claude is gud

204 files changed, 157511 insertions, 0 deletions

diff --git a/vere/ext/nasm/.gitattributes b/vere/ext/nasm/.gitattributes
new file mode 100644
index 0000000..d94c5fb
--- /dev/null
+++ b/vere/ext/nasm/.gitattributes
@@ -0,0 +1 @@
+/version -merge
diff --git a/vere/ext/nasm/.gitignore b/vere/ext/nasm/.gitignore
new file mode 100644
index 0000000..db3cb54
--- /dev/null
+++ b/vere/ext/nasm/.gitignore
@@ -0,0 +1,2 @@
+/.zig-cache/
+/zig-out/
diff --git a/vere/ext/nasm/LICENSE b/vere/ext/nasm/LICENSE
new file mode 100644
index 0000000..331e260
--- /dev/null
+++ b/vere/ext/nasm/LICENSE
@@ -0,0 +1,29 @@
+NASM is now licensed under the 2-clause BSD license, also known as the
+simplified BSD license.
+
+    Copyright 1996-2010 the NASM Authors - All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following
+    conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+      
+      THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+      CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+      INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+      DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+      CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+      SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+      NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+      LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+      CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+      OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+      EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vere/ext/nasm/README.md b/vere/ext/nasm/README.md
new file mode 100644
index 0000000..f17f214
--- /dev/null
+++ b/vere/ext/nasm/README.md
@@ -0,0 +1,24 @@
+This is a fork of [NASM](https://nasm.us/), packaged for Zig. Unnecessary files
+have been deleted, and the build system has been replaced with `build.zig`.
+
+Original README follows:
+
+----------------------------------------------------------------------------
+
+NASM, the Netwide Assembler
+===========================
+
+[![master](https://travis-ci.org/netwide-assembler/nasm.svg?branch=master)](https://travis-ci.org/netwide-assembler/nasm)
+
+Many many developers all over the net respect NASM for what it is:
+a widespread (thus netwide), portable (thus netwide!), very flexible
+and mature assembler tool with support for many output formats (thus netwide!!).
+
+Now we have good news for you: NASM is licensed under the "simplified"
+[(2-clause) BSD license](https://opensource.org/licenses/BSD-2-Clause).
+This means its development is open to even wider society of programmers
+wishing to improve their lovely assembler.
+
+Visit our [nasm.us](https://www.nasm.us/) website for more details.
+
+With best regards, the NASM crew.
diff --git a/vere/ext/nasm/asm/assemble.c b/vere/ext/nasm/asm/assemble.c
new file mode 100644
index 0000000..7eab5ce
--- /dev/null
+++ b/vere/ext/nasm/asm/assemble.c
@@ -0,0 +1,3411 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * assemble.c   code generation for the Netwide Assembler
+ *
+ * Bytecode specification
+ * ----------------------
+ *
+ *
+ * Codes            Mnemonic        Explanation
+ *
+ * \0                                       terminates the code. (Unless it's a literal of course.)
+ * \1..\4                                   that many literal bytes follow in the code stream
+ * \5                                       add 4 to the primary operand number (b, low octdigit)
+ * \6                                       add 4 to the secondary operand number (a, middle octdigit)
+ * \7                                       add 4 to both the primary and the secondary operand number
+ * \10..\13                                 a literal byte follows in the code stream, to be added
+ *                                          to the register value of operand 0..3
+ * \14..\17                                 the position of index register operand in MIB (BND insns)
+ * \20..\23         ib                      a byte immediate operand, from operand 0..3
+ * \24..\27         ib,u                    a zero-extended byte immediate operand, from operand 0..3
+ * \30..\33         iw                      a word immediate operand, from operand 0..3
+ * \34..\37         iwd                     select between \3[0-3] and \4[0-3] depending on 16/32 bit
+ *                                          assembly mode or the operand-size override on the operand
+ * \40..\43         id                      a long immediate operand, from operand 0..3
+ * \44..\47         iwdq                    select between \3[0-3], \4[0-3] and \5[4-7]
+ *                                          depending on the address size of the instruction.
+ * \50..\53         rel8                    a byte relative operand, from operand 0..3
+ * \54..\57         iq                      a qword immediate operand, from operand 0..3
+ * \60..\63         rel16                   a word relative operand, from operand 0..3
+ * \64..\67         rel                     select between \6[0-3] and \7[0-3] depending on 16/32 bit
+ *                                          assembly mode or the operand-size override on the operand
+ * \70..\73         rel32                   a long relative operand, from operand 0..3
+ * \74..\77         seg                     a word constant, from the _segment_ part of operand 0..3
+ * \1ab             /r                      a ModRM, calculated on EA in operand a, with the reg
+ *                                          field the register value of operand b.
+ * \171\mab         /mrb (e.g /3r0)         a ModRM, with the reg field taken from operand a, and the m
+ *                                          and b fields set to the specified values.
+ * \172\ab          /is4                    the register number from operand a in bits 7..4, with
+ *                                          the 4-bit immediate from operand b in bits 3..0.
+ * \173\xab                                 the register number from operand a in bits 7..4, with
+ *                                          the value b in bits 3..0.
+ * \174..\177                               the register number from operand 0..3 in bits 7..4, and
+ *                                          an arbitrary value in bits 3..0 (assembled as zero.)
+ * \2ab             /b                      a ModRM, calculated on EA in operand a, with the reg
+ *                                          field equal to digit b.
+ * \240..\243                               this instruction uses EVEX rather than REX or VEX/XOP, with the
+ *                                          V field taken from operand 0..3.
+ * \250                                     this instruction uses EVEX rather than REX or VEX/XOP, with the
+ *                                          V field set to 1111b.
+ *
+ * EVEX prefixes are followed by the sequence:
+ * \cm\wlp\tup    where cm is:
+ *                  cc 00m mmm
+ *                  c = 2 for EVEX and mmmm is the M field (EVEX.P0[3:0])
+ *                and wlp is:
+ *                  00 wwl lpp
+ *                  [l0]  ll = 0 (.128, .lz)
+ *                  [l1]  ll = 1 (.256)
+ *                  [l2]  ll = 2 (.512)
+ *                  [lig] ll = 3 for EVEX.L'L don't care (always assembled as 0)
+ *
+ *                  [w0]  ww = 0 for W = 0
+ *                  [w1]  ww = 1 for W = 1
+ *                  [wig] ww = 2 for W don't care (always assembled as 0)
+ *                  [ww]  ww = 3 for W used as REX.W
+ *
+ *                  [p0]  pp = 0 for no prefix
+ *                  [60]  pp = 1 for legacy prefix 60
+ *                  [f3]  pp = 2
+ *                  [f2]  pp = 3
+ *
+ *                tup is tuple type for Disp8*N from %tuple_codes in insns.pl
+ *                    (compressed displacement encoding)
+ *
+ * \254..\257       id,s                    a signed 32-bit operand to be extended to 64 bits.
+ * \260..\263                               this instruction uses VEX/XOP rather than REX, with the
+ *                                          V field taken from operand 0..3.
+ * \270                                     this instruction uses VEX/XOP rather than REX, with the
+ *                                          V field set to 1111b.
+ * VEX/XOP prefixes are followed by the sequence:
+ * \tmm\wlp        where mm is the M field; and wlp is:
+ *                 00 wwl lpp
+ *                 [l0]  ll = 0 for L = 0 (.128, .lz)
+ *                 [l1]  ll = 1 for L = 1 (.256)
+ *                 [lig] ll = 2 for L don't care (always assembled as 0)
+ *
+ *                 [w0]  ww = 0 for W = 0
+ *                 [w1 ] ww = 1 for W = 1
+ *                 [wig] ww = 2 for W don't care (always assembled as 0)
+ *                 [ww]  ww = 3 for W used as REX.W
+ *
+ * t = 0 for VEX (C4/C5), t = 1 for XOP (8F).
+ *
+ * \271             hlexr                       instruction takes XRELEASE (F3) with or without lock
+ * \272             hlenl                       instruction takes XACQUIRE/XRELEASE with or without lock
+ * \273             hle                         instruction takes XACQUIRE/XRELEASE with lock only
+ * \274..\277       ib,s                        a byte immediate operand, from operand 0..3, sign-extended
+ *                                              to the operand size (if o16/o32/o64 present) or the bit size
+ * \310             a16                         indicates fixed 16-bit address size, i.e. optional 0x67.
+ * \311             a32                         indicates fixed 32-bit address size, i.e. optional 0x67.
+ * \312             adf                         (disassembler only) invalid with non-default address size.
+ * \313             a64                         indicates fixed 64-bit address size, 0x67 invalid.
+ * \314             norexb                      (disassembler only) invalid with REX.B
+ * \315             norexx                      (disassembler only) invalid with REX.X
+ * \316             norexr                      (disassembler only) invalid with REX.R
+ * \317             norexw                      (disassembler only) invalid with REX.W
+ * \320             o16                         indicates fixed 16-bit operand size, i.e. optional 0x66.
+ * \321             o32                         indicates fixed 32-bit operand size, i.e. optional 0x66.
+ * \322             odf                         indicates that this instruction is only valid when the
+ *                                              operand size is the default (instruction to disassembler,
+ *                                              generates no code in the assembler)
+ * \323             o64nw                       indicates fixed 64-bit operand size, REX on extensions only.
+ * \324             o64                         indicates 64-bit operand size requiring REX prefix.
+ * \325             nohi                        instruction which always uses spl/bpl/sil/dil
+ * \326             nof3                        instruction not valid with 0xF3 REP prefix.  Hint for
+                                                disassembler only; for SSE instructions.
+ * \331             norep                       instruction not valid with REP prefix.  Hint for
+ *                                              disassembler only; for SSE instructions.
+ * \332             f2i                         REP prefix (0xF2 byte) used as opcode extension.
+ * \333             f3i                         REP prefix (0xF3 byte) used as opcode extension.
+ * \334             rex.l                       LOCK prefix used as REX.R (used in non-64-bit mode)
+ * \335             repe                        disassemble a rep (0xF3 byte) prefix as repe not rep.
+ * \336             mustrep                     force a REP(E) prefix (0xF3) even if not specified.
+ * \337             mustrepne                   force a REPNE prefix (0xF2) even if not specified.
+ *                                              \336-\337 are still listed as prefixes in the disassembler.
+ * \340             resb                        reserve <operand 0> bytes of uninitialized storage.
+ *                                              Operand 0 had better be a segmentless constant.
+ * \341             wait                        this instruction needs a WAIT "prefix"
+ * \360             np                          no SSE prefix (== \364\331)
+ * \361                                         66 SSE prefix (== \366\331)
+ * \364             !osp                        operand-size prefix (0x66) not permitted
+ * \365             !asp                        address-size prefix (0x67) not permitted
+ * \366                                         operand-size prefix (0x66) used as opcode extension
+ * \367                                         address-size prefix (0x67) used as opcode extension
+ * \370,\371        jcc8                        match only if operand 0 meets byte jump criteria.
+ *                  jmp8                        370 is used for Jcc, 371 is used for JMP.
+ * \373             jlen                        assemble 0x03 if bits==16, 0x05 if bits==32;
+ *                                              used for conditional jump over longer jump
+ * \374             vsibx|vm32x|vm64x           this instruction takes an XMM VSIB memory EA
+ * \375             vsiby|vm32y|vm64y           this instruction takes an YMM VSIB memory EA
+ * \376             vsibz|vm32z|vm64z           this instruction takes an ZMM VSIB memory EA
+ */
+
+#include "compiler.h"
+
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "assemble.h"
+#include "insns.h"
+#include "tables.h"
+#include "disp8.h"
+#include "listing.h"
+#include "dbginfo.h"
+
+enum match_result {
+    /*
+     * Matching errors.  These should be sorted so that more specific
+     * errors come later in the sequence.
+     */
+    MERR_INVALOP,
+    MERR_OPSIZEMISSING,
+    MERR_OPSIZEMISMATCH,
+    MERR_BRNOTHERE,
+    MERR_BRNUMMISMATCH,
+    MERR_MASKNOTHERE,
+    MERR_DECONOTHERE,
+    MERR_BADCPU,
+    MERR_BADMODE,
+    MERR_BADHLE,
+    MERR_ENCMISMATCH,
+    MERR_BADBND,
+    MERR_BADREPNE,
+    MERR_REGSETSIZE,
+    MERR_REGSET,
+    /*
+     * Matching success; the conditional ones first
+     */
+    MOK_JUMP,		/* Matching OK but needs jmp_match() */
+    MOK_GOOD		/* Matching unconditionally OK */
+};
+
+typedef struct {
+    enum ea_type type;            /* what kind of EA is this? */
+    int sib_present;              /* is a SIB byte necessary? */
+    int bytes;                    /* # of bytes of offset needed */
+    int size;                     /* lazy - this is sib+bytes+1 */
+    uint8_t modrm, sib, rex, rip; /* the bytes themselves */
+    int8_t disp8;                  /* compressed displacement for EVEX */
+} ea;
+
+#define GEN_SIB(scale, index, base)                 \
+        (((scale) << 6) | ((index) << 3) | ((base)))
+
+#define GEN_MODRM(mod, reg, rm)                     \
+        (((mod) << 6) | (((reg) & 7) << 3) | ((rm) & 7))
+
+static int64_t calcsize(int32_t, int64_t, int, insn *,
+                        const struct itemplate *);
+static int emit_prefix(struct out_data *data, const int bits, insn *ins);
+static void gencode(struct out_data *data, insn *ins);
+static enum match_result find_match(const struct itemplate **tempp,
+                                    insn *instruction,
+                                    int32_t segment, int64_t offset, int bits);
+static enum match_result matches(const struct itemplate *, insn *, int bits);
+static opflags_t regflag(const operand *);
+static int32_t regval(const operand *);
+static int rexflags(int, opflags_t, int);
+static int op_rexflags(const operand *, int);
+static int op_evexflags(const operand *, int, uint8_t);
+static void add_asp(insn *, int);
+
+static int process_ea(operand *, ea *, int, int, opflags_t,
+                      insn *, enum ea_type, const char **);
+
+static inline bool absolute_op(const struct operand *o)
+{
+    return o->segment == NO_SEG && o->wrt == NO_SEG &&
+        !(o->opflags & OPFLAG_RELATIVE);
+}
+
+static int has_prefix(insn * ins, enum prefix_pos pos, int prefix)
+{
+    return ins->prefixes[pos] == prefix;
+}
+
+static void assert_no_prefix(insn * ins, enum prefix_pos pos)
+{
+    if (ins->prefixes[pos])
+        nasm_nonfatal("invalid %s prefix", prefix_name(ins->prefixes[pos]));
+}
+
+static const char *size_name(int size)
+{
+    switch (size) {
+    case 1:
+        return "byte";
+    case 2:
+        return "word";
+    case 4:
+        return "dword";
+    case 8:
+        return "qword";
+    case 10:
+        return "tword";
+    case 16:
+        return "oword";
+    case 32:
+        return "yword";
+    case 64:
+        return "zword";
+    default:
+        return "???";
+    }
+}
+
+static void warn_overflow(int size)
+{
+    nasm_warn(ERR_PASS2 | WARN_NUMBER_OVERFLOW, "%s data exceeds bounds",
+               size_name(size));
+}
+
+static void warn_overflow_const(int64_t data, int size)
+{
+    if (overflow_general(data, size))
+        warn_overflow(size);
+}
+
+static void warn_overflow_out(int64_t data, int size, enum out_flags flags)
+{
+    bool err;
+
+    if (flags & OUT_SIGNED)
+        err = overflow_signed(data, size);
+    else if (flags & OUT_UNSIGNED)
+        err = overflow_unsigned(data, size);
+    else
+        err = overflow_general(data, size);
+
+    if (err)
+        warn_overflow(size);
+}
+
+/*
+ * Collect macro-related debug information, if applicable.
+ */
+static void debug_macro_out(const struct out_data *data)
+{
+    struct debug_macro_addr *addr;
+    uint64_t start = data->offset;
+    uint64_t end  = start + data->size;
+
+    addr = debug_macro_get_addr(data->segment);
+    while (addr) {
+        if (!addr->len)
+            addr->start = start;
+        addr->len = end - addr->start;
+        addr = addr->up;
+    }
+}
+
+/*
+ * This routine wrappers the real output format's output routine,
+ * in order to pass a copy of the data off to the listing file
+ * generator at the same time, flatten unnecessary relocations,
+ * and verify backend compatibility.
+ */
+/*
+ * This warning is currently issued by backends, but in the future
+ * this code should be centralized.
+ *
+ *!zeroing [on] RESx in initialized section becomes zero
+ *!  a \c{RESx} directive was used in a section which contains
+ *!  initialized data, and the output format does not support
+ *!  this. Instead, this will be replaced with explicit zero
+ *!  content, which may produce a large output file.
+ */
+static void out(struct out_data *data)
+{
+    static struct last_debug_info {
+        struct src_location where;
+        int32_t segment;
+    } dbg;
+    union {
+        uint8_t b[8];
+        uint64_t q;
+    } xdata;
+    size_t asize, amax;
+    uint64_t zeropad = 0;
+    int64_t addrval;
+    int32_t fixseg;             /* Segment for which to produce fixed data */
+
+    if (!data->size)
+        return;                 /* Nothing to do */
+
+    /*
+     * Convert addresses to RAWDATA if possible
+     * XXX: not all backends want this for global symbols!!!!
+     */
+    switch (data->type) {
+    case OUT_ADDRESS:
+        addrval = data->toffset;
+        fixseg = NO_SEG;        /* Absolute address is fixed data */
+        goto address;
+
+    case OUT_RELADDR:
+        addrval = data->toffset - data->relbase;
+        fixseg = data->segment; /* Our own segment is fixed data */
+        goto address;
+
+    address:
+        nasm_assert(data->size <= 8);
+        asize = data->size;
+        amax = ofmt->maxbits >> 3; /* Maximum address size in bytes */
+        if (!(ofmt->flags & OFMT_KEEP_ADDR) &&
+            data->tsegment == fixseg &&
+            data->twrt == NO_SEG) {
+            if (asize >= (size_t)(data->bits >> 3)) {
+                 /* Support address space wrapping for low-bit modes */
+                data->flags &= ~OUT_SIGNMASK;
+            }
+            warn_overflow_out(addrval, asize, data->flags);
+            xdata.q = cpu_to_le64(addrval);
+            data->data = xdata.b;
+            data->type = OUT_RAWDATA;
+            asize = amax = 0;   /* No longer an address */
+        }
+        break;
+
+    case OUT_SEGMENT:
+        nasm_assert(data->size <= 8);
+        asize = data->size;
+        amax = 2;
+        break;
+
+    default:
+        asize = amax = 0;       /* Not an address */
+        break;
+    }
+
+    /*
+     * If the source location or output segment has changed,
+     * let the debug backend know. Some backends really don't
+     * like being given a NULL filename as can happen if we
+     * use -Lb and expand a macro, so filter out that case.
+     */
+    data->where = src_where();
+    if (data->where.filename &&
+        (!src_location_same(data->where, dbg.where) |
+         (data->segment != dbg.segment))) {
+        dbg.where   = data->where;
+        dbg.segment = data->segment;
+        dfmt->linenum(dbg.where.filename, dbg.where.lineno, data->segment);
+    }
+
+    if (asize > amax) {
+        if (data->type == OUT_RELADDR || (data->flags & OUT_SIGNED)) {
+            nasm_nonfatal("%u-bit signed relocation unsupported by output format %s",
+                          (unsigned int)(asize << 3), ofmt->shortname);
+        } else {
+            /*!
+             *!zext-reloc [on] relocation zero-extended to match output format
+             *!  warns that a relocation has been zero-extended due
+             *!  to limitations in the output format.
+             */
+            nasm_warn(WARN_ZEXT_RELOC,
+                       "%u-bit %s relocation zero-extended from %u bits",
+                       (unsigned int)(asize << 3),
+                       data->type == OUT_SEGMENT ? "segment" : "unsigned",
+                       (unsigned int)(amax << 3));
+        }
+        zeropad = data->size - amax;
+        data->size = amax;
+    }
+    lfmt->output(data);
+
+    if (likely(data->segment != NO_SEG)) {
+        /*
+         * Collect macro-related information for the debugger, if applicable
+         */
+        if (debug_current_macro)
+            debug_macro_out(data);
+
+        ofmt->output(data);
+    } else {
+        /* Outputting to ABSOLUTE section - only reserve is permitted */
+        if (data->type != OUT_RESERVE)
+            nasm_nonfatal("attempt to assemble code in [ABSOLUTE] space");
+        /* No need to push to the backend */
+    }
+
+    data->offset  += data->size;
+    data->insoffs += data->size;
+
+    if (zeropad) {
+        data->type     = OUT_ZERODATA;
+        data->size     = zeropad;
+        lfmt->output(data);
+        ofmt->output(data);
+        data->offset  += zeropad;
+        data->insoffs += zeropad;
+        data->size    += zeropad;  /* Restore original size value */
+    }
+}
+
+static inline void out_rawdata(struct out_data *data, const void *rawdata,
+                               size_t size)
+{
+    data->type = OUT_RAWDATA;
+    data->data = rawdata;
+    data->size = size;
+    out(data);
+}
+
+static void out_rawbyte(struct out_data *data, uint8_t byte)
+{
+    data->type = OUT_RAWDATA;
+    data->data = &byte;
+    data->size = 1;
+    out(data);
+}
+
+static inline void out_reserve(struct out_data *data, uint64_t size)
+{
+    data->type = OUT_RESERVE;
+    data->size = size;
+    out(data);
+}
+
+static void out_segment(struct out_data *data, const struct operand *opx)
+{
+    if (opx->opflags & OPFLAG_RELATIVE)
+        nasm_nonfatal("segment references cannot be relative");
+
+    data->type      = OUT_SEGMENT;
+    data->flags     = OUT_UNSIGNED;
+    data->size      = 2;
+    data->toffset   = opx->offset;
+    data->tsegment  = ofmt->segbase(opx->segment | 1);
+    data->twrt      = opx->wrt;
+    out(data);
+}
+
+static void out_imm(struct out_data *data, const struct operand *opx,
+                    int size, enum out_flags sign)
+{
+    if (opx->segment != NO_SEG && (opx->segment & 1)) {
+        /*
+         * This is actually a segment reference, but eval() has
+         * already called ofmt->segbase() for us.  Sigh.
+         */
+        if (size < 2)
+            nasm_nonfatal("segment reference must be 16 bits");
+
+        data->type = OUT_SEGMENT;
+    } else {
+        data->type = (opx->opflags & OPFLAG_RELATIVE)
+            ? OUT_RELADDR : OUT_ADDRESS;
+    }
+    data->flags    = sign;
+    data->toffset  = opx->offset;
+    data->tsegment = opx->segment;
+    data->twrt     = opx->wrt;
+    /*
+     * XXX: improve this if at some point in the future we can
+     * distinguish the subtrahend in expressions like [foo - bar]
+     * where bar is a symbol in the current segment.  However, at the
+     * current point, if OPFLAG_RELATIVE is set that subtraction has
+     * already occurred.
+     */
+    data->relbase = 0;
+    data->size = size;
+    out(data);
+}
+
+static void out_reladdr(struct out_data *data, const struct operand *opx,
+                        int size)
+{
+    if (opx->opflags & OPFLAG_RELATIVE)
+        nasm_nonfatal("invalid use of self-relative expression");
+
+    data->type     = OUT_RELADDR;
+    data->flags    = OUT_SIGNED;
+    data->size     = size;
+    data->toffset  = opx->offset;
+    data->tsegment = opx->segment;
+    data->twrt     = opx->wrt;
+    data->relbase  = data->offset + (data->inslen - data->insoffs);
+    out(data);
+}
+
+static bool jmp_match(int32_t segment, int64_t offset, int bits,
+                      insn * ins, const struct itemplate *temp)
+{
+    int64_t isize;
+    const uint8_t *code = temp->code;
+    uint8_t c = code[0];
+    bool is_byte;
+
+    if (((c & ~1) != 0370) || (ins->oprs[0].type & STRICT))
+        return false;
+    if (!optimizing.level || (optimizing.flag & OPTIM_DISABLE_JMP_MATCH))
+        return false;
+    if (optimizing.level < 0 && c == 0371)
+        return false;
+
+    isize = calcsize(segment, offset, bits, ins, temp);
+
+    if (ins->oprs[0].opflags & OPFLAG_UNKNOWN)
+        /* Be optimistic in pass 1 */
+        return true;
+
+    if (ins->oprs[0].segment != segment)
+        return false;
+
+    isize = ins->oprs[0].offset - offset - isize; /* isize is delta */
+    is_byte = (isize >= -128 && isize <= 127); /* is it byte size? */
+
+    if (is_byte && c == 0371 && ins->prefixes[PPS_REP] == P_BND) {
+        /* jmp short (opcode eb) cannot be used with bnd prefix. */
+        ins->prefixes[PPS_REP] = P_none;
+        /*!
+         *!prefix-bnd [on] invalid BND prefix
+         *!=bnd
+         *!  warns about ineffective use of the \c{BND} prefix when the
+         *!  \c{JMP} instruction is converted to the \c{SHORT} form.
+         *!  This should be extremely rare since the short \c{JMP} only
+         *!  is applicable to jumps inside the same module, but if
+         *!  it is legitimate, it may be necessary to use
+         *!  \c{bnd jmp dword}.
+         */
+        nasm_warn(WARN_PREFIX_BND|ERR_PASS2 ,
+                   "jmp short does not init bnd regs - bnd prefix dropped");
+    }
+
+    return is_byte;
+}
+
+static inline int64_t merge_resb(insn *ins, int64_t isize)
+{
+    int nbytes = resb_bytes(ins->opcode);
+
+    if (likely(!nbytes))
+        return isize;
+
+    if (isize != nbytes * ins->oprs[0].offset)
+        return isize;           /* Has prefixes of some sort */
+
+    ins->oprs[0].offset *= ins->times;
+    isize *= ins->times;
+    ins->times = 1;
+    return isize;
+}
+
+/* This must be handle non-power-of-2 alignment values */
+static inline size_t pad_bytes(size_t len, size_t align)
+{
+    size_t partial = len % align;
+    return partial ? align - partial : 0;
+}
+
+static void out_eops(struct out_data *data, const extop *e)
+{
+    while (e) {
+        size_t dup = e->dup;
+
+        switch (e->type) {
+        case EOT_NOTHING:
+            break;
+
+        case EOT_EXTOP:
+            while (dup--)
+                out_eops(data, e->val.subexpr);
+            break;
+
+        case EOT_DB_NUMBER:
+            if (e->elem > 8) {
+                nasm_nonfatal("integer supplied as %d-bit data",
+                              e->elem << 3);
+            } else {
+                while (dup--) {
+                    data->insoffs = 0;
+                    data->inslen = data->size = e->elem;
+                    data->tsegment = e->val.num.segment;
+                    data->toffset  = e->val.num.offset;
+                    data->twrt = e->val.num.wrt;
+                    data->relbase = 0;
+                    if (e->val.num.segment != NO_SEG &&
+                        (e->val.num.segment & 1)) {
+                        data->type  = OUT_SEGMENT;
+                        data->flags = OUT_UNSIGNED;
+                    } else {
+                        data->type = e->val.num.relative
+                            ? OUT_RELADDR : OUT_ADDRESS;
+                        data->flags = OUT_WRAP;
+                    }
+                    out(data);
+                }
+            }
+            break;
+
+        case EOT_DB_FLOAT:
+        case EOT_DB_STRING:
+        case EOT_DB_STRING_FREE:
+        {
+            size_t pad, len;
+
+            pad = pad_bytes(e->val.string.len, e->elem);
+            len = e->val.string.len + pad;
+
+            while (dup--) {
+                data->insoffs = 0;
+                data->inslen = len;
+                out_rawdata(data, e->val.string.data, e->val.string.len);
+                if (pad)
+                    out_rawdata(data, zero_buffer, pad);
+            }
+            break;
+        }
+
+        case EOT_DB_RESERVE:
+            data->insoffs = 0;
+            data->inslen = dup * e->elem;
+            out_reserve(data, data->inslen);
+            break;
+        }
+
+        e = e->next;
+    }
+}
+
+/* This is totally just a wild guess what is reasonable... */
+#define INCBIN_MAX_BUF (ZERO_BUF_SIZE * 16)
+
+int64_t assemble(int32_t segment, int64_t start, int bits, insn *instruction)
+{
+    struct out_data data;
+    const struct itemplate *temp;
+    enum match_result m;
+
+    if (instruction->opcode == I_none)
+        return 0;
+
+    nasm_zero(data);
+    data.offset = start;
+    data.segment = segment;
+    data.itemp = NULL;
+    data.bits = bits;
+
+    if (opcode_is_db(instruction->opcode)) {
+        out_eops(&data, instruction->eops);
+    } else if (instruction->opcode == I_INCBIN) {
+        const char *fname = instruction->eops->val.string.data;
+        FILE *fp;
+        size_t t = instruction->times; /* INCBIN handles TIMES by itself */
+        off_t base = 0;
+        off_t len;
+        const void *map = NULL;
+        char *buf = NULL;
+        size_t blk = 0;         /* Buffered I/O block size */
+        size_t m = 0;           /* Bytes last read */
+
+        if (!t)
+            goto done;
+
+        fp = nasm_open_read(fname, NF_BINARY|NF_FORMAP);
+        if (!fp) {
+            nasm_nonfatal("`incbin': unable to open file `%s'",
+                          fname);
+            goto done;
+        }
+
+        len = nasm_file_size(fp);
+
+        if (len == (off_t)-1) {
+            nasm_nonfatal("`incbin': unable to get length of file `%s'",
+                          fname);
+            goto close_done;
+        }
+
+        if (instruction->eops->next) {
+            base = instruction->eops->next->val.num.offset;
+            if (base >= len) {
+                len = 0;
+            } else {
+                len -= base;
+                if (instruction->eops->next->next &&
+                    len > (off_t)instruction->eops->next->next->val.num.offset)
+                    len = (off_t)instruction->eops->next->next->val.num.offset;
+            }
+        }
+
+        lfmt->set_offset(data.offset);
+        lfmt->uplevel(LIST_INCBIN, len);
+
+        if (!len)
+            goto end_incbin;
+
+        /* Try to map file data */
+        map = nasm_map_file(fp, base, len);
+        if (!map) {
+            blk = len < (off_t)INCBIN_MAX_BUF ? (size_t)len : INCBIN_MAX_BUF;
+            buf = nasm_malloc(blk);
+        }
+
+        while (t--) {
+            /*
+             * Consider these irrelevant for INCBIN, since it is fully
+             * possible that these might be (way) bigger than an int
+             * can hold; there is, however, no reason to widen these
+             * types just for INCBIN.  data.inslen == 0 signals to the
+             * backend that these fields are meaningless, if at all
+             * needed.
+             */
+            data.insoffs = 0;
+            data.inslen = 0;
+
+            if (map) {
+                out_rawdata(&data, map, len);
+            } else if ((off_t)m == len) {
+                out_rawdata(&data, buf, len);
+            } else {
+                off_t l = len;
+
+                if (fseeko(fp, base, SEEK_SET) < 0 || ferror(fp)) {
+                    nasm_nonfatal("`incbin': unable to seek on file `%s'",
+                                  fname);
+                    goto end_incbin;
+                }
+                while (l > 0) {
+                    m = fread(buf, 1, l < (off_t)blk ? (size_t)l : blk, fp);
+                    if (!m || feof(fp)) {
+                        /*
+                         * This shouldn't happen unless the file
+                         * actually changes while we are reading
+                         * it.
+                         */
+                        nasm_nonfatal("`incbin': unexpected EOF while"
+                                      " reading file `%s'", fname);
+                        goto end_incbin;
+                    }
+                    out_rawdata(&data, buf, m);
+                    l -= m;
+                }
+            }
+        }
+    end_incbin:
+        lfmt->downlevel(LIST_INCBIN);
+        if (instruction->times > 1) {
+            lfmt->uplevel(LIST_TIMES, instruction->times);
+            lfmt->downlevel(LIST_TIMES);
+        }
+        if (ferror(fp)) {
+            nasm_nonfatal("`incbin': error while"
+                          " reading file `%s'", fname);
+        }
+    close_done:
+        if (buf)
+            nasm_free(buf);
+        if (map)
+            nasm_unmap_file(map, len);
+        fclose(fp);
+    done:
+        instruction->times = 1; /* Tell the upper layer not to iterate */
+        ;
+    } else {
+        /* "Real" instruction */
+
+        /* Check to see if we need an address-size prefix */
+        add_asp(instruction, bits);
+
+        m = find_match(&temp, instruction, data.segment, data.offset, bits);
+
+        if (m == MOK_GOOD) {
+            /* Matches! */
+            if (unlikely(itemp_has(temp, IF_OBSOLETE))) {
+                errflags warning;
+                const char *whathappened;
+                const char *validity;
+                bool never = itemp_has(temp, IF_NEVER);
+
+                /*
+                 * If IF_OBSOLETE is set, warn the user. Different
+                 * warning classes for "obsolete but valid for this
+                 * specific CPU" and "obsolete and gone."
+                 *
+                 *!obsolete-removed [on] instruction obsolete and removed on the target CPU
+                 *!  warns for an instruction which has been removed
+                 *!  from the architecture, and is no longer included
+                 *!  in the CPU definition given in the \c{[CPU]}
+                 *!  directive, for example \c{POP CS}, the opcode for
+                 *!  which, \c{0Fh}, instead is an opcode prefix on
+                 *!  CPUs newer than the first generation 8086.
+                 *
+                 *!obsolete-nop [on] instruction obsolete and is a noop on the target CPU
+                 *!  warns for an instruction which has been removed
+                 *!  from the architecture, but has been architecturally
+                 *!  defined to be a noop for future CPUs.
+                 *
+                 *!obsolete-valid [on] instruction obsolete but valid on the target CPU
+                 *!  warns for an instruction which has been removed
+                 *!  from the architecture, but is still valid on the
+                 *!  specific CPU given in the \c{CPU} directive. Code
+                 *!  using these instructions is most likely not
+                 *!  forward compatible.
+                 */
+
+                whathappened = never ? "never implemented" : "obsolete";
+
+                if (!never && !iflag_cmp_cpu_level(&insns_flags[temp->iflag_idx], &cpu)) {
+                    warning = WARN_OBSOLETE_VALID;
+                    validity = "but valid on";
+                } else if (itemp_has(temp, IF_NOP)) {
+                    warning = WARN_OBSOLETE_NOP;
+                    validity = "and is a noop on";
+                } else {
+                    warning = WARN_OBSOLETE_REMOVED;
+                    validity = never ? "and invalid on" : "and removed from";
+                }
+
+                nasm_warn(warning, "instruction %s %s the target CPU",
+                          whathappened, validity);
+            }
+
+            data.itemp = temp;
+            data.bits = bits;
+            data.insoffs = 0;
+
+            data.inslen = calcsize(data.segment, data.offset,
+                                   bits, instruction, temp);
+            nasm_assert(data.inslen >= 0);
+            data.inslen = merge_resb(instruction, data.inslen);
+
+            gencode(&data, instruction);
+            nasm_assert(data.insoffs == data.inslen);
+        } else {
+            /* No match */
+            switch (m) {
+            case MERR_OPSIZEMISSING:
+                nasm_nonfatal("operation size not specified");
+                break;
+            case MERR_OPSIZEMISMATCH:
+                nasm_nonfatal("mismatch in operand sizes");
+                break;
+            case MERR_BRNOTHERE:
+                nasm_nonfatal("broadcast not permitted on this operand");
+                break;
+            case MERR_BRNUMMISMATCH:
+                nasm_nonfatal("mismatch in the number of broadcasting elements");
+                break;
+            case MERR_MASKNOTHERE:
+                nasm_nonfatal("mask not permitted on this operand");
+                break;
+            case MERR_DECONOTHERE:
+                nasm_nonfatal("unsupported mode decorator for instruction");
+                break;
+            case MERR_BADCPU:
+                nasm_nonfatal("no instruction for this cpu level");
+                break;
+            case MERR_BADMODE:
+                nasm_nonfatal("instruction not supported in %d-bit mode", bits);
+                break;
+            case MERR_ENCMISMATCH:
+                if (!instruction->prefixes[PPS_REX]) {
+                    nasm_nonfatal("instruction not encodable without explicit prefix");
+                } else {
+                    nasm_nonfatal("instruction not encodable with %s prefix",
+                                  prefix_name(instruction->prefixes[PPS_REX]));
+                }
+                break;
+            case MERR_BADBND:
+            case MERR_BADREPNE:
+                nasm_nonfatal("%s prefix is not allowed",
+                              prefix_name(instruction->prefixes[PPS_REP]));
+                break;
+            case MERR_REGSETSIZE:
+                nasm_nonfatal("invalid register set size");
+                break;
+            case MERR_REGSET:
+                nasm_nonfatal("register set not valid for operand");
+                break;
+            default:
+                nasm_nonfatal("invalid combination of opcode and operands");
+                break;
+            }
+
+            instruction->times = 1; /* Avoid repeated error messages */
+        }
+    }
+    return data.offset - start;
+}
+
+static int32_t eops_typeinfo(const extop *e)
+{
+    int32_t typeinfo = 0;
+
+    while (e) {
+        switch (e->type) {
+        case EOT_NOTHING:
+            break;
+
+        case EOT_EXTOP:
+            typeinfo |= eops_typeinfo(e->val.subexpr);
+            break;
+
+        case EOT_DB_FLOAT:
+            switch (e->elem) {
+            case  1: typeinfo |= TY_BYTE;  break;
+            case  2: typeinfo |= TY_WORD;  break;
+            case  4: typeinfo |= TY_FLOAT; break;
+            case  8: typeinfo |= TY_QWORD; break; /* double? */
+            case 10: typeinfo |= TY_TBYTE; break; /* long double? */
+            case 16: typeinfo |= TY_YWORD; break;
+            case 32: typeinfo |= TY_ZWORD; break;
+            default: break;
+            }
+            break;
+
+        default:
+            switch (e->elem) {
+            case  1: typeinfo |= TY_BYTE;  break;
+            case  2: typeinfo |= TY_WORD;  break;
+            case  4: typeinfo |= TY_DWORD; break;
+            case  8: typeinfo |= TY_QWORD; break;
+            case 10: typeinfo |= TY_TBYTE; break;
+            case 16: typeinfo |= TY_YWORD; break;
+            case 32: typeinfo |= TY_ZWORD; break;
+            default: break;
+            }
+            break;
+        }
+        e = e->next;
+    }
+
+    return typeinfo;
+}
+
+static inline void debug_set_db_type(insn *instruction)
+{
+
+    int32_t typeinfo = TYS_ELEMENTS(instruction->operands);
+
+    typeinfo |= eops_typeinfo(instruction->eops);
+    dfmt->debug_typevalue(typeinfo);
+}
+
+static void debug_set_type(insn *instruction)
+{
+    int32_t typeinfo;
+
+    if (opcode_is_resb(instruction->opcode)) {
+        typeinfo = TYS_ELEMENTS(instruction->oprs[0].offset);
+
+        switch (instruction->opcode) {
+        case I_RESB:
+            typeinfo |= TY_BYTE;
+            break;
+        case I_RESW:
+            typeinfo |= TY_WORD;
+            break;
+        case I_RESD:
+            typeinfo |= TY_DWORD;
+            break;
+        case I_RESQ:
+            typeinfo |= TY_QWORD;
+            break;
+        case I_REST:
+            typeinfo |= TY_TBYTE;
+            break;
+        case I_RESO:
+            typeinfo |= TY_OWORD;
+            break;
+        case I_RESY:
+            typeinfo |= TY_YWORD;
+            break;
+        case I_RESZ:
+            typeinfo |= TY_ZWORD;
+            break;
+        default:
+            panic();
+        }
+    } else {
+        typeinfo = TY_LABEL;
+    }
+
+    dfmt->debug_typevalue(typeinfo);
+}
+
+
+/* Proecess an EQU directive */
+static void define_equ(insn * instruction)
+{
+    if (!instruction->label) {
+        nasm_nonfatal("EQU not preceded by label");
+    } else if (instruction->operands == 1 &&
+               (instruction->oprs[0].type & IMMEDIATE) &&
+               instruction->oprs[0].wrt == NO_SEG) {
+        define_label(instruction->label,
+                     instruction->oprs[0].segment,
+                     instruction->oprs[0].offset, false);
+    } else if (instruction->operands == 2
+               && (instruction->oprs[0].type & IMMEDIATE)
+               && (instruction->oprs[0].type & COLON)
+               && instruction->oprs[0].segment == NO_SEG
+               && instruction->oprs[0].wrt == NO_SEG
+               && (instruction->oprs[1].type & IMMEDIATE)
+               && instruction->oprs[1].segment == NO_SEG
+               && instruction->oprs[1].wrt == NO_SEG) {
+        define_label(instruction->label,
+                     instruction->oprs[0].offset | SEG_ABS,
+                     instruction->oprs[1].offset, false);
+    } else {
+        nasm_nonfatal("bad syntax for EQU");
+    }
+}
+
+static int64_t len_extops(const extop *e)
+{
+    int64_t isize = 0;
+    size_t pad;
+
+    while (e) {
+        switch (e->type) {
+        case EOT_NOTHING:
+            break;
+
+        case EOT_EXTOP:
+            isize += e->dup * len_extops(e->val.subexpr);
+            break;
+
+        case EOT_DB_STRING:
+        case EOT_DB_STRING_FREE:
+        case EOT_DB_FLOAT:
+            pad = pad_bytes(e->val.string.len, e->elem);
+            isize += e->dup * (e->val.string.len + pad);
+            break;
+
+        case EOT_DB_NUMBER:
+            warn_overflow_const(e->val.num.offset, e->elem);
+            isize += e->dup * e->elem;
+            break;
+
+        case EOT_DB_RESERVE:
+            isize += e->dup * e->elem;
+            break;
+        }
+
+        e = e->next;
+    }
+
+    return isize;
+}
+
+int64_t insn_size(int32_t segment, int64_t offset, int bits, insn *instruction)
+{
+    const struct itemplate *temp;
+    enum match_result m;
+    int64_t isize = 0;
+
+    if (instruction->opcode == I_none) {
+        return 0;
+    } else if (instruction->opcode == I_EQU) {
+        define_equ(instruction);
+        return 0;
+    } else if (opcode_is_db(instruction->opcode)) {
+        isize = len_extops(instruction->eops);
+        debug_set_db_type(instruction);
+        return isize;
+    } else if (instruction->opcode == I_INCBIN) {
+        const extop *e = instruction->eops;
+        const char *fname = e->val.string.data;
+        off_t len;
+
+        len = nasm_file_size_by_path(fname);
+        if (len == (off_t)-1) {
+            nasm_nonfatal("`incbin': unable to get length of file `%s'",
+                          fname);
+            return 0;
+        }
+
+        e = e->next;
+        if (e) {
+            if (len <= (off_t)e->val.num.offset) {
+                len = 0;
+            } else {
+                len -= e->val.num.offset;
+                e = e->next;
+                if (e && len > (off_t)e->val.num.offset) {
+                    len = (off_t)e->val.num.offset;
+                }
+            }
+        }
+
+        len *= instruction->times;
+        instruction->times = 1; /* Tell the upper layer to not iterate */
+
+        return len;
+    } else {
+        /* Normal instruction, or RESx */
+
+        /* Check to see if we need an address-size prefix */
+        add_asp(instruction, bits);
+
+        m = find_match(&temp, instruction, segment, offset, bits);
+        if (m != MOK_GOOD)
+            return -1;              /* No match */
+
+        isize = calcsize(segment, offset, bits, instruction, temp);
+        debug_set_type(instruction);
+        isize = merge_resb(instruction, isize);
+
+        return isize;
+    }
+}
+
+static void bad_hle_warn(const insn * ins, uint8_t hleok)
+{
+    enum prefixes rep_pfx = ins->prefixes[PPS_REP];
+    enum whatwarn { w_none, w_lock, w_inval } ww;
+    static const enum whatwarn warn[2][4] =
+    {
+        { w_inval, w_inval, w_none, w_lock }, /* XACQUIRE */
+        { w_inval, w_none,  w_none, w_lock }, /* XRELEASE */
+    };
+    unsigned int n;
+
+    n = (unsigned int)rep_pfx - P_XACQUIRE;
+    if (n > 1)
+        return;                 /* Not XACQUIRE/XRELEASE */
+
+    ww = warn[n][hleok];
+    if (!is_class(MEMORY, ins->oprs[0].type))
+        ww = w_inval;           /* HLE requires operand 0 to be memory */
+
+    /*!
+     *!prefix-hle [on] invalid HLE prefix
+     *!=hle
+     *!  warns about invalid use of the HLE \c{XACQUIRE} or \c{XRELEASE}
+     *!  prefixes.
+     */
+    switch (ww) {
+    case w_none:
+        break;
+
+    case w_lock:
+        if (ins->prefixes[PPS_LOCK] != P_LOCK) {
+            nasm_warn(WARN_PREFIX_HLE|ERR_PASS2,
+                       "%s with this instruction requires lock",
+                       prefix_name(rep_pfx));
+        }
+        break;
+
+    case w_inval:
+        nasm_warn(WARN_PREFIX_HLE|ERR_PASS2,
+                   "%s invalid with this instruction",
+                   prefix_name(rep_pfx));
+        break;
+    }
+}
+
+/* Common construct */
+#define case3(x) case (x): case (x)+1: case (x)+2
+#define case4(x) case3(x): case (x)+3
+
+static int64_t calcsize(int32_t segment, int64_t offset, int bits,
+                        insn * ins, const struct itemplate *temp)
+{
+    const uint8_t *codes = temp->code;
+    int64_t length = 0;
+    uint8_t c;
+    int rex_mask = ~0;
+    int op1, op2;
+    struct operand *opx;
+    uint8_t opex = 0;
+    enum ea_type eat;
+    uint8_t hleok = 0;
+    bool lockcheck = true;
+    enum reg_enum mib_index = R_none;   /* For a separate index reg form */
+    const char *errmsg;
+
+    ins->rex = 0;               /* Ensure REX is reset */
+    eat = EA_SCALAR;            /* Expect a scalar EA */
+    memset(ins->evex_p, 0, 3);  /* Ensure EVEX is reset */
+
+    if (ins->prefixes[PPS_OSIZE] == P_O64)
+        ins->rex |= REX_W;
+
+    (void)segment;              /* Don't warn that this parameter is unused */
+    (void)offset;               /* Don't warn that this parameter is unused */
+
+    while (*codes) {
+        c = *codes++;
+        op1 = (c & 3) + ((opex & 1) << 2);
+        op2 = ((c >> 3) & 3) + ((opex & 2) << 1);
+        opx = &ins->oprs[op1];
+        opex = 0;               /* For the next iteration */
+
+        switch (c) {
+        case4(01):
+            codes += c, length += c;
+            break;
+
+        case3(05):
+            opex = c;
+            break;
+
+        case4(010):
+            ins->rex |=
+                op_rexflags(opx, REX_B|REX_H|REX_P|REX_W);
+            codes++, length++;
+            break;
+
+        case4(014):
+            /* this is an index reg of a split SIB operand */
+            mib_index = opx->basereg;
+            break;
+
+        case4(020):
+        case4(024):
+            length++;
+            break;
+
+        case4(030):
+            length += 2;
+            break;
+
+        case4(034):
+            if (opx->type & (BITS16 | BITS32 | BITS64))
+                length += (opx->type & BITS16) ? 2 : 4;
+            else
+                length += (bits == 16) ? 2 : 4;
+            break;
+
+        case4(040):
+            length += 4;
+            break;
+
+        case4(044):
+            length += ins->addr_size >> 3;
+            break;
+
+        case4(050):
+            length++;
+            break;
+
+        case4(054):
+            length += 8; /* MOV reg64/imm */
+            break;
+
+        case4(060):
+            length += 2;
+            break;
+
+        case4(064):
+            if (opx->type & (BITS16 | BITS32 | BITS64))
+                length += (opx->type & BITS16) ? 2 : 4;
+            else
+                length += (bits == 16) ? 2 : 4;
+            break;
+
+        case4(070):
+            length += 4;
+            break;
+
+        case4(074):
+            length += 2;
+            break;
+
+        case 0171:
+            c = *codes++;
+            op2 = (op2 & ~3) | ((c >> 3) & 3);
+            opx = &ins->oprs[op2];
+            ins->rex |= op_rexflags(opx, REX_R|REX_H|REX_P|REX_W);
+            length++;
+            break;
+
+        case 0172:
+        case 0173:
+            codes++;
+            length++;
+            break;
+
+        case4(0174):
+            length++;
+            break;
+
+        case4(0240):
+            ins->rex |= REX_EV;
+            ins->vexreg = regval(opx);
+            ins->evex_p[2] |= op_evexflags(opx, EVEX_P2VP, 2); /* High-16 NDS */
+            ins->vex_cm = *codes++;
+            ins->vex_wlp = *codes++;
+            ins->evex_tuple = (*codes++ - 0300);
+            break;
+
+        case 0250:
+            ins->rex |= REX_EV;
+            ins->vexreg = 0;
+            ins->vex_cm = *codes++;
+            ins->vex_wlp = *codes++;
+            ins->evex_tuple = (*codes++ - 0300);
+            break;
+
+        case4(0254):
+            length += 4;
+            break;
+
+        case4(0260):
+            ins->rex |= REX_V;
+            ins->vexreg = regval(opx);
+            ins->vex_cm = *codes++;
+            ins->vex_wlp = *codes++;
+            break;
+
+        case 0270:
+            ins->rex |= REX_V;
+            ins->vexreg = 0;
+            ins->vex_cm = *codes++;
+            ins->vex_wlp = *codes++;
+            break;
+
+        case3(0271):
+            hleok = c & 3;
+            break;
+
+        case4(0274):
+            length++;
+            break;
+
+        case4(0300):
+            break;
+
+        case 0310:
+            if (bits == 64)
+                return -1;
+            length += (bits != 16) && !has_prefix(ins, PPS_ASIZE, P_A16);
+            break;
+
+        case 0311:
+            length += (bits != 32) && !has_prefix(ins, PPS_ASIZE, P_A32);
+            break;
+
+        case 0312:
+            break;
+
+        case 0313:
+            if (bits != 64 || has_prefix(ins, PPS_ASIZE, P_A16) ||
+                has_prefix(ins, PPS_ASIZE, P_A32))
+                return -1;
+            break;
+
+        case4(0314):
+            break;
+
+        case 0320:
+        {
+            /*! prefix-opsize [on] invalid operand size prefix
+             *!   warns that an operand prefix (\c{o16}, \c{o32}, \c{o64},
+             *!   \c{osp}) invalid for the specified instruction has been specified.
+             *!   The operand prefix will be ignored by the assembler.
+             */
+            enum prefixes pfx = ins->prefixes[PPS_OSIZE];
+            if (pfx == P_O16)
+                break;
+            if (pfx != P_none)
+                nasm_warn(WARN_PREFIX_OPSIZE|ERR_PASS2,
+                          "invalid operand size prefix, must be o16");
+            else
+                ins->prefixes[PPS_OSIZE] = P_O16;
+            break;
+        }
+
+        case 0321:
+        {
+            enum prefixes pfx = ins->prefixes[PPS_OSIZE];
+            if (pfx == P_O32)
+                break;
+            if (pfx != P_none)
+                nasm_warn(WARN_PREFIX_OPSIZE|ERR_PASS2,
+                          "invalid operand size prefix, must be o32");
+            else
+                ins->prefixes[PPS_OSIZE] = P_O32;
+            break;
+        }
+
+        case 0322:
+            break;
+
+        case 0323:
+            rex_mask &= ~REX_W;
+            break;
+
+        case 0324:
+            ins->rex |= REX_W;
+            break;
+
+        case 0325:
+            ins->rex |= REX_NH;
+            break;
+
+        case 0326:
+            break;
+
+        case 0331:
+            break;
+
+        case 0332:
+        case 0333:
+            length++;
+            break;
+
+        case 0334:
+            ins->rex |= REX_L;
+            break;
+
+        case 0335:
+            break;
+
+        case 0336:
+            if (!ins->prefixes[PPS_REP])
+                ins->prefixes[PPS_REP] = P_REP;
+            break;
+
+        case 0337:
+            if (!ins->prefixes[PPS_REP])
+                ins->prefixes[PPS_REP] = P_REPNE;
+            break;
+
+        case 0340:
+            /*!
+             *!forward [on] forward reference may have unpredictable results
+             *!  warns that a forward reference is used which may have
+             *!  unpredictable results, notably in a \c{RESB}-type
+             *!  pseudo-instruction. These would be \i\e{critical
+             *!  expressions} (see \k{crit}) but are permitted in a
+             *!  handful of cases for compatibility with older
+             *!  versions of NASM. This warning should be treated as a
+             *!  severe programming error as the code could break at
+             *!  any time for any number of reasons.
+             */
+            if (!absolute_op(&ins->oprs[0]))
+                nasm_nonfatal("attempt to reserve non-constant"
+                              " quantity of BSS space");
+            else if (ins->oprs[0].opflags & OPFLAG_FORWARD)
+                nasm_warn(WARN_FORWARD, "forward reference in RESx "
+                           "can have unpredictable results");
+            else
+                length += ins->oprs[0].offset * resb_bytes(ins->opcode);
+            break;
+
+        case 0341:
+            if (!ins->prefixes[PPS_WAIT])
+                ins->prefixes[PPS_WAIT] = P_WAIT;
+            break;
+
+        case 0360:
+            break;
+
+        case 0361:
+            length++;
+            break;
+
+        case 0364:
+        case 0365:
+            break;
+
+        case 0366:
+        case 0367:
+            length++;
+            break;
+
+        case 0370:
+        case 0371:
+            break;
+
+        case 0373:
+            length++;
+            break;
+
+        case 0374:
+            eat = EA_XMMVSIB;
+            break;
+
+        case 0375:
+            eat = EA_YMMVSIB;
+            break;
+
+        case 0376:
+            eat = EA_ZMMVSIB;
+            break;
+
+        case4(0100):
+        case4(0110):
+        case4(0120):
+        case4(0130):
+        case4(0200):
+        case4(0204):
+        case4(0210):
+        case4(0214):
+        case4(0220):
+        case4(0224):
+        case4(0230):
+        case4(0234):
+            {
+                ea ea_data;
+                int rfield;
+                opflags_t rflags;
+                struct operand *opy = &ins->oprs[op2];
+                struct operand *op_er_sae;
+
+                ea_data.rex = 0;           /* Ensure ea.REX is initially 0 */
+
+                if (c <= 0177) {
+                    /* pick rfield from operand b (opx) */
+                    rflags = regflag(opx);
+                    rfield = nasm_regvals[opx->basereg];
+                } else {
+                    rflags = 0;
+                    rfield = c & 7;
+                }
+
+                /* EVEX.b1 : evex_brerop contains the operand position */
+                op_er_sae = (ins->evex_brerop >= 0 ?
+                             &ins->oprs[ins->evex_brerop] : NULL);
+
+                if (op_er_sae && (op_er_sae->decoflags & (ER | SAE))) {
+                    /* set EVEX.b */
+                    ins->evex_p[2] |= EVEX_P2B;
+                    if (op_er_sae->decoflags & ER) {
+                        /* set EVEX.RC (rounding control) */
+                        ins->evex_p[2] |= ((ins->evex_rm - BRC_RN) << 5)
+                                          & EVEX_P2RC;
+                    }
+                } else {
+                    /* set EVEX.L'L (vector length) */
+                    ins->evex_p[2] |= ((ins->vex_wlp << (5 - 2)) & EVEX_P2LL);
+                    ins->evex_p[1] |= ((ins->vex_wlp << (7 - 4)) & EVEX_P1W);
+                    if (opy->decoflags & BRDCAST_MASK) {
+                        /* set EVEX.b */
+                        ins->evex_p[2] |= EVEX_P2B;
+                    }
+                }
+
+                if (itemp_has(temp, IF_MIB)) {
+                    opy->eaflags |= EAF_MIB;
+                    /*
+                     * if a separate form of MIB (ICC style) is used,
+                     * the index reg info is merged into mem operand
+                     */
+                    if (mib_index != R_none) {
+                        opy->indexreg = mib_index;
+                        opy->scale = 1;
+                        opy->hintbase = mib_index;
+                        opy->hinttype = EAH_NOTBASE;
+                    }
+                }
+
+                /* SIB encoding required */
+                if (itemp_has(temp, IF_SIB))
+                    opy->eaflags |= EAF_SIB;
+
+                if (process_ea(opy, &ea_data, bits,
+                               rfield, rflags, ins, eat, &errmsg)) {
+                    nasm_nonfatal("%s", errmsg);
+                    return -1;
+                } else {
+                    ins->rex |= ea_data.rex;
+                    length += ea_data.size;
+                }
+            }
+            break;
+
+        default:
+            nasm_panic("internal instruction table corrupt"
+                    ": instruction code \\%o (0x%02X) given", c, c);
+            break;
+        }
+    }
+
+    ins->rex &= rex_mask;
+
+    if (ins->rex & REX_NH) {
+        if (ins->rex & REX_H) {
+            nasm_nonfatal("instruction cannot use high registers");
+            return -1;
+        }
+        ins->rex &= ~REX_P;        /* Don't force REX prefix due to high reg */
+    }
+
+    switch (ins->prefixes[PPS_REX]) {
+    case P_EVEX:
+        if (!(ins->rex & REX_EV))
+            return -1;
+        break;
+    case P_VEX:
+    case P_VEX3:
+    case P_VEX2:
+        if (!(ins->rex & REX_V))
+            return -1;
+        break;
+    case P_REX:
+        if (ins->rex & (REX_V|REX_EV))
+            return -1;
+        ins->rex |= REX_P;      /* Force REX prefix */
+        break;
+    default:
+        break;
+    }
+
+    if (ins->rex & (REX_V | REX_EV)) {
+        int bad32 = REX_R|REX_W|REX_X|REX_B;
+
+        if (ins->rex & REX_H) {
+            nasm_nonfatal("cannot use high register in AVX instruction");
+            return -1;
+        }
+        switch (ins->vex_wlp & 060) {
+        case 000:
+        case 040:
+            ins->rex &= ~REX_W;
+            break;
+        case 020:
+            ins->rex |= REX_W;
+            bad32 &= ~REX_W;
+            break;
+        case 060:
+            /* Follow REX_W */
+            break;
+        }
+
+        if (bits != 64 && ((ins->rex & bad32) || ins->vexreg > 7)) {
+            nasm_nonfatal("invalid operands in non-64-bit mode");
+            return -1;
+        } else if (!(ins->rex & REX_EV) &&
+                   ((ins->vexreg > 15) || (ins->evex_p[0] & 0xf0))) {
+            nasm_nonfatal("invalid high-16 register in non-AVX-512");
+            return -1;
+        }
+        if (ins->rex & REX_EV) {
+            length += 4;
+        } else if (ins->vex_cm != 1 || (ins->rex & (REX_W|REX_X|REX_B)) ||
+                 ins->prefixes[PPS_REX] == P_VEX3) {
+            if (ins->prefixes[PPS_REX] == P_VEX2)
+                nasm_nonfatal("instruction not encodable with {vex2} prefix");
+            length += 3;
+        } else {
+            length += 2;
+        }
+    } else if (ins->rex & REX_MASK) {
+        if (ins->rex & REX_H) {
+            nasm_nonfatal("cannot use high byte register in rex instruction");
+            return -1;
+        } else if (bits == 64) {
+            length++;
+        } else if ((ins->rex & REX_L) &&
+                   !(ins->rex & (REX_P|REX_W|REX_X|REX_B)) &&
+                   iflag_cpu_level_ok(&cpu, IF_X86_64)) {
+            /* LOCK-as-REX.R */
+            assert_no_prefix(ins, PPS_LOCK);
+            lockcheck = false;  /* Already errored, no need for warning */
+            length++;
+        } else {
+            nasm_nonfatal("invalid operands in non-64-bit mode");
+            return -1;
+        }
+    }
+
+    if (has_prefix(ins, PPS_LOCK, P_LOCK) && lockcheck &&
+        (!itemp_has(temp,IF_LOCK) || !is_class(MEMORY, ins->oprs[0].type))) {
+        /*!
+         *!prefix-lock [on] LOCK prefix on unlockable instructions
+         *!=lock
+         *!  warns about \c{LOCK} prefixes on unlockable instructions.
+         */
+        nasm_warn(WARN_PREFIX_LOCK|ERR_PASS2 , "instruction is not lockable");
+    }
+
+    bad_hle_warn(ins, hleok);
+
+    /*
+     * when BND prefix is set by DEFAULT directive,
+     * BND prefix is added to every appropriate instruction line
+     * unless it is overridden by NOBND prefix.
+     */
+    if (globalbnd &&
+        (itemp_has(temp, IF_BND) && !has_prefix(ins, PPS_REP, P_NOBND)))
+            ins->prefixes[PPS_REP] = P_BND;
+
+    /*
+     * Add length of legacy prefixes
+     */
+    length += emit_prefix(NULL, bits, ins);
+
+    return length;
+}
+
+static inline void emit_rex(struct out_data *data, insn *ins)
+{
+    if (data->bits == 64) {
+        if ((ins->rex & REX_MASK) &&
+            !(ins->rex & (REX_V | REX_EV)) &&
+            !ins->rex_done) {
+            uint8_t rex = (ins->rex & REX_MASK) | REX_P;
+            out_rawbyte(data, rex);
+            ins->rex_done = true;
+        }
+    }
+}
+
+static int emit_prefix(struct out_data *data, const int bits, insn *ins)
+{
+    int bytes = 0;
+    int j;
+
+    for (j = 0; j < MAXPREFIX; j++) {
+        uint8_t c = 0;
+        switch (ins->prefixes[j]) {
+        case P_WAIT:
+            c = 0x9B;
+            break;
+        case P_LOCK:
+            c = 0xF0;
+            break;
+        case P_REPNE:
+        case P_REPNZ:
+        case P_XACQUIRE:
+        case P_BND:
+            c = 0xF2;
+            break;
+        case P_REPE:
+        case P_REPZ:
+        case P_REP:
+        case P_XRELEASE:
+            c = 0xF3;
+            break;
+        case R_CS:
+            /*!
+             *!prefix-seg [on] segment prefix ignored in 64-bit mode
+             *!  warns that an \c{es}, \c{cs}, \c{ss} or \c{ds} segment override
+             *!  prefix has no effect in 64-bit mode. The prefix will still be
+             *!  generated as requested.
+             */
+            if (bits == 64)
+                nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "cs segment base generated, "
+                           "but will be ignored in 64-bit mode");
+            c = 0x2E;
+            break;
+        case R_DS:
+            if (bits == 64)
+                nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "ds segment base generated, "
+                           "but will be ignored in 64-bit mode");
+            c = 0x3E;
+            break;
+        case R_ES:
+            if (bits == 64)
+                nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "es segment base generated, "
+                           "but will be ignored in 64-bit mode");
+            c = 0x26;
+            break;
+        case R_FS:
+            c = 0x64;
+            break;
+        case R_GS:
+            c = 0x65;
+            break;
+        case R_SS:
+            if (bits == 64) {
+                nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "ss segment base generated, "
+                           "but will be ignored in 64-bit mode");
+            }
+            c = 0x36;
+            break;
+        case R_SEGR6:
+        case R_SEGR7:
+            nasm_nonfatal("segr6 and segr7 cannot be used as prefixes");
+            break;
+        case P_A16:
+            if (bits == 64) {
+                nasm_nonfatal("16-bit addressing is not supported "
+                              "in 64-bit mode");
+            } else if (bits != 16)
+                c = 0x67;
+            break;
+        case P_A32:
+            if (bits != 32)
+                c = 0x67;
+            break;
+        case P_A64:
+            if (bits != 64) {
+                nasm_nonfatal("64-bit addressing is only supported "
+			      "in 64-bit mode");
+            }
+            break;
+        case P_ASP:
+            c = 0x67;
+            break;
+        case P_O16:
+            if (bits != 16)
+                c = 0x66;
+            break;
+        case P_O32:
+            if (bits == 16)
+                c = 0x66;
+            break;
+        case P_O64:
+            /* REX.W */
+            break;
+        case P_OSP:
+            c = 0x66;
+            break;
+        case P_REX:
+        case P_VEX:
+        case P_EVEX:
+        case P_VEX3:
+        case P_VEX2:
+        case P_NOBND:
+        case P_none:
+            break;
+        default:
+            nasm_panic("invalid instruction prefix");
+        }
+        if (c) {
+            if (data)
+                out_rawbyte(data, c);
+            bytes++;
+        }
+    }
+    return bytes;
+}
+
+static void gencode(struct out_data *data, insn *ins)
+{
+    uint8_t c;
+    uint8_t bytes[4];
+    int64_t size;
+    int op1, op2;
+    struct operand *opx;
+    const uint8_t *codes = data->itemp->code;
+    uint8_t opex = 0;
+    enum ea_type eat = EA_SCALAR;
+    int r;
+    const int bits = data->bits;
+    const char *errmsg;
+
+    ins->rex_done = false;
+
+    emit_prefix(data, bits, ins);
+
+    while (*codes) {
+        c = *codes++;
+        op1 = (c & 3) + ((opex & 1) << 2);
+        op2 = ((c >> 3) & 3) + ((opex & 2) << 1);
+        opx = &ins->oprs[op1];
+        opex = 0;                /* For the next iteration */
+
+
+        switch (c) {
+        case 01:
+        case 02:
+        case 03:
+        case 04:
+            emit_rex(data, ins);
+            out_rawdata(data, codes, c);
+            codes += c;
+            break;
+
+        case 05:
+        case 06:
+        case 07:
+            opex = c;
+            break;
+
+        case4(010):
+            emit_rex(data, ins);
+            out_rawbyte(data, *codes++ + (regval(opx) & 7));
+            break;
+
+        case4(014):
+            break;
+
+        case4(020):
+            out_imm(data, opx, 1, OUT_WRAP);
+            break;
+
+        case4(024):
+            out_imm(data, opx, 1, OUT_UNSIGNED);
+            break;
+
+        case4(030):
+            out_imm(data, opx, 2, OUT_WRAP);
+            break;
+
+        case4(034):
+            if (opx->type & (BITS16 | BITS32))
+                size = (opx->type & BITS16) ? 2 : 4;
+            else
+                size = (bits == 16) ? 2 : 4;
+            out_imm(data, opx, size, OUT_WRAP);
+            break;
+
+        case4(040):
+            out_imm(data, opx, 4, OUT_WRAP);
+            break;
+
+        case4(044):
+            size = ins->addr_size >> 3;
+            out_imm(data, opx, size, OUT_WRAP);
+            break;
+
+        case4(050):
+            if (opx->segment == data->segment) {
+                int64_t delta = opx->offset - data->offset
+                    - (data->inslen - data->insoffs);
+                if (delta > 127 || delta < -128)
+                    nasm_nonfatal("short jump is out of range");
+            }
+            out_reladdr(data, opx, 1);
+            break;
+
+        case4(054):
+            out_imm(data, opx, 8, OUT_WRAP);
+            break;
+
+        case4(060):
+            out_reladdr(data, opx, 2);
+            break;
+
+        case4(064):
+            if (opx->type & (BITS16 | BITS32 | BITS64))
+                size = (opx->type & BITS16) ? 2 : 4;
+            else
+                size = (bits == 16) ? 2 : 4;
+
+            out_reladdr(data, opx, size);
+            break;
+
+        case4(070):
+            out_reladdr(data, opx, 4);
+            break;
+
+        case4(074):
+            if (opx->segment == NO_SEG)
+                nasm_nonfatal("value referenced by FAR is not relocatable");
+            out_segment(data, opx);
+            break;
+
+        case 0171:
+            c = *codes++;
+            op2 = (op2 & ~3) | ((c >> 3) & 3);
+            opx = &ins->oprs[op2];
+            r = nasm_regvals[opx->basereg];
+            c = (c & ~070) | ((r & 7) << 3);
+            out_rawbyte(data, c);
+            break;
+
+        case 0172:
+        {
+            int mask = ins->prefixes[PPS_REX] == P_EVEX ? 7 : 15;
+            const struct operand *opy;
+
+            c = *codes++;
+            opx = &ins->oprs[c >> 3];
+            opy = &ins->oprs[c & 7];
+            if (!absolute_op(opy))
+                nasm_nonfatal("non-absolute expression not permitted "
+                              "as argument %d", c & 7);
+            else if (opy->offset & ~mask)
+                nasm_warn(ERR_PASS2|WARN_NUMBER_OVERFLOW,
+                           "is4 argument exceeds bounds");
+            c = opy->offset & mask;
+            goto emit_is4;
+         }
+
+        case 0173:
+            c = *codes++;
+            opx = &ins->oprs[c >> 4];
+            c &= 15;
+            goto emit_is4;
+
+        case4(0174):
+            c = 0;
+        emit_is4:
+            r = nasm_regvals[opx->basereg];
+            out_rawbyte(data, (r << 4) | ((r & 0x10) >> 1) | c);
+            break;
+
+        case4(0254):
+            if (absolute_op(opx) &&
+                (int32_t)opx->offset != (int64_t)opx->offset) {
+                nasm_warn(ERR_PASS2|WARN_NUMBER_OVERFLOW,
+                           "signed dword immediate exceeds bounds");
+            }
+            out_imm(data, opx, 4, OUT_SIGNED);
+            break;
+
+        case4(0240):
+        case 0250:
+            codes += 3;
+            ins->evex_p[2] |= op_evexflags(&ins->oprs[0],
+                                           EVEX_P2Z | EVEX_P2AAA, 2);
+            ins->evex_p[2] ^= EVEX_P2VP;        /* 1's complement */
+            bytes[0] = 0x62;
+            /* EVEX.X can be set by either REX or EVEX for different reasons */
+            bytes[1] = ((((ins->rex & 7) << 5) |
+                         (ins->evex_p[0] & (EVEX_P0X | EVEX_P0RP))) ^ 0xf0) |
+                       (ins->vex_cm & EVEX_P0MM);
+            bytes[2] = ((ins->rex & REX_W) << (7 - 3)) |
+                       ((~ins->vexreg & 15) << 3) |
+                       (1 << 2) | (ins->vex_wlp & 3);
+            bytes[3] = ins->evex_p[2];
+            out_rawdata(data, bytes, 4);
+            break;
+
+        case4(0260):
+        case 0270:
+            codes += 2;
+            if (ins->vex_cm != 1 || (ins->rex & (REX_W|REX_X|REX_B)) ||
+                ins->prefixes[PPS_REX] == P_VEX3) {
+                bytes[0] = (ins->vex_cm >> 6) ? 0x8f : 0xc4;
+                bytes[1] = (ins->vex_cm & 31) | ((~ins->rex & 7) << 5);
+                bytes[2] = ((ins->rex & REX_W) << (7-3)) |
+                    ((~ins->vexreg & 15)<< 3) | (ins->vex_wlp & 07);
+                out_rawdata(data, bytes, 3);
+            } else {
+                bytes[0] = 0xc5;
+                bytes[1] = ((~ins->rex & REX_R) << (7-2)) |
+                    ((~ins->vexreg & 15) << 3) | (ins->vex_wlp & 07);
+                out_rawdata(data, bytes, 2);
+            }
+            break;
+
+        case 0271:
+        case 0272:
+        case 0273:
+            break;
+
+        case4(0274):
+        {
+            uint64_t uv, um;
+            int s;
+
+            if (absolute_op(opx)) {
+                if (ins->rex & REX_W)
+                    s = 64;
+                else if (ins->prefixes[PPS_OSIZE] == P_O16)
+                    s = 16;
+                else if (ins->prefixes[PPS_OSIZE] == P_O32)
+                    s = 32;
+                else
+                    s = bits;
+
+                um = (uint64_t)2 << (s-1);
+                uv = opx->offset;
+
+                if (uv > 127 && uv < (uint64_t)-128 &&
+                    (uv < um-128 || uv > um-1)) {
+                    /* If this wasn't explicitly byte-sized, warn as though we
+                     * had fallen through to the imm16/32/64 case.
+                     */
+                    nasm_warn(ERR_PASS2|WARN_NUMBER_OVERFLOW,
+                               "%s value exceeds bounds",
+                               (opx->type & BITS8) ? "signed byte" :
+                               s == 16 ? "word" :
+                               s == 32 ? "dword" :
+                               "signed dword");
+                }
+
+                /* Output as a raw byte to avoid byte overflow check */
+                out_rawbyte(data, (uint8_t)uv);
+            } else {
+                out_imm(data, opx, 1, OUT_WRAP); /* XXX: OUT_SIGNED? */
+            }
+            break;
+        }
+
+        case4(0300):
+            break;
+
+        case 0310:
+            if (bits == 32 && !has_prefix(ins, PPS_ASIZE, P_A16))
+                out_rawbyte(data, 0x67);
+            break;
+
+        case 0311:
+            if (bits != 32 && !has_prefix(ins, PPS_ASIZE, P_A32))
+                out_rawbyte(data, 0x67);
+            break;
+
+        case 0312:
+            break;
+
+        case 0313:
+            break;
+
+        case4(0314):
+            break;
+
+        case 0320:
+        case 0321:
+            break;
+
+        case 0322:
+        case 0323:
+            break;
+
+        case 0324:
+            ins->rex |= REX_W;
+            break;
+
+        case 0325:
+            break;
+
+        case 0326:
+            break;
+
+        case 0331:
+            break;
+
+        case 0332:
+        case 0333:
+            out_rawbyte(data, c - 0332 + 0xF2);
+            break;
+
+        case 0334:
+            if (ins->rex & REX_R)
+                out_rawbyte(data, 0xF0);
+            ins->rex &= ~(REX_L|REX_R);
+            break;
+
+        case 0335:
+            break;
+
+        case 0336:
+        case 0337:
+            break;
+
+        case 0340:
+            if (ins->oprs[0].segment != NO_SEG)
+                nasm_panic("non-constant BSS size in pass two");
+
+            out_reserve(data, ins->oprs[0].offset * resb_bytes(ins->opcode));
+            break;
+
+        case 0341:
+            break;
+
+        case 0360:
+            break;
+
+        case 0361:
+            out_rawbyte(data, 0x66);
+            break;
+
+        case 0364:
+        case 0365:
+            break;
+
+        case 0366:
+        case 0367:
+            out_rawbyte(data, c - 0366 + 0x66);
+            break;
+
+        case3(0370):
+            break;
+
+        case 0373:
+            out_rawbyte(data, bits == 16 ? 3 : 5);
+            break;
+
+        case 0374:
+            eat = EA_XMMVSIB;
+            break;
+
+        case 0375:
+            eat = EA_YMMVSIB;
+            break;
+
+        case 0376:
+            eat = EA_ZMMVSIB;
+            break;
+
+        case4(0100):
+        case4(0110):
+        case4(0120):
+        case4(0130):
+        case4(0200):
+        case4(0204):
+        case4(0210):
+        case4(0214):
+        case4(0220):
+        case4(0224):
+        case4(0230):
+        case4(0234):
+            {
+                ea ea_data;
+                int rfield;
+                opflags_t rflags;
+                uint8_t *p;
+                struct operand *opy = &ins->oprs[op2];
+
+                if (c <= 0177) {
+                    /* pick rfield from operand b (opx) */
+                    rflags = regflag(opx);
+                    rfield = nasm_regvals[opx->basereg];
+                } else {
+                    /* rfield is constant */
+                    rflags = 0;
+                    rfield = c & 7;
+                }
+
+                if (process_ea(opy, &ea_data, bits,
+                               rfield, rflags, ins, eat, &errmsg))
+                    nasm_nonfatal("%s", errmsg);
+
+                p = bytes;
+                *p++ = ea_data.modrm;
+                if (ea_data.sib_present)
+                    *p++ = ea_data.sib;
+                out_rawdata(data, bytes, p - bytes);
+
+                /*
+                 * Make sure the address gets the right offset in case
+                 * the line breaks in the .lst file (BR 1197827)
+                 */
+
+                if (ea_data.bytes) {
+                    /* use compressed displacement, if available */
+                    if (ea_data.disp8) {
+                        out_rawbyte(data, ea_data.disp8);
+                    } else if (ea_data.rip) {
+                        out_reladdr(data, opy, ea_data.bytes);
+                    } else {
+                        int asize = ins->addr_size >> 3;
+
+                        if (overflow_general(opy->offset, asize) ||
+                            signed_bits(opy->offset, ins->addr_size) !=
+                            signed_bits(opy->offset, ea_data.bytes << 3))
+                            warn_overflow(ea_data.bytes);
+
+                        out_imm(data, opy, ea_data.bytes,
+                                (asize > ea_data.bytes)
+                                ? OUT_SIGNED : OUT_WRAP);
+                    }
+                }
+            }
+            break;
+
+        default:
+            nasm_panic("internal instruction table corrupt"
+                    ": instruction code \\%o (0x%02X) given", c, c);
+            break;
+        }
+    }
+}
+
+static opflags_t regflag(const operand * o)
+{
+    if (!is_register(o->basereg))
+        nasm_panic("invalid operand passed to regflag()");
+    return nasm_reg_flags[o->basereg];
+}
+
+static int32_t regval(const operand * o)
+{
+    if (!is_register(o->basereg))
+        nasm_panic("invalid operand passed to regval()");
+    return nasm_regvals[o->basereg];
+}
+
+static int op_rexflags(const operand * o, int mask)
+{
+    opflags_t flags;
+    int val;
+
+    if (!is_register(o->basereg))
+        nasm_panic("invalid operand passed to op_rexflags()");
+
+    flags = nasm_reg_flags[o->basereg];
+    val = nasm_regvals[o->basereg];
+
+    return rexflags(val, flags, mask);
+}
+
+static int rexflags(int val, opflags_t flags, int mask)
+{
+    int rex = 0;
+
+    if (val >= 0 && (val & 8))
+        rex |= REX_B|REX_X|REX_R;
+    if (flags & BITS64)
+        rex |= REX_W;
+    if (!(REG_HIGH & ~flags))                   /* AH, CH, DH, BH */
+        rex |= REX_H;
+    else if (!(REG8 & ~flags) && val >= 4)      /* SPL, BPL, SIL, DIL */
+        rex |= REX_P;
+
+    return rex & mask;
+}
+
+static int evexflags(int val, decoflags_t deco,
+                     int mask, uint8_t byte)
+{
+    int evex = 0;
+
+    switch (byte) {
+    case 0:
+        if (val >= 0 && (val & 16))
+            evex |= (EVEX_P0RP | EVEX_P0X);
+        break;
+    case 2:
+        if (val >= 0 && (val & 16))
+            evex |= EVEX_P2VP;
+        if (deco & Z)
+            evex |= EVEX_P2Z;
+        if (deco & OPMASK_MASK)
+            evex |= deco & EVEX_P2AAA;
+        break;
+    }
+    return evex & mask;
+}
+
+static int op_evexflags(const operand * o, int mask, uint8_t byte)
+{
+    int val;
+
+    val = nasm_regvals[o->basereg];
+
+    return evexflags(val, o->decoflags, mask, byte);
+}
+
+static enum match_result find_match(const struct itemplate **tempp,
+                                    insn *instruction,
+                                    int32_t segment, int64_t offset, int bits)
+{
+    const struct itemplate *temp;
+    enum match_result m, merr;
+    opflags_t xsizeflags[MAX_OPERANDS];
+    bool opsizemissing = false;
+    int8_t broadcast = instruction->evex_brerop;
+    int i;
+
+    /* broadcasting uses a different data element size */
+    for (i = 0; i < instruction->operands; i++) {
+        if (i == broadcast)
+            xsizeflags[i] = instruction->oprs[i].decoflags & BRSIZE_MASK;
+        else
+            xsizeflags[i] = instruction->oprs[i].type & SIZE_MASK;
+    }
+
+    merr = MERR_INVALOP;
+
+    for (temp = nasm_instructions[instruction->opcode];
+         temp->opcode != I_none; temp++) {
+        m = matches(temp, instruction, bits);
+        if (m == MOK_JUMP) {
+            if (jmp_match(segment, offset, bits, instruction, temp))
+                m = MOK_GOOD;
+            else
+                m = MERR_INVALOP;
+        } else if (m == MERR_OPSIZEMISSING && !itemp_has(temp, IF_SX)) {
+            /*
+             * Missing operand size and a candidate for fuzzy matching...
+             */
+            for (i = 0; i < temp->operands; i++)
+                if (i == broadcast)
+                    xsizeflags[i] |= temp->deco[i] & BRSIZE_MASK;
+                else
+                    xsizeflags[i] |= temp->opd[i] & SIZE_MASK;
+            opsizemissing = true;
+        }
+        if (m > merr)
+            merr = m;
+        if (merr == MOK_GOOD)
+            goto done;
+    }
+
+    /* No match, but see if we can get a fuzzy operand size match... */
+    if (!opsizemissing)
+        goto done;
+
+    for (i = 0; i < instruction->operands; i++) {
+        /*
+         * We ignore extrinsic operand sizes on registers, so we should
+         * never try to fuzzy-match on them.  This also resolves the case
+         * when we have e.g. "xmmrm128" in two different positions.
+         */
+        if (is_class(REGISTER, instruction->oprs[i].type))
+            continue;
+
+        /* This tests if xsizeflags[i] has more than one bit set */
+        if ((xsizeflags[i] & (xsizeflags[i]-1)))
+            goto done;                /* No luck */
+
+        if (i == broadcast) {
+            instruction->oprs[i].decoflags |= xsizeflags[i];
+            instruction->oprs[i].type |= brsize_to_size(xsizeflags[i]);
+        } else {
+            instruction->oprs[i].type |= xsizeflags[i]; /* Set the size */
+        }
+    }
+
+    /* Try matching again... */
+    for (temp = nasm_instructions[instruction->opcode];
+         temp->opcode != I_none; temp++) {
+        m = matches(temp, instruction, bits);
+        if (m == MOK_JUMP) {
+            if (jmp_match(segment, offset, bits, instruction, temp))
+                m = MOK_GOOD;
+            else
+                m = MERR_INVALOP;
+        }
+        if (m > merr)
+            merr = m;
+        if (merr == MOK_GOOD)
+            goto done;
+    }
+
+done:
+    *tempp = temp;
+    return merr;
+}
+
+static uint8_t get_broadcast_num(opflags_t opflags, opflags_t brsize)
+{
+    unsigned int opsize = (opflags & SIZE_MASK) >> SIZE_SHIFT;
+    uint8_t brcast_num;
+
+    if (brsize > BITS64)
+        nasm_fatal("size of broadcasting element is greater than 64 bits");
+
+    /*
+     * The shift term is to take care of the extra BITS80 inserted
+     * between BITS64 and BITS128.
+     */
+    brcast_num = ((opsize / (BITS64 >> SIZE_SHIFT)) * (BITS64 / brsize))
+        >> (opsize > (BITS64 >> SIZE_SHIFT));
+
+    return brcast_num;
+}
+
+static enum match_result matches(const struct itemplate *itemp,
+                                 insn *instruction, int bits)
+{
+    opflags_t size[MAX_OPERANDS], asize;
+    bool opsizemissing = false;
+    int i, oprs;
+
+    /*
+     * Check the opcode
+     */
+    if (itemp->opcode != instruction->opcode)
+        return MERR_INVALOP;
+
+    /*
+     * Count the operands
+     */
+    if (itemp->operands != instruction->operands)
+        return MERR_INVALOP;
+
+    /*
+     * Is it legal?
+     */
+    if (!(optimizing.level > 0) && itemp_has(itemp, IF_OPT))
+	return MERR_INVALOP;
+
+    /*
+     * {rex/vexn/evex} available?
+     */
+    switch (instruction->prefixes[PPS_REX]) {
+    case P_EVEX:
+        if (!itemp_has(itemp, IF_EVEX))
+            return MERR_ENCMISMATCH;
+        break;
+    case P_VEX:
+    case P_VEX3:
+    case P_VEX2:
+        if (!itemp_has(itemp, IF_VEX))
+            return MERR_ENCMISMATCH;
+        break;
+    case P_REX:
+        if (itemp_has(itemp, IF_VEX) || itemp_has(itemp, IF_EVEX) ||
+            bits != 64)
+            return MERR_ENCMISMATCH;
+        break;
+    default:
+        if (itemp_has(itemp, IF_EVEX)) {
+            if (!iflag_test(&cpu, IF_EVEX))
+                return MERR_ENCMISMATCH;
+        } else if (itemp_has(itemp, IF_VEX)) {
+            if (!iflag_test(&cpu, IF_VEX)) {
+                return MERR_ENCMISMATCH;
+            } else if (itemp_has(itemp, IF_LATEVEX)) {
+                if (!iflag_test(&cpu, IF_LATEVEX) && iflag_test(&cpu, IF_EVEX))
+                    return MERR_ENCMISMATCH;
+            }
+        }
+        break;
+    }
+
+    /*
+     * Check that no spurious colons or TOs are present
+     */
+    for (i = 0; i < itemp->operands; i++)
+        if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO))
+            return MERR_INVALOP;
+
+    /*
+     * Process size flags
+     */
+    switch (itemp_smask(itemp)) {
+    case IF_GENBIT(IF_SB):
+        asize = BITS8;
+        break;
+    case IF_GENBIT(IF_SW):
+        asize = BITS16;
+        break;
+    case IF_GENBIT(IF_SD):
+        asize = BITS32;
+        break;
+    case IF_GENBIT(IF_SQ):
+        asize = BITS64;
+        break;
+    case IF_GENBIT(IF_SO):
+        asize = BITS128;
+        break;
+    case IF_GENBIT(IF_SY):
+        asize = BITS256;
+        break;
+    case IF_GENBIT(IF_SZ):
+        asize = BITS512;
+        break;
+    case IF_GENBIT(IF_ANYSIZE):
+        asize = SIZE_MASK;
+        break;
+    case IF_GENBIT(IF_SIZE):
+        switch (bits) {
+        case 16:
+            asize = BITS16;
+            break;
+        case 32:
+            asize = BITS32;
+            break;
+        case 64:
+            asize = BITS64;
+            break;
+        default:
+            asize = 0;
+            break;
+        }
+        break;
+    default:
+        asize = 0;
+        break;
+    }
+
+    if (itemp_armask(itemp)) {
+        /* S- flags only apply to a specific operand */
+        i = itemp_arg(itemp);
+        memset(size, 0, sizeof size);
+        size[i] = asize;
+    } else {
+        /* S- flags apply to all operands */
+        for (i = 0; i < MAX_OPERANDS; i++)
+            size[i] = asize;
+    }
+
+    /*
+     * Check that the operand flags all match up,
+     * it's a bit tricky so lets be verbose:
+     *
+     * 1) Find out the size of operand. If instruction
+     *    doesn't have one specified -- we're trying to
+     *    guess it either from template (IF_S* flag) or
+     *    from code bits.
+     *
+     * 2) If template operand do not match the instruction OR
+     *    template has an operand size specified AND this size differ
+     *    from which instruction has (perhaps we got it from code bits)
+     *    we are:
+     *      a)  Check that only size of instruction and operand is differ
+     *          other characteristics do match
+     *      b)  Perhaps it's a register specified in instruction so
+     *          for such a case we just mark that operand as "size
+     *          missing" and this will turn on fuzzy operand size
+     *          logic facility (handled by a caller)
+     */
+    for (i = 0; i < itemp->operands; i++) {
+        opflags_t type = instruction->oprs[i].type;
+        decoflags_t deco = instruction->oprs[i].decoflags;
+        decoflags_t ideco = itemp->deco[i];
+        bool is_broadcast = deco & BRDCAST_MASK;
+        uint8_t brcast_num = 0;
+        opflags_t template_opsize, insn_opsize;
+
+        if (!(type & SIZE_MASK))
+            type |= size[i];
+
+        insn_opsize     = type & SIZE_MASK;
+        if (!is_broadcast) {
+            template_opsize = itemp->opd[i] & SIZE_MASK;
+        } else {
+            decoflags_t deco_brsize = ideco & BRSIZE_MASK;
+
+            if (~ideco & BRDCAST_MASK)
+                return MERR_BRNOTHERE;
+
+            /*
+             * when broadcasting, the element size depends on
+             * the instruction type. decorator flag should match.
+             */
+            if (deco_brsize) {
+                template_opsize = brsize_to_size(deco_brsize);
+                /* calculate the proper number : {1to<brcast_num>} */
+                brcast_num = get_broadcast_num(itemp->opd[i], template_opsize);
+            } else {
+                template_opsize = 0;
+            }
+        }
+
+        if (~ideco & deco & OPMASK_MASK)
+            return MERR_MASKNOTHERE;
+
+        if (~ideco & deco & (Z_MASK|STATICRND_MASK|SAE_MASK))
+            return MERR_DECONOTHERE;
+
+        if (itemp->opd[i] & ~type & ~(SIZE_MASK|REGSET_MASK))
+            return MERR_INVALOP;
+
+        if (~itemp->opd[i] & type & REGSET_MASK)
+            return (itemp->opd[i] & REGSET_MASK)
+                ? MERR_REGSETSIZE : MERR_REGSET;
+
+        if (template_opsize) {
+            if (template_opsize != insn_opsize) {
+                if (insn_opsize) {
+                    return MERR_INVALOP;
+                } else if (!is_class(REGISTER, type)) {
+                    /*
+                     * Note: we don't honor extrinsic operand sizes for registers,
+                     * so "missing operand size" for a register should be
+                     * considered a wildcard match rather than an error.
+                     */
+                    opsizemissing = true;
+                } else if (is_class(REG_HIGH, type) &&
+                           instruction->prefixes[PPS_REX]) {
+                    return MERR_ENCMISMATCH;
+                }
+            } else if (is_broadcast &&
+                       (brcast_num !=
+                        (2U << ((deco & BRNUM_MASK) >> BRNUM_SHIFT)))) {
+                /*
+                 * broadcasting opsize matches but the number of repeated memory
+                 * element does not match.
+                 * if 64b double precision float is broadcasted to ymm (256b),
+                 * broadcasting decorator must be {1to4}.
+                 */
+                return MERR_BRNUMMISMATCH;
+            }
+        }
+    }
+
+    if (opsizemissing)
+        return MERR_OPSIZEMISSING;
+
+    /*
+     * Check operand sizes
+     */
+    if (itemp_has(itemp, IF_SM) || itemp_has(itemp, IF_SM2)) {
+        oprs = (itemp_has(itemp, IF_SM2) ? 2 : itemp->operands);
+        for (i = 0; i < oprs; i++) {
+            asize = itemp->opd[i] & SIZE_MASK;
+            if (asize) {
+                for (i = 0; i < oprs; i++)
+                    size[i] = asize;
+                break;
+            }
+        }
+    } else {
+        oprs = itemp->operands;
+    }
+
+    for (i = 0; i < itemp->operands; i++) {
+        if (!(itemp->opd[i] & SIZE_MASK) &&
+            (instruction->oprs[i].type & SIZE_MASK & ~size[i]))
+            return MERR_OPSIZEMISMATCH;
+    }
+
+    /*
+     * Check template is okay at the set cpu level
+     */
+    if (iflag_cmp_cpu_level(&insns_flags[itemp->iflag_idx], &cpu) > 0)
+        return MERR_BADCPU;
+
+    /*
+     * Verify the appropriate long mode flag.
+     */
+    if (itemp_has(itemp, (bits == 64 ? IF_NOLONG : IF_LONG)))
+        return MERR_BADMODE;
+
+    /*
+     * If we have a HLE prefix, look for the NOHLE flag
+     */
+    if (itemp_has(itemp, IF_NOHLE) &&
+        (has_prefix(instruction, PPS_REP, P_XACQUIRE) ||
+         has_prefix(instruction, PPS_REP, P_XRELEASE)))
+        return MERR_BADHLE;
+
+    /*
+     * Check if special handling needed for Jumps
+     */
+    if ((itemp->code[0] & ~1) == 0370)
+        return MOK_JUMP;
+
+    /*
+     * Check if BND prefix is allowed.
+     * Other 0xF2 (REPNE/REPNZ) prefix is prohibited.
+     */
+    if (!itemp_has(itemp, IF_BND) &&
+        (has_prefix(instruction, PPS_REP, P_BND) ||
+         has_prefix(instruction, PPS_REP, P_NOBND)))
+        return MERR_BADBND;
+    else if (itemp_has(itemp, IF_BND) &&
+             (has_prefix(instruction, PPS_REP, P_REPNE) ||
+              has_prefix(instruction, PPS_REP, P_REPNZ)))
+        return MERR_BADREPNE;
+
+    return MOK_GOOD;
+}
+
+/*
+ * Check if ModR/M.mod should/can be 01.
+ * - EAF_BYTEOFFS is set
+ * - offset can fit in a byte when EVEX is not used
+ * - offset can be compressed when EVEX is used
+ */
+#define IS_MOD_01() (!(input->eaflags & EAF_WORDOFFS) &&               \
+                    (ins->rex & REX_EV ? seg == NO_SEG && !forw_ref && \
+                     is_disp8n(input, ins, &output->disp8) :           \
+                     input->eaflags & EAF_BYTEOFFS || (o >= -128 &&    \
+                     o <= 127 && seg == NO_SEG && !forw_ref)))
+
+static int process_ea(operand *input, ea *output, int bits,
+                      int rfield, opflags_t rflags, insn *ins,
+                      enum ea_type expected, const char **errmsgp)
+{
+    bool forw_ref = !!(input->opflags & OPFLAG_UNKNOWN);
+    const int addrbits = ins->addr_size;
+    const int eaflags = input->eaflags;
+    const char *errmsg = NULL;
+
+    errmsg = NULL;
+
+    output->type    = EA_SCALAR;
+    output->rip     = false;
+    output->disp8   = 0;
+
+    /* REX flags for the rfield operand */
+    output->rex     |= rexflags(rfield, rflags, REX_R | REX_P | REX_W | REX_H);
+    /* EVEX.R' flag for the REG operand */
+    ins->evex_p[0]  |= evexflags(rfield, 0, EVEX_P0RP, 0);
+
+    if (is_class(REGISTER, input->type)) {
+        /*
+         * It's a direct register.
+         */
+        if (!is_register(input->basereg))
+            goto err;
+
+        if (!is_reg_class(REG_EA, input->basereg))
+            goto err;
+
+        /* broadcasting is not available with a direct register operand. */
+        if (input->decoflags & BRDCAST_MASK) {
+            errmsg = "broadcast not allowed with register operand";
+            goto err;
+        }
+
+        output->rex         |= op_rexflags(input, REX_B | REX_P | REX_W | REX_H);
+        ins->evex_p[0]      |= op_evexflags(input, EVEX_P0X, 0);
+        output->sib_present = false;    /* no SIB necessary */
+        output->bytes       = 0;        /* no offset necessary either */
+        output->modrm       = GEN_MODRM(3, rfield, nasm_regvals[input->basereg]);
+    } else {
+        /*
+         * It's a memory reference.
+         */
+
+        /* Embedded rounding or SAE is not available with a mem ref operand. */
+        if (input->decoflags & (ER | SAE)) {
+            errmsg = "embedded rounding is available only with "
+                "register-register operations";
+            goto err;
+        }
+
+        if (input->basereg == -1 &&
+            (input->indexreg == -1 || input->scale == 0)) {
+            /*
+             * It's a pure offset. If it is an IMMEDIATE, it is a pattern
+             * in insns.dat which allows an immediate to be used as a memory
+             * address, in which case apply the default REL/ABS.
+             */
+            if (bits == 64) {
+                if (is_class(IMMEDIATE, input->type)) {
+                    if (!(input->eaflags & EAF_ABS) &&
+                        ((input->eaflags & EAF_REL) || globalrel))
+                        input->type |= IP_REL;
+                }
+                if ((input->type & IP_REL) == IP_REL) {
+                    /*!
+                     *!ea-absolute [on] absolute address cannot be RIP-relative
+                     *!  warns that an address that is inherently absolute cannot
+                     *!  be generated with RIP-relative encoding using \c{REL},
+                     *!  see \k{REL & ABS}.
+                     */
+                    if (input->segment == NO_SEG ||
+                        (input->opflags & OPFLAG_RELATIVE)) {
+                        nasm_warn(WARN_EA_ABSOLUTE|ERR_PASS2,
+                                  "absolute address can not be RIP-relative");
+                        input->type &= ~IP_REL;
+                        input->type |= MEMORY;
+                    }
+                }
+            }
+
+            if (bits == 64 && !(IP_REL & ~input->type) && (eaflags & EAF_SIB)) {
+                errmsg = "instruction requires SIB encoding, cannot be RIP-relative";
+                goto err;
+            }
+
+            if (eaflags & EAF_BYTEOFFS ||
+                (eaflags & EAF_WORDOFFS &&
+                 input->disp_size != (addrbits != 16 ? 32 : 16))) {
+                /*!
+                 *!ea-dispsize [on] displacement size ignored on absolute address
+                 *!  warns that NASM does not support generating displacements for
+                 *!  inherently absolute addresses that do not match the address size
+                 *!  of the instruction.
+                 */
+                nasm_warn(WARN_EA_DISPSIZE, "displacement size ignored on absolute address");
+            }
+
+            if ((eaflags & EAF_SIB) || (bits == 64 && (~input->type & IP_REL))) {
+                output->sib_present = true;
+                output->sib         = GEN_SIB(0, 4, 5);
+                output->bytes       = 4;
+                output->modrm       = GEN_MODRM(0, rfield, 4);
+                output->rip         = false;
+            } else {
+                output->sib_present = false;
+                output->bytes       = (addrbits != 16 ? 4 : 2);
+                output->modrm       = GEN_MODRM(0, rfield,
+                                                (addrbits != 16 ? 5 : 6));
+                output->rip         = bits == 64;
+            }
+        } else {
+            /*
+             * It's an indirection.
+             */
+            int i = input->indexreg, b = input->basereg, s = input->scale;
+            int32_t seg = input->segment;
+            int hb = input->hintbase, ht = input->hinttype;
+            int t, it, bt;              /* register numbers */
+            opflags_t x, ix, bx;        /* register flags */
+
+            if (s == 0)
+                i = -1;         /* make this easy, at least */
+
+            if (is_register(i)) {
+                it = nasm_regvals[i];
+                ix = nasm_reg_flags[i];
+            } else {
+                it = -1;
+                ix = 0;
+            }
+
+            if (is_register(b)) {
+                bt = nasm_regvals[b];
+                bx = nasm_reg_flags[b];
+            } else {
+                bt = -1;
+                bx = 0;
+            }
+
+            /* if either one are a vector register... */
+            if ((ix|bx) & (XMMREG|YMMREG|ZMMREG) & ~REG_EA) {
+                opflags_t sok = BITS32 | BITS64;
+                int32_t o = input->offset;
+                int mod, scale, index, base;
+
+                /*
+                 * For a vector SIB, one has to be a vector and the other,
+                 * if present, a GPR.  The vector must be the index operand.
+                 */
+                if (it == -1 || (bx & (XMMREG|YMMREG|ZMMREG) & ~REG_EA)) {
+                    if (s == 0)
+                        s = 1;
+                    else if (s != 1)
+                        goto err;
+
+                    t = bt, bt = it, it = t;
+                    x = bx, bx = ix, ix = x;
+                }
+
+                if (bt != -1) {
+                    if (REG_GPR & ~bx)
+                        goto err;
+                    if (!(REG64 & ~bx) || !(REG32 & ~bx))
+                        sok &= bx;
+                    else
+                        goto err;
+                }
+
+                /*
+                 * While we're here, ensure the user didn't specify
+                 * WORD or QWORD
+                 */
+                if (input->disp_size == 16 || input->disp_size == 64)
+                    goto err;
+
+                if (addrbits == 16 ||
+                    (addrbits == 32 && !(sok & BITS32)) ||
+                    (addrbits == 64 && !(sok & BITS64)))
+                    goto err;
+
+                output->type = ((ix & ZMMREG & ~REG_EA) ? EA_ZMMVSIB
+                                : ((ix & YMMREG & ~REG_EA)
+                                ? EA_YMMVSIB : EA_XMMVSIB));
+
+                output->rex    |= rexflags(it, ix, REX_X);
+                output->rex    |= rexflags(bt, bx, REX_B);
+                ins->evex_p[2] |= evexflags(it, 0, EVEX_P2VP, 2);
+
+                index = it & 7; /* it is known to be != -1 */
+
+                switch (s) {
+                case 1:
+                    scale = 0;
+                    break;
+                case 2:
+                    scale = 1;
+                    break;
+                case 4:
+                    scale = 2;
+                    break;
+                case 8:
+                    scale = 3;
+                    break;
+                default:   /* then what the smeg is it? */
+                    goto err;    /* panic */
+                }
+
+                if (bt == -1) {
+                    base = 5;
+                    mod = 0;
+                } else {
+                    base = (bt & 7);
+                    if (base != REG_NUM_EBP && o == 0 &&
+                        seg == NO_SEG && !forw_ref &&
+                        !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
+                        mod = 0;
+                    else if (IS_MOD_01())
+                        mod = 1;
+                    else
+                        mod = 2;
+                }
+
+                output->sib_present = true;
+                output->bytes       = (bt == -1 || mod == 2 ? 4 : mod);
+                output->modrm       = GEN_MODRM(mod, rfield, 4);
+                output->sib         = GEN_SIB(scale, index, base);
+            } else if ((ix|bx) & (BITS32|BITS64)) {
+                /*
+                 * it must be a 32/64-bit memory reference. Firstly we have
+                 * to check that all registers involved are type E/Rxx.
+                 */
+                opflags_t sok = BITS32 | BITS64;
+                int32_t o = input->offset;
+
+                if (it != -1) {
+                    if (!(REG64 & ~ix) || !(REG32 & ~ix))
+                        sok &= ix;
+                    else
+                        goto err;
+                }
+
+                if (bt != -1) {
+                    if (REG_GPR & ~bx)
+                        goto err; /* Invalid register */
+                    if (~sok & bx & SIZE_MASK)
+                        goto err; /* Invalid size */
+                    sok &= bx;
+                }
+
+                /*
+                 * While we're here, ensure the user didn't specify
+                 * WORD or QWORD
+                 */
+                if (input->disp_size == 16 || input->disp_size == 64)
+                    goto err;
+
+                if (addrbits == 16 ||
+                    (addrbits == 32 && !(sok & BITS32)) ||
+                    (addrbits == 64 && !(sok & BITS64)))
+                    goto err;
+
+                /* now reorganize base/index */
+                if (s == 1 && bt != it && bt != -1 && it != -1 &&
+                    ((hb == b && ht == EAH_NOTBASE) ||
+                     (hb == i && ht == EAH_MAKEBASE))) {
+                    /* swap if hints say so */
+                    t = bt, bt = it, it = t;
+                    x = bx, bx = ix, ix = x;
+                }
+
+                if (bt == -1 && s == 1 && !(hb == i && ht == EAH_NOTBASE)) {
+                    /* make single reg base, unless hint */
+                    bt = it, bx = ix, it = -1, ix = 0;
+                }
+                if (eaflags & EAF_MIB) {
+                    /* MIB/split-SIB encoding */
+                    if (it == -1 && (hb == b && ht == EAH_NOTBASE)) {
+                        /*
+                         * make a single reg index [reg*1].
+                         * gas uses this form for an explicit index register.
+                         */
+                        it = bt, ix = bx, bt = -1, bx = 0, s = 1;
+                    }
+                    if ((ht == EAH_SUMMED) && bt == -1) {
+                        /* separate once summed index into [base, index] */
+                        bt = it, bx = ix, s--;
+                    }
+                } else {
+                    if (((s == 2 && it != REG_NUM_ESP &&
+                          (!(eaflags & EAF_TIMESTWO) || (ht == EAH_SUMMED))) ||
+                         s == 3 || s == 5 || s == 9) && bt == -1) {
+                        /* convert 3*EAX to EAX+2*EAX */
+                        bt = it, bx = ix, s--;
+                    }
+                    if (it == -1 && (bt & 7) != REG_NUM_ESP &&
+                        (eaflags & EAF_TIMESTWO) &&
+                        (hb == b && ht == EAH_NOTBASE)) {
+                        /*
+                         * convert [NOSPLIT EAX*1]
+                         * to sib format with 0x0 displacement - [EAX*1+0].
+                         */
+                        it = bt, ix = bx, bt = -1, bx = 0, s = 1;
+                    }
+                }
+                if (s == 1 && it == REG_NUM_ESP) {
+                    /* swap ESP into base if scale is 1 */
+                    t = it, it = bt, bt = t;
+                    x = ix, ix = bx, bx = x;
+                }
+                if (it == REG_NUM_ESP ||
+                    (s != 1 && s != 2 && s != 4 && s != 8 && it != -1))
+                    goto err;        /* wrong, for various reasons */
+
+                output->rex |= rexflags(it, ix, REX_X);
+                output->rex |= rexflags(bt, bx, REX_B);
+
+                if (it == -1 && (bt & 7) != REG_NUM_ESP && !(eaflags & EAF_SIB)) {
+                    /* no SIB needed */
+                    int mod, rm;
+
+                    if (bt == -1) {
+                        rm = 5;
+                        mod = 0;
+                    } else {
+                        rm = (bt & 7);
+                        if (rm != REG_NUM_EBP && o == 0 &&
+                            seg == NO_SEG && !forw_ref &&
+                            !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
+                            mod = 0;
+                        else if (IS_MOD_01())
+                            mod = 1;
+                        else
+                            mod = 2;
+                    }
+
+                    output->sib_present = false;
+                    output->bytes       = (bt == -1 || mod == 2 ? 4 : mod);
+                    output->modrm       = GEN_MODRM(mod, rfield, rm);
+                } else {
+                    /* we need a SIB */
+                    int mod, scale, index, base;
+
+                    if (it == -1)
+                        index = 4, s = 1;
+                    else
+                        index = (it & 7);
+
+                    switch (s) {
+                    case 1:
+                        scale = 0;
+                        break;
+                    case 2:
+                        scale = 1;
+                        break;
+                    case 4:
+                        scale = 2;
+                        break;
+                    case 8:
+                        scale = 3;
+                        break;
+                    default:   /* then what the smeg is it? */
+                        goto err;    /* panic */
+                    }
+
+                    if (bt == -1) {
+                        base = 5;
+                        mod = 0;
+                    } else {
+                        base = (bt & 7);
+                        if (base != REG_NUM_EBP && o == 0 &&
+                            seg == NO_SEG && !forw_ref &&
+                            !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
+                            mod = 0;
+                        else if (IS_MOD_01())
+                            mod = 1;
+                        else
+                            mod = 2;
+                    }
+
+                    output->sib_present = true;
+                    output->bytes       = (bt == -1 || mod == 2 ? 4 : mod);
+                    output->modrm       = GEN_MODRM(mod, rfield, 4);
+                    output->sib         = GEN_SIB(scale, index, base);
+                }
+            } else {            /* it's 16-bit */
+                int mod, rm;
+                int16_t o = input->offset;
+
+                /* check for 64-bit long mode */
+                if (addrbits == 64)
+                    goto err;
+
+                /* check all registers are BX, BP, SI or DI */
+                if ((b != -1 && b != R_BP && b != R_BX && b != R_SI && b != R_DI) ||
+                    (i != -1 && i != R_BP && i != R_BX && i != R_SI && i != R_DI))
+                    goto err;
+
+                /* ensure the user didn't specify DWORD/QWORD */
+                if (input->disp_size == 32 || input->disp_size == 64)
+                    goto err;
+
+                if (s != 1 && i != -1)
+                    goto err;        /* no can do, in 16-bit EA */
+                if (b == -1 && i != -1) {
+                    int tmp = b;
+                    b = i;
+                    i = tmp;
+                }               /* swap */
+                if ((b == R_SI || b == R_DI) && i != -1) {
+                    int tmp = b;
+                    b = i;
+                    i = tmp;
+                }
+                /* have BX/BP as base, SI/DI index */
+                if (b == i)
+                    goto err;        /* shouldn't ever happen, in theory */
+                if (i != -1 && b != -1 &&
+                    (i == R_BP || i == R_BX || b == R_SI || b == R_DI))
+                    goto err;        /* invalid combinations */
+                if (b == -1)            /* pure offset: handled above */
+                    goto err;        /* so if it gets to here, panic! */
+
+                rm = -1;
+                if (i != -1)
+                    switch (i * 256 + b) {
+                    case R_SI * 256 + R_BX:
+                        rm = 0;
+                        break;
+                    case R_DI * 256 + R_BX:
+                        rm = 1;
+                        break;
+                    case R_SI * 256 + R_BP:
+                        rm = 2;
+                        break;
+                    case R_DI * 256 + R_BP:
+                        rm = 3;
+                        break;
+                } else
+                    switch (b) {
+                    case R_SI:
+                        rm = 4;
+                        break;
+                    case R_DI:
+                        rm = 5;
+                        break;
+                    case R_BP:
+                        rm = 6;
+                        break;
+                    case R_BX:
+                        rm = 7;
+                        break;
+                    }
+                if (rm == -1)           /* can't happen, in theory */
+                    goto err;        /* so panic if it does */
+
+                if (o == 0 && seg == NO_SEG && !forw_ref && rm != 6 &&
+                    !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
+                    mod = 0;
+                else if (IS_MOD_01())
+                    mod = 1;
+                else
+                    mod = 2;
+
+                output->sib_present = false;    /* no SIB - it's 16-bit */
+                output->bytes       = mod;      /* bytes of offset needed */
+                output->modrm       = GEN_MODRM(mod, rfield, rm);
+            }
+
+            if (eaflags & EAF_REL) {
+                /* Explicit REL reference with indirect memory */
+                nasm_warn(WARN_OTHER,
+                          "indirect address displacements cannot be RIP-relative");
+            }
+        }
+    }
+
+    output->size = 1 + output->sib_present + output->bytes;
+    /*
+     * The type parsed might not match one supplied by
+     * a caller. In this case exit with error and let
+     * the caller to decide how critical it is.
+     */
+    if (output->type != expected)
+        goto err_set_msg;
+
+    return 0;
+
+err_set_msg:
+    if (!errmsg) {
+        /* Default error message */
+        static char invalid_address_msg[40];
+        snprintf(invalid_address_msg, sizeof invalid_address_msg,
+                 "invalid %d-bit effective address", bits);
+        errmsg = invalid_address_msg;
+    }
+    *errmsgp = errmsg;
+    return -1;
+
+err:
+    output->type = EA_INVALID;
+    goto err_set_msg;
+}
+
+static void add_asp(insn *ins, int addrbits)
+{
+    int j, valid;
+    int defdisp;
+
+    valid = (addrbits == 64) ? 64|32 : 32|16;
+
+    switch (ins->prefixes[PPS_ASIZE]) {
+    case P_A16:
+        valid &= 16;
+        break;
+    case P_A32:
+        valid &= 32;
+        break;
+    case P_A64:
+        valid &= 64;
+        break;
+    case P_ASP:
+        valid &= (addrbits == 32) ? 16 : 32;
+        break;
+    default:
+        break;
+    }
+
+    for (j = 0; j < ins->operands; j++) {
+        if (is_class(MEMORY, ins->oprs[j].type)) {
+            opflags_t i, b;
+
+            /* Verify as Register */
+            if (!is_register(ins->oprs[j].indexreg))
+                i = 0;
+            else
+                i = nasm_reg_flags[ins->oprs[j].indexreg];
+
+            /* Verify as Register */
+            if (!is_register(ins->oprs[j].basereg))
+                b = 0;
+            else
+                b = nasm_reg_flags[ins->oprs[j].basereg];
+
+            if (ins->oprs[j].scale == 0)
+                i = 0;
+
+            if (!i && !b) {
+                int ds = ins->oprs[j].disp_size;
+                if ((addrbits != 64 && ds > 8) ||
+                    (addrbits == 64 && ds == 16))
+                    valid &= ds;
+            } else {
+                if (!(REG16 & ~b))
+                    valid &= 16;
+                if (!(REG32 & ~b))
+                    valid &= 32;
+                if (!(REG64 & ~b))
+                    valid &= 64;
+
+                if (!(REG16 & ~i))
+                    valid &= 16;
+                if (!(REG32 & ~i))
+                    valid &= 32;
+                if (!(REG64 & ~i))
+                    valid &= 64;
+            }
+        }
+    }
+
+    if (valid & addrbits) {
+        ins->addr_size = addrbits;
+    } else if (valid & ((addrbits == 32) ? 16 : 32)) {
+        /* Add an address size prefix */
+        ins->prefixes[PPS_ASIZE] = (addrbits == 32) ? P_A16 : P_A32;;
+        ins->addr_size = (addrbits == 32) ? 16 : 32;
+    } else {
+        /* Impossible... */
+        nasm_nonfatal("impossible combination of address sizes");
+        ins->addr_size = addrbits; /* Error recovery */
+    }
+
+    defdisp = ins->addr_size == 16 ? 16 : 32;
+
+    for (j = 0; j < ins->operands; j++) {
+        if (!(MEM_OFFS & ~ins->oprs[j].type) &&
+            (ins->oprs[j].disp_size ? ins->oprs[j].disp_size : defdisp) != ins->addr_size) {
+            /*
+             * mem_offs sizes must match the address size; if not,
+             * strip the MEM_OFFS bit and match only EA instructions
+             */
+            ins->oprs[j].type &= ~(MEM_OFFS & ~MEMORY);
+        }
+    }
+}
diff --git a/vere/ext/nasm/asm/assemble.h b/vere/ext/nasm/asm/assemble.h
new file mode 100644
index 0000000..5070662
--- /dev/null
+++ b/vere/ext/nasm/asm/assemble.h
@@ -0,0 +1,56 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * assemble.h - header file for stuff private to the assembler
+ */
+
+#ifndef NASM_ASSEMBLE_H
+#define NASM_ASSEMBLE_H
+
+#include "nasm.h"
+#include "iflag.h"
+
+extern iflag_t cpu, cmd_cpu;
+void set_cpu(const char *cpuspec);
+
+extern bool in_absolute;        /* Are we in an absolute segment? */
+extern struct location absolute;
+
+int64_t insn_size(int32_t segment, int64_t offset, int bits, insn *instruction);
+int64_t assemble(int32_t segment, int64_t offset, int bits, insn *instruction);
+
+bool process_directives(char *);
+void process_pragma(char *);
+
+#endif
diff --git a/vere/ext/nasm/asm/directbl.c b/vere/ext/nasm/asm/directbl.c
new file mode 100644
index 0000000..2a1d058
--- /dev/null
+++ b/vere/ext/nasm/asm/directbl.c
@@ -0,0 +1,192 @@
+/*
+ * This file is generated from ./asm/directiv.dat
+ * by perfhash.pl; do not edit.
+ */
+
+#include "directiv.h"
+
+const char * const directive_tbl[40] = {
+    "absolute",
+    "bits",
+    "common",
+    "cpu",
+    "debug",
+    "default",
+    "extern",
+    "float",
+    "global",
+    "static",
+    "list",
+    "section",
+    "segment",
+    "warning",
+    "sectalign",
+    "pragma",
+    "required",
+    "export",
+    "group",
+    "import",
+    "library",
+    "map",
+    "module",
+    "org",
+    "osabi",
+    "safeseh",
+    "uppercase",
+    "prefix",
+    "suffix",
+    "gprefix",
+    "gsuffix",
+    "lprefix",
+    "lsuffix",
+    "limit",
+    "options",
+    "subsections_via_symbols",
+    "no_dead_strip",
+    "maxdump",
+    "nodepend",
+    "noseclabels"
+};
+
+#define INVALID_HASH_ENTRY (65536/3)
+
+static const int16_t directive_hashvals[128] = {
+    0,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    0,
+    6,
+    0,
+    0,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    0,
+    3,
+    INVALID_HASH_ENTRY,
+    0,
+    0,
+    0,
+    32,
+    0,
+    4,
+    0,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    12,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    1,
+    INVALID_HASH_ENTRY,
+    0,
+    33,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    0,
+    0,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    25,
+    38,
+    1,
+    9,
+    INVALID_HASH_ENTRY,
+    31,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    -12,
+    0,
+    INVALID_HASH_ENTRY,
+    34,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    29,
+    INVALID_HASH_ENTRY,
+    13,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    27,
+    INVALID_HASH_ENTRY,
+    7,
+    22,
+    0,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    19,
+    INVALID_HASH_ENTRY,
+    37,
+    5,
+    -11,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    16,
+    15,
+    11,
+    INVALID_HASH_ENTRY,
+    23,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    0,
+    36,
+    12,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    27,
+    INVALID_HASH_ENTRY,
+    21,
+    26,
+    10,
+    5,
+    29,
+    35,
+    INVALID_HASH_ENTRY,
+    INVALID_HASH_ENTRY,
+    30,
+    INVALID_HASH_ENTRY,
+    28,
+    4,
+    INVALID_HASH_ENTRY
+};
+
+const struct perfect_hash directive_hash = {
+    UINT64_C(0x076259c3e291c26c),
+    UINT32_C(0x7e),
+    UINT32_C(40),
+    3,
+    (D_unknown),
+    directive_hashvals,
+    directive_tbl
+};
diff --git a/vere/ext/nasm/asm/directiv.c b/vere/ext/nasm/asm/directiv.c
new file mode 100644
index 0000000..a4f54b4
--- /dev/null
+++ b/vere/ext/nasm/asm/directiv.c
@@ -0,0 +1,567 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Parse and handle assembler directives
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "ilog2.h"
+#include "error.h"
+#include "floats.h"
+#include "stdscan.h"
+#include "preproc.h"
+#include "eval.h"
+#include "assemble.h"
+#include "outform.h"
+#include "listing.h"
+#include "labels.h"
+#include "iflag.h"
+
+struct cpunames {
+    const char *name;
+    unsigned int level;
+    /* Eventually a table of features */
+};
+
+static void iflag_set_cpu(iflag_t *a, unsigned int lvl)
+{
+    a->field[0] = 0;     /* Not applicable to the CPU type */
+    iflag_set_all_features(a);    /* All feature masking bits set for now */
+    if (lvl >= IF_ANY) {
+        /* This is a hack for now */
+        iflag_set(a, IF_LATEVEX);
+    }
+    a->field[IF_CPU_FIELD] &= ~IF_CPU_LEVEL_MASK;
+    iflag_set(a, lvl);
+}
+
+void set_cpu(const char *value)
+{
+    const char *p;
+    char modifier;
+    const struct cpunames *cpuflag;
+    static const struct cpunames cpunames[] = {
+        { "default", IF_DEFAULT }, /* Must be first */
+        { "8086", IF_8086 },
+        { "186",  IF_186  },
+        { "286",  IF_286  },
+        { "386",  IF_386  },
+        { "486",  IF_486  },
+        { "586",  IF_PENT },
+        { "pentium", IF_PENT },
+        { "pentiummmx", IF_PENT },
+        { "686",  IF_P6 },
+        { "p6",   IF_P6 },
+        { "ppro", IF_P6 },
+        { "pentiumpro", IF_P6 },
+        { "p2", IF_P6 },        /* +MMX */
+        { "pentiumii", IF_P6 },
+        { "p3", IF_KATMAI },
+        { "katmai", IF_KATMAI },
+        { "p4", IF_WILLAMETTE },
+        { "willamette", IF_WILLAMETTE },
+        { "prescott", IF_PRESCOTT },
+        { "x64", IF_X86_64 },
+        { "x86-64", IF_X86_64 },
+        { "ia64", IF_IA64 },
+        { "ia-64", IF_IA64 },
+        { "itanium", IF_IA64 },
+        { "itanic", IF_IA64 },
+        { "merced", IF_IA64 },
+        { "nehalem", IF_NEHALEM },
+        { "westmere", IF_WESTMERE },
+        { "sandybridge", IF_SANDYBRIDGE },
+        { "ivybridge", IF_FUTURE },
+        { "any", IF_ANY },
+        { "all", IF_ANY },
+        { "latevex", IF_LATEVEX },
+        { "evex", IF_EVEX },
+        { "vex", IF_VEX },
+        { NULL, 0 }
+    };
+
+    if (!value) {
+        iflag_set_cpu(&cpu, cpunames[0].level);
+        return;
+    }
+
+    p = value;
+    modifier = '+';
+    while (*p) {
+        int len = strcspn(p, " ,");
+
+        while (len && (*p == '+' || *p == '-' || *p == '*')) {
+            modifier = *p++;
+            len--;
+            if (!len && modifier == '*')
+                cpu = cmd_cpu;
+        }
+
+        if (len) {
+            bool invert_flag = false;
+
+            if (len >= 3 && !nasm_memicmp(p, "no", 2)) {
+                invert_flag = true;
+                p += 2;
+                len -= 2;
+            }
+
+            for (cpuflag = cpunames; cpuflag->name; cpuflag++)
+                if (!nasm_strnicmp(p, cpuflag->name, len))
+                    break;
+
+            if (!cpuflag->name) {
+                nasm_nonfatal("unknown CPU type or flag '%.*s'", len, p);
+                return;
+            }
+
+            if (cpuflag->level >= IF_CPU_FIRST && cpuflag->level <= IF_ANY) {
+                iflag_set_cpu(&cpu, cpuflag->level);
+            } else {
+                switch (modifier) {
+                case '-':
+                    invert_flag = !invert_flag;
+                    break;
+                case '*':
+                    invert_flag ^= iflag_test(&cmd_cpu, cpuflag->level);
+                    break;
+                default:
+                    break;
+                }
+
+                iflag_set(&cpu, cpuflag->level);
+                if (invert_flag)
+                    iflag_clear(&cpu, cpuflag->level);
+            }
+        }
+        p += len;
+        if (!*p)
+            break;
+        p++;                /* Skip separator */
+    }
+}
+
+static int get_bits(const char *value)
+{
+    int i = atoi(value);
+
+    switch (i) {
+    case 16:
+        break;                  /* Always safe */
+    case 32:
+        if (!iflag_cpu_level_ok(&cpu, IF_386)) {
+            nasm_nonfatal("cannot specify 32-bit segment on processor below a 386");
+            i = 16;
+        }
+        break;
+    case 64:
+        if (!iflag_cpu_level_ok(&cpu, IF_X86_64)) {
+            nasm_nonfatal("cannot specify 64-bit segment on processor below an x86-64");
+            i = 16;
+        }
+        break;
+    default:
+        nasm_nonfatal("`%s' is not a valid segment size; must be 16, 32 or 64",
+                      value);
+        i = 16;
+        break;
+    }
+    return i;
+}
+
+static enum directive parse_directive_line(char **directive, char **value)
+{
+    char *p, *q, *buf;
+
+    buf = nasm_skip_spaces(*directive);
+
+    /*
+     * It should be enclosed in [ ].
+     * XXX: we don't check there is nothing else on the remainder of the
+     * line, except a possible comment.
+     */
+    if (*buf != '[')
+        return D_none;
+    q = strchr(buf, ']');
+    if (!q)
+        return D_corrupt;
+
+    /*
+     * Strip off the comments.  XXX: this doesn't account for quoted
+     * strings inside a directive.  We should really strip the
+     * comments in generic code, not here.  While we're at it, it
+     * would be better to pass the backend a series of tokens instead
+     * of a raw string, and actually process quoted strings for it,
+     * like of like argv is handled in C.
+     */
+    p = strchr(buf, ';');
+    if (p) {
+        if (p < q) /* ouch! somewhere inside */
+            return D_corrupt;
+        *p = '\0';
+    }
+
+    /* no brace, no trailing spaces */
+    *q = '\0';
+    nasm_zap_spaces_rev(--q);
+
+    /* directive */
+    p = nasm_skip_spaces(++buf);
+    q = nasm_skip_word(p);
+    if (!q)
+        return D_corrupt; /* sigh... no value there */
+    *q = '\0';
+    *directive = p;
+
+    /* and value finally */
+    p = nasm_skip_spaces(++q);
+    *value = p;
+
+    return directive_find(*directive);
+}
+
+/*
+ * Process a line from the assembler and try to handle it if it
+ * is a directive.  Return true if the line was handled (including
+ * if it was an error), false otherwise.
+ */
+bool process_directives(char *directive)
+{
+    enum directive d;
+    char *value, *p, *q, *special;
+    struct tokenval tokval;
+    bool bad_param = false;
+    enum label_type type;
+
+    d = parse_directive_line(&directive, &value);
+
+    switch (d) {
+    case D_none:
+        return D_none;      /* Not a directive */
+
+    case D_corrupt:
+	nasm_nonfatal("invalid directive line");
+	break;
+
+    default:			/* It's a backend-specific directive */
+        switch (ofmt->directive(d, value)) {
+        case DIRR_UNKNOWN:
+            goto unknown;
+        case DIRR_OK:
+        case DIRR_ERROR:
+            break;
+        case DIRR_BADPARAM:
+            bad_param = true;
+            break;
+        default:
+            panic();
+        }
+        break;
+
+    case D_unknown:
+    unknown:
+        nasm_nonfatal("unrecognized directive [%s]", directive);
+        break;
+
+    case D_SEGMENT:         /* [SEGMENT n] */
+    case D_SECTION:
+    {
+	int sb = globalbits;
+        int32_t seg = ofmt->section(value, &sb);
+
+        if (seg == NO_SEG) {
+            nasm_nonfatal("segment name `%s' not recognized", value);
+        } else {
+            globalbits = sb;
+            switch_segment(seg);
+        }
+        break;
+    }
+
+    case D_SECTALIGN:       /* [SECTALIGN n] */
+    {
+	expr *e;
+
+        if (*value) {
+            stdscan_reset();
+            stdscan_set(value);
+            tokval.t_type = TOKEN_INVALID;
+            e = evaluate(stdscan, NULL, &tokval, NULL, true, NULL);
+            if (e) {
+                uint64_t align = e->value;
+
+		if (!is_power2(e->value)) {
+                    nasm_nonfatal("segment alignment `%s' is not power of two",
+				  value);
+		} else if (align > UINT64_C(0x7fffffff)) {
+                    /*
+                     * FIXME: Please make some sane message here
+                     * ofmt should have some 'check' method which
+                     * would report segment alignment bounds.
+                     */
+		    nasm_nonfatal("absurdly large segment alignment `%s' (2^%d)",
+				  value, ilog2_64(align));
+                }
+
+                /* callee should be able to handle all details */
+                if (location.segment != NO_SEG)
+                    ofmt->sectalign(location.segment, align);
+            }
+        }
+        break;
+    }
+
+    case D_BITS:            /* [BITS bits] */
+        globalbits = get_bits(value);
+        break;
+
+    case D_GLOBAL:          /* [GLOBAL|STATIC|EXTERN|COMMON symbol:special] */
+        type = LBL_GLOBAL;
+        goto symdef;
+    case D_STATIC:
+        type = LBL_STATIC;
+        goto symdef;
+    case D_EXTERN:
+        type = LBL_EXTERN;
+        goto symdef;
+    case D_REQUIRED:
+        type = LBL_REQUIRED;
+        goto symdef;
+    case D_COMMON:
+        type = LBL_COMMON;
+        goto symdef;
+
+    symdef:
+    {
+        bool validid = true;
+        int64_t size = 0;
+        char *sizestr;
+        bool rn_error;
+
+        if (*value == '$')
+            value++;        /* skip initial $ if present */
+
+        q = value;
+        if (!nasm_isidstart(*q)) {
+            validid = false;
+        } else {
+            q++;
+            while (*q && *q != ':' && !nasm_isspace(*q)) {
+                if (!nasm_isidchar(*q))
+                    validid = false;
+                q++;
+            }
+        }
+        if (!validid) {
+            nasm_nonfatal("identifier expected after %s, got `%s'",
+			  directive, value);
+            break;
+        }
+
+        if (nasm_isspace(*q)) {
+            *q++ = '\0';
+            sizestr = q = nasm_skip_spaces(q);
+            q = strchr(q, ':');
+        } else {
+            sizestr = NULL;
+        }
+
+        if (q && *q == ':') {
+            *q++ = '\0';
+            special = q;
+        } else {
+            special = NULL;
+        }
+
+        if (type == LBL_COMMON) {
+            if (sizestr)
+                size = readnum(sizestr, &rn_error);
+            if (!sizestr || rn_error)
+                nasm_nonfatal("%s size specified in common declaration",
+			      sizestr ? "invalid" : "no");
+        } else if (sizestr) {
+            nasm_nonfatal("invalid syntax in %s declaration", directive);
+        }
+
+        if (!declare_label(value, type, special))
+            break;
+
+        if (type == LBL_COMMON || type == LBL_EXTERN || type == LBL_REQUIRED)
+            define_label(value, 0, size, false);
+
+	break;
+    }
+
+    case D_ABSOLUTE:        /* [ABSOLUTE address] */
+    {
+	expr *e;
+
+        stdscan_reset();
+        stdscan_set(value);
+        tokval.t_type = TOKEN_INVALID;
+        e = evaluate(stdscan, NULL, &tokval, NULL, true, NULL);
+        if (e) {
+            if (!is_reloc(e)) {
+                nasm_nonfatal("cannot use non-relocatable expression as "
+                              "ABSOLUTE address");
+            } else {
+                absolute.segment = reloc_seg(e);
+                absolute.offset = reloc_value(e);
+            }
+        } else if (pass_first()) {
+            absolute.offset = 0x100;     /* don't go near zero in case of / */
+        } else {
+            nasm_nonfatal("invalid ABSOLUTE address");
+        }
+        in_absolute = true;
+        location.segment = NO_SEG;
+        location.offset = absolute.offset;
+        break;
+    }
+
+    case D_DEBUG:           /* [DEBUG] */
+    {
+        bool badid, overlong;
+	char debugid[128];
+
+        p = value;
+        q = debugid;
+        badid = overlong = false;
+        if (!nasm_isidstart(*p)) {
+            badid = true;
+        } else {
+            while (*p && !nasm_isspace(*p)) {
+                if (q >= debugid + sizeof debugid - 1) {
+                    overlong = true;
+                    break;
+                }
+                if (!nasm_isidchar(*p))
+                    badid = true;
+                *q++ = *p++;
+            }
+            *q = 0;
+        }
+        if (badid) {
+            nasm_nonfatal("identifier expected after DEBUG");
+            break;
+        }
+        if (overlong) {
+            nasm_nonfatal("DEBUG identifier too long");
+            break;
+        }
+        p = nasm_skip_spaces(p);
+        if (pass_final())
+            dfmt->debug_directive(debugid, p);
+        break;
+    }
+
+    case D_WARNING:         /* [WARNING {push|pop|{+|-|*}warn-name}] */
+        value = nasm_skip_spaces(value);
+        if ((*value | 0x20) == 'p') {
+            if (!nasm_stricmp(value, "push"))
+                push_warnings();
+            else if (!nasm_stricmp(value, "pop"))
+                pop_warnings();
+        }
+        set_warning_status(value);
+        break;
+
+    case D_CPU:         /* [CPU] */
+        set_cpu(value);
+        break;
+
+    case D_LIST:        /* [LIST {+|-}] */
+        value = nasm_skip_spaces(value);
+        if (*value == '+') {
+            user_nolist = false;
+        } else {
+            if (*value == '-') {
+                user_nolist = true;
+            } else {
+                bad_param = true;
+            }
+        }
+        break;
+
+    case D_DEFAULT:         /* [DEFAULT] */
+        stdscan_reset();
+        stdscan_set(value);
+        tokval.t_type = TOKEN_INVALID;
+        if (stdscan(NULL, &tokval) != TOKEN_INVALID) {
+            switch (tokval.t_integer) {
+            case S_REL:
+                globalrel = 1;
+                break;
+            case S_ABS:
+                globalrel = 0;
+                break;
+            case P_BND:
+                globalbnd = 1;
+                break;
+            case P_NOBND:
+                globalbnd = 0;
+                break;
+            default:
+                bad_param = true;
+                break;
+            }
+        } else {
+            bad_param = true;
+        }
+        break;
+
+    case D_FLOAT:
+        if (float_option(value)) {
+            nasm_nonfatal("unknown 'float' directive: %s", value);
+        }
+        break;
+
+    case D_PRAGMA:
+        process_pragma(value);
+        break;
+    }
+
+
+    /* A common error message */
+    if (bad_param) {
+        nasm_nonfatal("invalid parameter to [%s] directive", directive);
+    }
+
+    return d != D_none;
+}
diff --git a/vere/ext/nasm/asm/directiv.dat b/vere/ext/nasm/asm/directiv.dat
new file mode 100644
index 0000000..5659ee1
--- /dev/null
+++ b/vere/ext/nasm/asm/directiv.dat
@@ -0,0 +1,110 @@
+;; --------------------------------------------------------------------------
+;;
+;;   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+;;
+;; List of global NASM directives and pragma operations codes
+;;
+;; ALL directives, including backend-specific, need to be added here.
+;;
+;; %pragma operation keywords (the second word, after facility) MAY
+;; be added here too to assist in parsing, but it is not required.
+;; See the definition of struct pragma in include/nasm.h.
+;;
+;; The same keyword can be used as a directive and as a pragma
+;; operation, or as pragma operations in different namespaces.  The
+;; same D_ constant will be used for both, and this is perfectly
+;; acceptable.
+;;
+;; In the future, this will be turned into a general list of keywords
+;; to be parsed in special contexts.
+;;
+
+; --- General configuration
+#name directive
+#prefix D_
+#errval D_unknown
+#header directiv.h
+
+; --- Special enum values
+#special none = 0			; Must be zero
+#special unknown
+#special corrupt
+
+; --- Global directives
+absolute
+bits
+common
+cpu
+debug
+default
+extern
+float
+global
+static
+list
+section
+segment
+warning
+sectalign
+pragma
+required
+
+; --- Format-specific directives
+export				; outcoff, outobj
+group				; outobj
+import				; outobj
+library				; outrdf2
+map				; outbin
+module				; outrdf2
+org				; outbin
+osabi				; outelf
+safeseh				; outcoff
+uppercase			; outieee, outobj
+
+; --- Assembler pragmas
+prefix
+suffix
+gprefix
+gsuffix
+lprefix
+lsuffix
+limit
+
+; --- Listing pragmas
+options
+
+; --- Backend pragmas
+subsections_via_symbols		; macho
+no_dead_strip			; macho
+maxdump				; dbg
+nodepend			; obj
+noseclabels			; dbg
diff --git a/vere/ext/nasm/asm/directiv.h b/vere/ext/nasm/asm/directiv.h
new file mode 100644
index 0000000..1911264
--- /dev/null
+++ b/vere/ext/nasm/asm/directiv.h
@@ -0,0 +1,79 @@
+/*
+ * This file is generated from ./asm/directiv.dat
+ * by perfhash.pl; do not edit.
+ */
+
+#ifndef DIRECTIV_H
+#define DIRECTIV_H 1
+
+#include "perfhash.h"
+
+enum directive {
+    D_none,
+    D_unknown,
+    D_corrupt,
+    D_ABSOLUTE,
+    D_BITS,
+    D_COMMON,
+    D_CPU,
+    D_DEBUG,
+    D_DEFAULT,
+    D_EXTERN,
+    D_FLOAT,
+    D_GLOBAL,
+    D_STATIC,
+    D_LIST,
+    D_SECTION,
+    D_SEGMENT,
+    D_WARNING,
+    D_SECTALIGN,
+    D_PRAGMA,
+    D_REQUIRED,
+    D_EXPORT,
+    D_GROUP,
+    D_IMPORT,
+    D_LIBRARY,
+    D_MAP,
+    D_MODULE,
+    D_ORG,
+    D_OSABI,
+    D_SAFESEH,
+    D_UPPERCASE,
+    D_PREFIX,
+    D_SUFFIX,
+    D_GPREFIX,
+    D_GSUFFIX,
+    D_LPREFIX,
+    D_LSUFFIX,
+    D_LIMIT,
+    D_OPTIONS,
+    D_SUBSECTIONS_VIA_SYMBOLS,
+    D_NO_DEAD_STRIP,
+    D_MAXDUMP,
+    D_NODEPEND,
+    D_NOSECLABELS
+};
+
+extern const struct perfect_hash directive_hash;
+extern const char * const directive_tbl[40];
+
+static inline enum directive directive_find(const char *str)
+{
+    return perfhash_find(&directive_hash, str);
+}
+
+static inline const char * directive_name(enum directive x)
+{
+    size_t ix = (size_t)x - (3);
+    if (ix >= 40)
+        return NULL;
+    return directive_tbl[ix];
+}
+
+static inline const char * directive_dname(enum directive x)
+{
+    const char *y = directive_name(x);
+    return y ? y : invalid_enum_str(x);
+}
+
+#endif /* DIRECTIV_H */
diff --git a/vere/ext/nasm/asm/error.c b/vere/ext/nasm/asm/error.c
new file mode 100644
index 0000000..192555d
--- /dev/null
+++ b/vere/ext/nasm/asm/error.c
@@ -0,0 +1,288 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2019 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * error.c - error message handling routines for the assembler
+ */
+
+#include "compiler.h"
+
+
+#include "nasmlib.h"
+#include "error.h"
+
+/* Common function body */
+#define nasm_do_error(_sev,_flags)				\
+	va_list ap;						\
+        va_start(ap, fmt);					\
+	if ((_sev) >= ERR_CRITICAL)				\
+		nasm_verror_critical((_sev)|(_flags), fmt, ap);	\
+	else							\
+		nasm_verror((_sev)|(_flags), fmt, ap);		\
+	va_end(ap);						\
+	if ((_sev) >= ERR_FATAL)                                \
+		abort();
+
+
+void nasm_error(errflags severity, const char *fmt, ...)
+{
+	nasm_do_error(severity & ERR_MASK, severity & ~ERR_MASK);
+}
+
+#define nasm_err_helpers(_type, _name, _sev)				\
+_type nasm_ ## _name ## f (errflags flags, const char *fmt, ...)	\
+{									\
+	nasm_do_error(_sev, flags);					\
+}									\
+_type nasm_ ## _name (const char *fmt, ...)				\
+{									\
+	nasm_do_error(_sev, 0);						\
+}
+
+nasm_err_helpers(void,       listmsg,  ERR_LISTMSG)
+nasm_err_helpers(void,       debug,    ERR_DEBUG)
+nasm_err_helpers(void,       info,     ERR_INFO)
+nasm_err_helpers(void,       nonfatal, ERR_NONFATAL)
+nasm_err_helpers(fatal_func, fatal,    ERR_FATAL)
+nasm_err_helpers(fatal_func, critical, ERR_CRITICAL)
+nasm_err_helpers(fatal_func, panic,    ERR_PANIC)
+
+/*
+ * Strongly discourage warnings without level by require flags on warnings.
+ * This means nasm_warn() is the equivalent of the -f variants of the
+ * other ones.
+ */
+void nasm_warn(errflags flags, const char *fmt, ...)
+{
+	nasm_do_error(ERR_WARNING, flags);
+}
+
+fatal_func nasm_panic_from_macro(const char *file, int line)
+{
+	nasm_panic("internal error at %s:%d\n", file, line);
+}
+
+fatal_func nasm_assert_failed(const char *file, int line, const char *msg)
+{
+	nasm_panic("assertion %s failed at %s:%d", msg, file, line);
+}
+
+
+/*
+ * Warning stack management. Note that there is an implicit "push"
+ * after the command line has been parsed, but this particular push
+ * cannot be popped.
+ */
+struct warning_stack {
+	struct warning_stack *next;
+	uint8_t state[sizeof warning_state];
+};
+static struct warning_stack *warning_stack, *warning_state_init;
+
+/* Push the warning status onto the warning stack */
+void push_warnings(void)
+{
+	struct warning_stack *ws;
+
+	ws = nasm_malloc(sizeof *ws);
+	memcpy(ws->state, warning_state, sizeof warning_state);
+	ws->next = warning_stack;
+	warning_stack = ws;
+}
+
+/* Pop the warning status off the warning stack */
+void pop_warnings(void)
+{
+	struct warning_stack *ws = warning_stack;
+
+	memcpy(warning_state, ws->state, sizeof warning_state);
+	if (!ws->next) {
+		/*!
+		 *!warn-stack-empty [on] warning stack empty
+		 *!  a [WARNING POP] directive was executed when
+		 *!  the warning stack is empty. This is treated
+		 *!  as a [WARNING *all] directive.
+		 */
+		nasm_warn(WARN_WARN_STACK_EMPTY, "warning stack empty");
+	} else {
+		warning_stack = ws->next;
+		nasm_free(ws);
+	}
+}
+
+/* Call after the command line is parsed, but before the first pass */
+void init_warnings(void)
+{
+	push_warnings();
+	warning_state_init = warning_stack;
+}
+
+
+/* Call after each pass */
+void reset_warnings(void)
+{
+	struct warning_stack *ws = warning_stack;
+
+	/* Unwind the warning stack. We do NOT delete the last entry! */
+	while (ws->next) {
+		struct warning_stack *wst = ws;
+		ws = ws->next;
+		nasm_free(wst);
+	}
+	warning_stack = ws;
+	memcpy(warning_state, ws->state, sizeof warning_state);
+}
+
+/*
+ * This is called when processing a -w or -W option, or a warning directive.
+ * Returns ok if the action was successful.
+ *
+ * Special pseudo-warnings:
+ *
+ *!other [on] any warning not specifically mentioned above
+ *!  specifies any warning not included in any specific warning class.
+ *
+ *!all [all] all possible warnings
+ *!  is an group alias for \e{all} warning classes.  Thus, \c{-w+all}
+ *!  enables all available warnings, and \c{-w-all} disables warnings
+ *!  entirely (since NASM 2.13).
+ */
+bool set_warning_status(const char *value)
+{
+	enum warn_action { WID_OFF, WID_ON, WID_RESET };
+	enum warn_action action;
+        const struct warning_alias *wa;
+        size_t vlen;
+	bool ok = false;
+	uint8_t mask;
+
+	value = nasm_skip_spaces(value);
+
+	switch (*value) {
+	case '-':
+		action = WID_OFF;
+		value++;
+		break;
+	case '+':
+		action = WID_ON;
+		value++;
+		break;
+	case '*':
+		action = WID_RESET;
+		value++;
+		break;
+	case 'N':
+	case 'n':
+		if (!nasm_strnicmp(value, "no-", 3)) {
+			action = WID_OFF;
+			value += 3;
+			break;
+		} else if (!nasm_stricmp(value, "none")) {
+			action = WID_OFF;
+			value = NULL;
+			break;
+		}
+		/* else fall through */
+	default:
+		action = WID_ON;
+		break;
+	}
+
+	mask = WARN_ST_ENABLED;
+
+	if (value && !nasm_strnicmp(value, "error", 5)) {
+		switch (value[5]) {
+		case '=':
+			mask = WARN_ST_ERROR;
+			value += 6;
+			break;
+		case '\0':
+			mask = WARN_ST_ERROR;
+			value = NULL;
+			break;
+		default:
+			/* Just an accidental prefix? */
+			break;
+		}
+	}
+
+	if (value && !nasm_stricmp(value, "all"))
+		value = NULL;
+
+        vlen = value ? strlen(value) : 0;
+
+	/*
+         * This is inefficient, but it shouldn't matter.
+         * Note: warning_alias[0] is "all".
+         */
+	for (wa = warning_alias+1;
+             wa < &warning_alias[NUM_WARNING_ALIAS]; wa++) {
+            enum warn_index i = wa->warning;
+
+            if (value) {
+                char sep;
+
+                if (nasm_strnicmp(value, wa->name, vlen))
+                    continue;   /* Not a prefix */
+
+                sep = wa->name[vlen];
+                if (sep != '\0' && sep != '-')
+                    continue;   /* Not a valid prefix */
+            }
+
+            ok = true; /* At least one action taken */
+            switch (action) {
+            case WID_OFF:
+                warning_state[i] &= ~mask;
+                break;
+            case WID_ON:
+                warning_state[i] |= mask;
+                break;
+            case WID_RESET:
+                warning_state[i] &= ~mask;
+                warning_state[i] |= warning_state_init->state[i] & mask;
+                break;
+            }
+        }
+
+        if (!ok && value) {
+            /*!
+             *!unknown-warning [off] unknown warning in -W/-w or warning directive
+             *!  warns about a \c{-w} or \c{-W} option or a \c{[WARNING]} directive
+             *!  that contains an unknown warning name or is otherwise not possible to process.
+             */
+            nasm_warn(WARN_UNKNOWN_WARNING, "unknown warning name: %s", value);
+	}
+
+	return ok;
+}
diff --git a/vere/ext/nasm/asm/eval.c b/vere/ext/nasm/asm/eval.c
new file mode 100644
index 0000000..80fb4a2
--- /dev/null
+++ b/vere/ext/nasm/asm/eval.c
@@ -0,0 +1,1067 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * eval.c    expression evaluator for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "ilog2.h"
+#include "error.h"
+#include "eval.h"
+#include "labels.h"
+#include "floats.h"
+#include "assemble.h"
+
+#define TEMPEXPRS_DELTA 128
+#define TEMPEXPR_DELTA 8
+
+static scanner scanfunc;        /* Address of scanner routine */
+static void *scpriv;            /* Scanner private pointer */
+
+static expr **tempexprs = NULL;
+static int ntempexprs;
+static int tempexprs_size = 0;
+
+static expr *tempexpr;
+static int ntempexpr;
+static int tempexpr_size;
+
+static struct tokenval *tokval; /* The current token */
+static int tt;                   /* The t_type of tokval */
+
+static bool critical;
+static int *opflags;
+
+static struct eval_hints *hint;
+static int64_t deadman;
+
+
+/*
+ * Unimportant cleanup is done to avoid confusing people who are trying
+ * to debug real memory leaks
+ */
+void eval_cleanup(void)
+{
+    while (ntempexprs)
+        nasm_free(tempexprs[--ntempexprs]);
+    nasm_free(tempexprs);
+}
+
+/*
+ * Construct a temporary expression.
+ */
+static void begintemp(void)
+{
+    tempexpr = NULL;
+    tempexpr_size = ntempexpr = 0;
+}
+
+static void addtotemp(int32_t type, int64_t value)
+{
+    while (ntempexpr >= tempexpr_size) {
+        tempexpr_size += TEMPEXPR_DELTA;
+        tempexpr = nasm_realloc(tempexpr,
+                                tempexpr_size * sizeof(*tempexpr));
+    }
+    tempexpr[ntempexpr].type = type;
+    tempexpr[ntempexpr++].value = value;
+}
+
+static expr *finishtemp(void)
+{
+    addtotemp(0L, 0L);          /* terminate */
+    while (ntempexprs >= tempexprs_size) {
+        tempexprs_size += TEMPEXPRS_DELTA;
+        tempexprs = nasm_realloc(tempexprs,
+                                 tempexprs_size * sizeof(*tempexprs));
+    }
+    return tempexprs[ntempexprs++] = tempexpr;
+}
+
+/*
+ * Add two vector datatypes. We have some bizarre behaviour on far-
+ * absolute segment types: we preserve them during addition _only_
+ * if one of the segments is a truly pure scalar.
+ */
+static expr *add_vectors(expr * p, expr * q)
+{
+    int preserve;
+
+    preserve = is_really_simple(p) || is_really_simple(q);
+
+    begintemp();
+
+    while (p->type && q->type &&
+           p->type < EXPR_SEGBASE + SEG_ABS &&
+           q->type < EXPR_SEGBASE + SEG_ABS) {
+        int lasttype;
+
+        if (p->type > q->type) {
+            addtotemp(q->type, q->value);
+            lasttype = q++->type;
+        } else if (p->type < q->type) {
+            addtotemp(p->type, p->value);
+            lasttype = p++->type;
+        } else {                /* *p and *q have same type */
+            int64_t sum = p->value + q->value;
+            if (sum) {
+                addtotemp(p->type, sum);
+                if (hint)
+                    hint->type = EAH_SUMMED;
+            }
+            lasttype = p->type;
+            p++, q++;
+        }
+        if (lasttype == EXPR_UNKNOWN) {
+            return finishtemp();
+        }
+    }
+    while (p->type && (preserve || p->type < EXPR_SEGBASE + SEG_ABS)) {
+        addtotemp(p->type, p->value);
+        p++;
+    }
+    while (q->type && (preserve || q->type < EXPR_SEGBASE + SEG_ABS)) {
+        addtotemp(q->type, q->value);
+        q++;
+    }
+
+    return finishtemp();
+}
+
+/*
+ * Multiply a vector by a scalar. Strip far-absolute segment part
+ * if present.
+ *
+ * Explicit treatment of UNKNOWN is not required in this routine,
+ * since it will silently do the Right Thing anyway.
+ *
+ * If `affect_hints' is set, we also change the hint type to
+ * NOTBASE if a MAKEBASE hint points at a register being
+ * multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
+ * as the base register.
+ */
+static expr *scalar_mult(expr * vect, int64_t scalar, int affect_hints)
+{
+    expr *p = vect;
+
+    while (p->type && p->type < EXPR_SEGBASE + SEG_ABS) {
+        p->value = scalar * (p->value);
+        if (hint && hint->type == EAH_MAKEBASE &&
+            p->type == hint->base && affect_hints)
+            hint->type = EAH_NOTBASE;
+        p++;
+    }
+    p->type = 0;
+
+    return vect;
+}
+
+static expr *scalarvect(int64_t scalar)
+{
+    begintemp();
+    addtotemp(EXPR_SIMPLE, scalar);
+    return finishtemp();
+}
+
+static expr *unknown_expr(void)
+{
+    begintemp();
+    addtotemp(EXPR_UNKNOWN, 1L);
+    return finishtemp();
+}
+
+/*
+ * The SEG operator: calculate the segment part of a relocatable
+ * value. Return NULL, as usual, if an error occurs. Report the
+ * error too.
+ */
+static expr *segment_part(expr * e)
+{
+    int32_t seg;
+
+    if (is_unknown(e))
+        return unknown_expr();
+
+    if (!is_reloc(e)) {
+        nasm_nonfatal("cannot apply SEG to a non-relocatable value");
+        return NULL;
+    }
+
+    seg = reloc_seg(e);
+    if (seg == NO_SEG) {
+        nasm_nonfatal("cannot apply SEG to a non-relocatable value");
+        return NULL;
+    } else if (seg & SEG_ABS) {
+        return scalarvect(seg & ~SEG_ABS);
+    } else if (seg & 1) {
+        nasm_nonfatal("SEG applied to something which"
+                      " is already a segment base");
+        return NULL;
+    } else {
+        int32_t base = ofmt->segbase(seg + 1);
+
+        begintemp();
+        addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base),
+                  1L);
+        return finishtemp();
+    }
+}
+
+/*
+ * Recursive-descent parser. Called with a single boolean operand,
+ * which is true if the evaluation is critical (i.e. unresolved
+ * symbols are an error condition). Must update the global `tt' to
+ * reflect the token after the parsed string. May return NULL.
+ *
+ * evaluate() should report its own errors: on return it is assumed
+ * that if NULL has been returned, the error has already been
+ * reported.
+ *
+ */
+
+/*
+ * Wrapper function around the scanner
+ */
+static int scan(void)
+{
+    return tt = scanfunc(scpriv, tokval);
+}
+
+/*
+ * Grammar parsed is:
+ *
+ * expr  : bexpr [ WRT expr6 ]
+ * bexpr : cexpr
+ * cexpr : rexp0 [ {?} bexpr {:} cexpr ]
+ * rexp0 : rexp1 [ {||} rexp1...]
+ * rexp1 : rexp2 [ {^^} rexp2...]
+ * rexp2 : rexp3 [ {&&} rexp3...]
+ * rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=,<=>} expr0... ]
+ * expr0 : expr1 [ {|} expr1...]
+ * expr1 : expr2 [ {^} expr2...]
+ * expr2 : expr3 [ {&} expr3...]
+ * expr3 : expr4 [ {<<,>>,<<<,>>>} expr4...]
+ * expr4 : expr5 [ {+,-} expr5...]
+ * expr5 : expr6 [ {*,/,%,//,%%} expr6...]
+ * expr6 : { ~,+,-,IFUNC,SEG } expr6
+ *       | (bexpr)
+ *       | symbol
+ *       | $
+ *       | number
+ */
+
+static expr *cexpr(void);
+static expr *rexp0(void), *rexp1(void), *rexp2(void), *rexp3(void);
+
+static expr *expr0(void), *expr1(void), *expr2(void), *expr3(void);
+static expr *expr4(void), *expr5(void), *expr6(void);
+
+/* This inline is a placeholder for the root of the basic expression */
+static inline expr *bexpr(void)
+{
+    return cexpr();
+}
+
+static expr *cexpr(void)
+{
+    expr *e, *f, *g;
+
+    e = rexp0();
+    if (!e)
+        return NULL;
+
+    if (tt == TOKEN_QMARK) {
+        scan();
+        f = bexpr();
+        if (!f)
+            return NULL;
+
+        if (tt != ':') {
+            nasm_nonfatal("`?' without matching `:'");
+            return NULL;
+        }
+
+        scan();
+        g = cexpr();
+        if (!g)
+            return NULL;
+
+        if (is_simple(e)) {
+            e = reloc_value(e) ? f : g;
+        } else if (is_just_unknown(e)) {
+            e = unknown_expr();
+        } else {
+            nasm_nonfatal("the left-hand side of `?' must be "
+                          "a scalar value");
+        }
+    }
+
+    return e;
+}
+
+static expr *rexp0(void)
+{
+    expr *e, *f;
+
+    e = rexp1();
+    if (!e)
+        return NULL;
+
+    while (tt == TOKEN_DBL_OR) {
+        scan();
+        f = rexp1();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("`|' operator may only be applied to"
+                          " scalar values");
+        }
+
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect((int64_t)(reloc_value(e) || reloc_value(f)));
+    }
+    return e;
+}
+
+static expr *rexp1(void)
+{
+    expr *e, *f;
+
+    e = rexp2();
+    if (!e)
+        return NULL;
+
+    while (tt == TOKEN_DBL_XOR) {
+        scan();
+        f = rexp2();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("`^' operator may only be applied to"
+                          " scalar values");
+        }
+
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect((int64_t)(!reloc_value(e) ^ !reloc_value(f)));
+    }
+    return e;
+}
+
+static expr *rexp2(void)
+{
+    expr *e, *f;
+
+    e = rexp3();
+    if (!e)
+        return NULL;
+    while (tt == TOKEN_DBL_AND) {
+        scan();
+        f = rexp3();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("`&' operator may only be applied to"
+                          " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect((int64_t)(reloc_value(e) && reloc_value(f)));
+    }
+    return e;
+}
+
+static expr *rexp3(void)
+{
+    expr *e, *f;
+    int64_t v;
+
+    e = expr0();
+    if (!e)
+        return NULL;
+
+    while (tt == TOKEN_EQ || tt == TOKEN_LT || tt == TOKEN_GT ||
+           tt == TOKEN_NE || tt == TOKEN_LE || tt == TOKEN_GE ||
+           tt == TOKEN_LEG) {
+        int tto = tt;
+        scan();
+        f = expr0();
+        if (!f)
+            return NULL;
+
+        e = add_vectors(e, scalar_mult(f, -1L, false));
+
+        switch (tto) {
+        case TOKEN_EQ:
+        case TOKEN_NE:
+            if (is_unknown(e))
+                v = -1;         /* means unknown */
+            else if (!is_really_simple(e) || reloc_value(e) != 0)
+                v = (tto == TOKEN_NE);    /* unequal, so return true if NE */
+            else
+                v = (tto == TOKEN_EQ);    /* equal, so return true if EQ */
+            break;
+        default:
+            if (is_unknown(e))
+                v = -1;         /* means unknown */
+            else if (!is_really_simple(e)) {
+                nasm_nonfatal("`%s': operands differ by a non-scalar",
+                              (tto == TOKEN_LE ? "<=" :
+                               tto == TOKEN_LT ? "<" :
+                               tto == TOKEN_GE ? ">=" :
+                               tto == TOKEN_GT ? ">" :
+                               tto == TOKEN_LEG ? "<=>" :
+                               "<internal error>"));
+                v = 0;          /* must set it to _something_ */
+            } else {
+                int64_t vv = reloc_value(e);
+                if (tto == TOKEN_LEG)
+                    v = (vv < 0) ? -1 : (vv > 0) ? 1 : 0;
+                else if (vv == 0)
+                    v = (tto == TOKEN_LE || tto == TOKEN_GE);
+                else if (vv > 0)
+                    v = (tto == TOKEN_GE || tto == TOKEN_GT);
+                else            /* vv < 0 */
+                    v = (tto == TOKEN_LE || tto == TOKEN_LT);
+            }
+            break;
+        }
+
+        if (v == -1)
+            e = unknown_expr();
+        else
+            e = scalarvect(v);
+    }
+    return e;
+}
+
+static expr *expr0(void)
+{
+    expr *e, *f;
+
+    e = expr1();
+    if (!e)
+        return NULL;
+
+    while (tt == '|') {
+        scan();
+        f = expr1();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("`|' operator may only be applied to"
+                          " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect(reloc_value(e) | reloc_value(f));
+    }
+    return e;
+}
+
+static expr *expr1(void)
+{
+    expr *e, *f;
+
+    e = expr2();
+    if (!e)
+        return NULL;
+
+    while (tt == '^') {
+        scan();
+        f = expr2();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("`^' operator may only be applied to"
+                          " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect(reloc_value(e) ^ reloc_value(f));
+    }
+    return e;
+}
+
+static expr *expr2(void)
+{
+    expr *e, *f;
+
+    e = expr3();
+    if (!e)
+        return NULL;
+
+    while (tt == '&') {
+        scan();
+        f = expr3();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("`&' operator may only be applied to"
+                          " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect(reloc_value(e) & reloc_value(f));
+    }
+    return e;
+}
+
+static expr *expr3(void)
+{
+    expr *e, *f;
+
+    e = expr4();
+    if (!e)
+        return NULL;
+
+    while (tt == TOKEN_SHL || tt == TOKEN_SHR || tt == TOKEN_SAR) {
+        int tto = tt;
+        scan();
+        f = expr4();
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_nonfatal("shift operator may only be applied to"
+                          " scalar values");
+        } else if (is_just_unknown(e) || is_just_unknown(f)) {
+            e = unknown_expr();
+        } else {
+            switch (tto) {
+            case TOKEN_SHL:
+                e = scalarvect(reloc_value(e) << reloc_value(f));
+                break;
+            case TOKEN_SHR:
+                e = scalarvect(((uint64_t)reloc_value(e)) >>
+                               reloc_value(f));
+                break;
+            case TOKEN_SAR:
+                e = scalarvect(((int64_t)reloc_value(e)) >>
+                               reloc_value(f));
+                break;
+            }
+        }
+    }
+    return e;
+}
+
+static expr *expr4(void)
+{
+    expr *e, *f;
+
+    e = expr5();
+    if (!e)
+        return NULL;
+    while (tt == '+' || tt == '-') {
+        int tto = tt;
+        scan();
+        f = expr5();
+        if (!f)
+            return NULL;
+        switch (tto) {
+        case '+':
+            e = add_vectors(e, f);
+            break;
+        case '-':
+            e = add_vectors(e, scalar_mult(f, -1L, false));
+            break;
+        }
+    }
+    return e;
+}
+
+static expr *expr5(void)
+{
+    expr *e, *f;
+
+    e = expr6();
+    if (!e)
+        return NULL;
+    while (tt == '*' || tt == '/' || tt == '%' ||
+           tt == TOKEN_SDIV || tt == TOKEN_SMOD) {
+        int tto = tt;
+        scan();
+        f = expr6();
+        if (!f)
+            return NULL;
+        if (tto != '*' && (!(is_simple(e) || is_just_unknown(e)) ||
+                         !(is_simple(f) || is_just_unknown(f)))) {
+            nasm_nonfatal("division operator may only be applied to"
+                          " scalar values");
+            return NULL;
+        }
+        if (tto != '*' && !is_just_unknown(f) && reloc_value(f) == 0) {
+            nasm_nonfatal("division by zero");
+            return NULL;
+        }
+        switch (tto) {
+        case '*':
+            if (is_simple(e))
+                e = scalar_mult(f, reloc_value(e), true);
+            else if (is_simple(f))
+                e = scalar_mult(e, reloc_value(f), true);
+            else if (is_just_unknown(e) && is_just_unknown(f))
+                e = unknown_expr();
+            else {
+                nasm_nonfatal("unable to multiply two "
+                              "non-scalar objects");
+                return NULL;
+            }
+            break;
+        case '/':
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((uint64_t)reloc_value(e)) /
+                               ((uint64_t)reloc_value(f)));
+            break;
+        case '%':
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((uint64_t)reloc_value(e)) %
+                               ((uint64_t)reloc_value(f)));
+            break;
+        case TOKEN_SDIV:
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((int64_t)reloc_value(e)) /
+                               ((int64_t)reloc_value(f)));
+            break;
+        case TOKEN_SMOD:
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((int64_t)reloc_value(e)) %
+                               ((int64_t)reloc_value(f)));
+            break;
+        }
+    }
+    return e;
+}
+
+static expr *eval_floatize(enum floatize type)
+{
+    uint8_t result[16], *p;     /* Up to 128 bits */
+    int sign = 1;
+    int64_t val;
+    size_t len;
+    int i;
+    const struct ieee_format *fmt;
+
+    fmt = &fp_formats[type];
+
+    scan();
+    if (tt != '(') {
+        nasm_nonfatal("expecting `('");
+        return NULL;
+    }
+    scan();
+    if (tt == '-' || tt == '+') {
+        sign = (tt == '-') ? -1 : 1;
+        scan();
+    }
+    if (tt != TOKEN_FLOAT) {
+        nasm_nonfatal("expecting floating-point number");
+        return NULL;
+    }
+    if (!float_const(tokval->t_charptr, sign, result, type))
+        return NULL;
+    scan();
+    if (tt != ')') {
+        nasm_nonfatal("expecting `)'");
+        return NULL;
+    }
+
+    len = fmt->bytes - fmt->offset;
+    if (len > 8)
+        len = 8;                /* Max 64 bits */
+    p = result + len + fmt->offset;
+    val = 0;
+    for (i = len; i; i--) {
+        p--;
+        val = (val << 8) + *p;
+    }
+
+    begintemp();
+    addtotemp(EXPR_SIMPLE, val);
+
+    scan();
+    return finishtemp();
+}
+
+static expr *eval_strfunc(enum strfunc type, const char *name)
+{
+    char *string;
+    size_t string_len;
+    int64_t val;
+    bool parens, rn_warn;
+
+    parens = false;
+    scan();
+    if (tt == '(') {
+        parens = true;
+        scan();
+    }
+    if (tt != TOKEN_STR) {
+        nasm_nonfatal("expecting string as argument to %s", name);
+        return NULL;
+    }
+    string_len = string_transform(tokval->t_charptr, tokval->t_inttwo,
+                                  &string, type);
+    if (string_len == (size_t)-1) {
+        nasm_nonfatal("invalid input string to %s", name);
+        return NULL;
+    }
+
+    val = readstrnum(string, string_len, &rn_warn);
+    if (parens) {
+        scan();
+        if (tt != ')') {
+            nasm_nonfatal("expecting `)'");
+            return NULL;
+        }
+    }
+
+    if (rn_warn)
+        nasm_warn(WARN_OTHER, "character constant too long");
+
+    begintemp();
+    addtotemp(EXPR_SIMPLE, val);
+
+    scan();
+    return finishtemp();
+}
+
+static int64_t eval_ifunc(int64_t val, enum ifunc func)
+{
+    uint64_t uval = (uint64_t)val;
+    int64_t rv;
+
+    switch (func) {
+    case IFUNC_ILOG2E:
+    case IFUNC_ILOG2W:
+        if (!is_power2(uval))
+            nasm_error((func == IFUNC_ILOG2E) ? ERR_NONFATAL : ERR_WARNING|WARN_OTHER,
+                       "ilog2 argument is not a power of two");
+        /* fall through */
+    case IFUNC_ILOG2F:
+        rv = ilog2_64(uval);
+        break;
+
+    case IFUNC_ILOG2C:
+        rv = (uval < 2) ? 0 : ilog2_64(uval-1) + 1;
+        break;
+
+    default:
+        nasm_panic("invalid IFUNC token %d", func);
+        rv = 0;
+        break;
+    }
+
+    return rv;
+}
+
+static expr *expr6(void)
+{
+    int32_t type;
+    expr *e;
+    int32_t label_seg;
+    int64_t label_ofs;
+    int64_t tmpval;
+    bool rn_warn;
+    const char *scope;
+
+    if (++deadman > nasm_limit[LIMIT_EVAL]) {
+        nasm_nonfatal("expression too long");
+        return NULL;
+    }
+
+    switch (tt) {
+    case '-':
+        scan();
+        e = expr6();
+        if (!e)
+            return NULL;
+        return scalar_mult(e, -1L, false);
+
+    case '+':
+        scan();
+        return expr6();
+
+    case '~':
+        scan();
+        e = expr6();
+        if (!e)
+            return NULL;
+        if (is_just_unknown(e))
+            return unknown_expr();
+        else if (!is_simple(e)) {
+            nasm_nonfatal("`~' operator may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        return scalarvect(~reloc_value(e));
+
+    case '!':
+        scan();
+        e = expr6();
+        if (!e)
+            return NULL;
+        if (is_just_unknown(e))
+            return unknown_expr();
+        else if (!is_simple(e)) {
+            nasm_nonfatal("`!' operator may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        return scalarvect(!reloc_value(e));
+
+    case TOKEN_IFUNC:
+    {
+        enum ifunc func = tokval->t_integer;
+        scan();
+        e = expr6();
+        if (!e)
+            return NULL;
+        if (is_just_unknown(e))
+            return unknown_expr();
+        else if (!is_simple(e)) {
+            nasm_nonfatal("function may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        return scalarvect(eval_ifunc(reloc_value(e), func));
+    }
+
+    case TOKEN_SEG:
+        scan();
+        e = expr6();
+        if (!e)
+            return NULL;
+        e = segment_part(e);
+        if (!e)
+            return NULL;
+        if (is_unknown(e) && critical) {
+            nasm_nonfatal("unable to determine segment base");
+            return NULL;
+        }
+        return e;
+
+    case TOKEN_FLOATIZE:
+        return eval_floatize(tokval->t_integer);
+
+    case TOKEN_STRFUNC:
+        return eval_strfunc(tokval->t_integer, tokval->t_charptr);
+
+    case '(':
+        scan();
+        e = bexpr();
+        if (!e)
+            return NULL;
+        if (tt != ')') {
+            nasm_nonfatal("expecting `)'");
+            return NULL;
+        }
+        scan();
+        return e;
+
+    case TOKEN_NUM:
+    case TOKEN_STR:
+    case TOKEN_REG:
+    case TOKEN_ID:
+    case TOKEN_INSN:            /* Opcodes that occur here are really labels */
+    case TOKEN_HERE:
+    case TOKEN_BASE:
+    case TOKEN_DECORATOR:
+        begintemp();
+        switch (tt) {
+        case TOKEN_NUM:
+            addtotemp(EXPR_SIMPLE, tokval->t_integer);
+            break;
+        case TOKEN_STR:
+            tmpval = readstrnum(tokval->t_charptr, tokval->t_inttwo, &rn_warn);
+            if (rn_warn)
+                nasm_warn(WARN_OTHER, "character constant too long");
+            addtotemp(EXPR_SIMPLE, tmpval);
+            break;
+        case TOKEN_REG:
+            addtotemp(tokval->t_integer, 1L);
+            if (hint && hint->type == EAH_NOHINT)
+                hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
+            break;
+        case TOKEN_ID:
+        case TOKEN_INSN:
+        case TOKEN_HERE:
+        case TOKEN_BASE:
+            /*
+             * If !location.known, this indicates that no
+             * symbol, Here or Base references are valid because we
+             * are in preprocess-only mode.
+             */
+            if (!location.known) {
+                nasm_nonfatal("%s not supported in preprocess-only mode",
+                              (tt == TOKEN_HERE ? "`$'" :
+                               tt == TOKEN_BASE ? "`$$'" :
+                               "symbol references"));
+                addtotemp(EXPR_UNKNOWN, 1L);
+                break;
+            }
+
+            type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
+            if (tt == TOKEN_BASE) {
+                label_seg = in_absolute ? absolute.segment : location.segment;
+                label_ofs = 0;
+            } else if (tt == TOKEN_HERE) {
+                label_seg = in_absolute ? absolute.segment : location.segment;
+                label_ofs = in_absolute ? absolute.offset : location.offset;
+            } else {
+                enum label_type ltype;
+                ltype = lookup_label(tokval->t_charptr, &label_seg, &label_ofs);
+                if (ltype == LBL_none) {
+                    scope = local_scope(tokval->t_charptr);
+                    if (critical) {
+                        nasm_nonfatal("symbol `%s%s' not defined%s",
+                                      scope,tokval->t_charptr,
+                                      pass_first() ? " before use" : "");
+                        return NULL;
+                    }
+                    if (opflags)
+                        *opflags |= OPFLAG_FORWARD;
+                    type = EXPR_UNKNOWN;
+                    label_seg = NO_SEG;
+                    label_ofs = 1;
+                } else if (is_extern(ltype)) {
+                    if (opflags)
+                        *opflags |= OPFLAG_EXTERN;
+                }
+            }
+            addtotemp(type, label_ofs);
+            if (label_seg != NO_SEG)
+                addtotemp(EXPR_SEGBASE + label_seg, 1L);
+            break;
+        case TOKEN_DECORATOR:
+            addtotemp(EXPR_RDSAE, tokval->t_integer);
+            break;
+        }
+        scan();
+        return finishtemp();
+
+    default:
+        nasm_nonfatal("expression syntax error");
+        return NULL;
+    }
+}
+
+expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
+               int *fwref, bool crit, struct eval_hints *hints)
+{
+    expr *e;
+    expr *f = NULL;
+
+    deadman = 0;
+
+    hint = hints;
+    if (hint)
+        hint->type = EAH_NOHINT;
+
+    critical = crit;
+    scanfunc = sc;
+    scpriv = scprivate;
+    tokval = tv;
+    opflags = fwref;
+
+    while (ntempexprs)          /* initialize temporary storage */
+        nasm_free(tempexprs[--ntempexprs]);
+
+    tt = tokval->t_type;
+    if (tt == TOKEN_INVALID)
+        scan();
+
+    e = bexpr();
+    if (!e)
+        return NULL;
+
+    if (tt == TOKEN_WRT) {
+        scan();                 /* eat the WRT */
+        f = expr6();
+        if (!f)
+            return NULL;
+    }
+    e = scalar_mult(e, 1L, false);      /* strip far-absolute segment part */
+    if (f) {
+        expr *g;
+        if (is_just_unknown(f))
+            g = unknown_expr();
+        else {
+            int64_t value;
+            begintemp();
+            if (!is_reloc(f)) {
+                nasm_nonfatal("invalid right-hand operand to WRT");
+                return NULL;
+            }
+            value = reloc_seg(f);
+            if (value == NO_SEG)
+                value = reloc_value(f) | SEG_ABS;
+            else if (!(value & SEG_ABS) && !(value % 2) && critical) {
+                nasm_nonfatal("invalid right-hand operand to WRT");
+                return NULL;
+            }
+            addtotemp(EXPR_WRT, value);
+            g = finishtemp();
+        }
+        e = add_vectors(e, g);
+    }
+    return e;
+}
diff --git a/vere/ext/nasm/asm/eval.h b/vere/ext/nasm/asm/eval.h
new file mode 100644
index 0000000..ba471a2
--- /dev/null
+++ b/vere/ext/nasm/asm/eval.h
@@ -0,0 +1,49 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * eval.h   header file for eval.c
+ */
+
+#ifndef NASM_EVAL_H
+#define NASM_EVAL_H
+
+/*
+ * The evaluator itself.
+ */
+expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
+               int *fwref, bool critical, struct eval_hints *hints);
+
+void eval_cleanup(void);
+
+#endif
diff --git a/vere/ext/nasm/asm/exprdump.c b/vere/ext/nasm/asm/exprdump.c
new file mode 100644
index 0000000..68a9b67
--- /dev/null
+++ b/vere/ext/nasm/asm/exprdump.c
@@ -0,0 +1,79 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * exprdump.c
+ *
+ * Debugging code to dump the contents of an expression vector to stdout
+ */
+
+#include "nasm.h"
+
+static const char *expr_type(int32_t type)
+{
+    static char seg_str[64];
+
+    switch (type) {
+    case 0:
+        return "null";
+    case EXPR_UNKNOWN:
+        return "unknown";
+    case EXPR_SIMPLE:
+        return "simple";
+    case EXPR_WRT:
+        return "wrt";
+    case EXPR_RDSAE:
+        return "sae";
+    default:
+        break;
+    }
+
+    if (type >= EXPR_REG_START && type <= EXPR_REG_END) {
+        return nasm_reg_names[type - EXPR_REG_START];
+    } else if (type >= EXPR_SEGBASE) {
+        snprintf(seg_str, sizeof seg_str, "%sseg %d",
+                 (type - EXPR_SEGBASE) == location.segment ? "this " : "",
+                 type - EXPR_SEGBASE);
+        return seg_str;
+    } else {
+        return "ERR";
+    }
+}
+
+void dump_expr(const expr *e)
+{
+    printf("[");
+    for (; e->type; e++)
+        printf("<%s(%d),%"PRId64">", expr_type(e->type), e->type, e->value);
+    printf("]\n");
+}
diff --git a/vere/ext/nasm/asm/exprlib.c b/vere/ext/nasm/asm/exprlib.c
new file mode 100644
index 0000000..f7cfbce
--- /dev/null
+++ b/vere/ext/nasm/asm/exprlib.c
@@ -0,0 +1,200 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * exprlib.c
+ *
+ * Library routines to manipulate expression data types.
+ */
+
+#include "nasm.h"
+
+/*
+ * Return true if the argument is a simple scalar. (Or a far-
+ * absolute, which counts.)
+ */
+bool is_simple(const expr *vect)
+{
+    while (vect->type && !vect->value)
+        vect++;
+    if (!vect->type)
+        return true;
+    if (vect->type != EXPR_SIMPLE)
+        return false;
+    do {
+        vect++;
+    } while (vect->type && !vect->value);
+    if (vect->type && vect->type < EXPR_SEGBASE + SEG_ABS)
+        return false;
+    return true;
+}
+
+/*
+ * Return true if the argument is a simple scalar, _NOT_ a far-
+ * absolute.
+ */
+bool is_really_simple(const expr *vect)
+{
+    while (vect->type && !vect->value)
+        vect++;
+    if (!vect->type)
+        return true;
+    if (vect->type != EXPR_SIMPLE)
+        return false;
+    do {
+        vect++;
+    } while (vect->type && !vect->value);
+    if (vect->type)
+        return false;
+    return true;
+}
+
+/*
+ * Return true if the argument is relocatable (i.e. a simple
+ * scalar, plus at most one segment-base, possibly a subtraction
+ * of the current segment base, plus possibly a WRT).
+ */
+bool is_reloc(const expr *vect)
+{
+    bool has_rel = false;       /* Has a self-segment-subtract */
+    bool has_seg = false;       /* Has a segment base */
+
+    for (; vect->type; vect++) {
+        if (!vect->value) {
+            /* skip value-0 terms */
+            continue;
+        } else if (vect->type < EXPR_SIMPLE) {
+            /* false if a register is present */
+            return false;
+        } else if (vect->type == EXPR_SIMPLE) {
+            /* skip over a pure number term... */
+            continue;
+        } else if (vect->type == EXPR_WRT) {
+            /* skip over a WRT term... */
+            continue;
+        } else if (vect->type < EXPR_SEGBASE) {
+            /* other special type -> problem */
+            return false;
+        } else if (vect->value == 1) {
+            if (has_seg)
+                return false;   /* only one segbase allowed */
+            has_seg = true;
+        } else if (vect->value == -1) {
+            if (vect->type != location.segment + EXPR_SEGBASE)
+                return false;   /* can only subtract current segment */
+            if (has_rel)
+                return false;   /* already is relative */
+            has_rel = true;
+        }
+    }
+
+    return true;
+}
+
+/*
+ * Return true if the argument contains an `unknown' part.
+ */
+bool is_unknown(const expr *vect)
+{
+    while (vect->type && vect->type < EXPR_UNKNOWN)
+        vect++;
+    return (vect->type == EXPR_UNKNOWN);
+}
+
+/*
+ * Return true if the argument contains nothing but an `unknown'
+ * part.
+ */
+bool is_just_unknown(const expr *vect)
+{
+    while (vect->type && !vect->value)
+        vect++;
+    return (vect->type == EXPR_UNKNOWN);
+}
+
+/*
+ * Return the scalar part of a relocatable vector. (Including
+ * simple scalar vectors - those qualify as relocatable.)
+ */
+int64_t reloc_value(const expr *vect)
+{
+    while (vect->type && !vect->value)
+        vect++;
+    if (!vect->type)
+        return 0;
+    if (vect->type == EXPR_SIMPLE)
+        return vect->value;
+    else
+        return 0;
+}
+
+/*
+ * Return the segment number of a relocatable vector, or NO_SEG for
+ * simple scalars.
+ */
+int32_t reloc_seg(const expr *vect)
+{
+    for (; vect->type; vect++) {
+        if (vect->type >= EXPR_SEGBASE && vect->value == 1)
+            return vect->type - EXPR_SEGBASE;
+    }
+
+    return NO_SEG;
+}
+
+/*
+ * Return the WRT segment number of a relocatable vector, or NO_SEG
+ * if no WRT part is present.
+ */
+int32_t reloc_wrt(const expr *vect)
+{
+    while (vect->type && vect->type < EXPR_WRT)
+        vect++;
+    if (vect->type == EXPR_WRT) {
+        return vect->value;
+    } else
+        return NO_SEG;
+}
+
+/*
+ * Return true if this expression contains a subtraction of the location
+ */
+bool is_self_relative(const expr *vect)
+{
+    for (; vect->type; vect++) {
+        if (vect->type == location.segment + EXPR_SEGBASE && vect->value == -1)
+            return true;
+    }
+
+    return false;
+}
diff --git a/vere/ext/nasm/asm/floats.c b/vere/ext/nasm/asm/floats.c
new file mode 100644
index 0000000..27180bd
--- /dev/null
+++ b/vere/ext/nasm/asm/floats.c
@@ -0,0 +1,960 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * float.c     floating-point constant support for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "floats.h"
+#include "error.h"
+
+/*
+ * -----------------
+ *  local variables
+ * -----------------
+ */
+static bool daz = false;        /* denormals as zero */
+static enum float_round rc = FLOAT_RC_NEAR;     /* rounding control */
+
+/*
+ * -----------
+ *  constants
+ * -----------
+ */
+
+/* "A limb is like a digit but bigger */
+typedef uint32_t fp_limb;
+typedef uint64_t fp_2limb;
+
+#define LIMB_BITS       32
+#define LIMB_BYTES      (LIMB_BITS/8)
+#define LIMB_TOP_BIT    ((fp_limb)1 << (LIMB_BITS-1))
+#define LIMB_MASK       ((fp_limb)(~0))
+#define LIMB_ALL_BYTES  ((fp_limb)0x01010101)
+#define LIMB_BYTE(x)    ((x)*LIMB_ALL_BYTES)
+
+/* 112 bits + 64 bits for accuracy + 16 bits for rounding */
+#define MANT_LIMBS 6
+
+/* 52 digits fit in 176 bits because 10^53 > 2^176 > 10^52 */
+#define MANT_DIGITS 52
+
+/* the format and the argument list depend on MANT_LIMBS */
+#define MANT_FMT "%08x_%08x_%08x_%08x_%08x_%08x"
+#define MANT_ARG SOME_ARG(mant, 0)
+
+#define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], \
+                      (a)[(i)+3], (a)[(i)+4], (a)[(i)+5]
+
+/*
+ * ---------------------------------------------------------------------------
+ *  emit a printf()-like debug message... but only if DEBUG_FLOAT was defined
+ * ---------------------------------------------------------------------------
+ */
+
+#ifdef DEBUG_FLOAT
+#define dprintf(x) printf x
+#else
+#define dprintf(x) do { } while (0)
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ *  multiply
+ * ---------------------------------------------------------------------------
+ */
+static int float_multiply(fp_limb *to, fp_limb *from)
+{
+    fp_2limb temp[MANT_LIMBS * 2];
+    int i, j;
+
+    /*
+     * guaranteed that top bit of 'from' is set -- so we only have
+     * to worry about _one_ bit shift to the left
+     */
+    dprintf(("%s=" MANT_FMT "\n", "mul1", SOME_ARG(to, 0)));
+    dprintf(("%s=" MANT_FMT "\n", "mul2", SOME_ARG(from, 0)));
+
+    memset(temp, 0, sizeof temp);
+
+    for (i = 0; i < MANT_LIMBS; i++) {
+        for (j = 0; j < MANT_LIMBS; j++) {
+            fp_2limb n;
+            n = (fp_2limb) to[i] * (fp_2limb) from[j];
+            temp[i + j] += n >> LIMB_BITS;
+            temp[i + j + 1] += (fp_limb)n;
+        }
+    }
+
+    for (i = MANT_LIMBS * 2; --i;) {
+        temp[i - 1] += temp[i] >> LIMB_BITS;
+        temp[i] &= LIMB_MASK;
+    }
+
+    dprintf(("%s=" MANT_FMT "_" MANT_FMT "\n", "temp", SOME_ARG(temp, 0),
+             SOME_ARG(temp, MANT_LIMBS)));
+
+    if (temp[0] & LIMB_TOP_BIT) {
+        for (i = 0; i < MANT_LIMBS; i++) {
+            to[i] = temp[i] & LIMB_MASK;
+        }
+        dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), 0));
+        return 0;
+    } else {
+        for (i = 0; i < MANT_LIMBS; i++) {
+            to[i] = (temp[i] << 1) + !!(temp[i + 1] & LIMB_TOP_BIT);
+        }
+        dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), -1));
+        return -1;
+    }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ *  read an exponent; returns INT32_MAX on error
+ * ---------------------------------------------------------------------------
+ */
+static int32_t read_exponent(const char *string, int32_t max)
+{
+    int32_t i = 0;
+    bool neg = false;
+
+    if (*string == '+') {
+        string++;
+    } else if (*string == '-') {
+        neg = true;
+        string++;
+    }
+    while (*string) {
+        if (*string >= '0' && *string <= '9') {
+            i = (i * 10) + (*string - '0');
+
+            /*
+             * To ensure that underflows and overflows are
+             * handled properly we must avoid wraparounds of
+             * the signed integer value that is used to hold
+             * the exponent. Therefore we cap the exponent at
+             * +/-5000, which is slightly more/less than
+             * what's required for normal and denormal numbers
+             * in single, double, and extended precision, but
+             * sufficient to avoid signed integer wraparound.
+             */
+            if (i > max)
+                i = max;
+        } else if (*string == '_') {
+            /* do nothing */
+        } else {
+            nasm_nonfatal("invalid character in floating-point constant %s: '%c'",
+                          "exponent", *string);
+            return INT32_MAX;
+        }
+        string++;
+    }
+
+    return neg ? -i : i;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ *  convert
+ * ---------------------------------------------------------------------------
+ */
+static bool ieee_flconvert(const char *string, fp_limb *mant,
+                           int32_t * exponent)
+{
+    char digits[MANT_DIGITS];
+    char *p, *q, *r;
+    fp_limb mult[MANT_LIMBS], bit;
+    fp_limb *m;
+    int32_t tenpwr, twopwr;
+    int32_t extratwos;
+    bool started, seendot, warned;
+
+    warned = false;
+    p = digits;
+    tenpwr = 0;
+    started = seendot = false;
+
+    while (*string && *string != 'E' && *string != 'e') {
+        if (*string == '.') {
+            if (!seendot) {
+                seendot = true;
+            } else {
+                nasm_nonfatal("too many periods in floating-point constant");
+                return false;
+            }
+        } else if (*string >= '0' && *string <= '9') {
+            if (*string == '0' && !started) {
+                if (seendot) {
+                    tenpwr--;
+                }
+            } else {
+                started = true;
+                if (p < digits + sizeof(digits)) {
+                    *p++ = *string - '0';
+                } else {
+                    if (!warned) {
+                        /*!
+                         *!float-toolong [on] too many digits in floating-point number
+                         *!  warns about too many digits in floating-point numbers.
+                         */
+                        nasm_warn(WARN_FLOAT_TOOLONG|ERR_PASS2,
+                                   "floating-point constant significand contains "
+                                   "more than %i digits", MANT_DIGITS);
+                        warned = true;
+                    }
+                }
+                if (!seendot) {
+                    tenpwr++;
+                }
+            }
+        } else if (*string == '_') {
+            /* do nothing */
+        } else {
+            nasm_nonfatalf(ERR_PASS2,
+                           "invalid character in floating-point constant %s: '%c'",
+                           "significand", *string);
+            return false;
+        }
+        string++;
+    }
+
+    if (*string) {
+        int32_t e;
+
+        string++;               /* eat the E */
+        e = read_exponent(string, 5000);
+        if (e == INT32_MAX)
+            return false;
+        tenpwr += e;
+    }
+
+    /*
+     * At this point, the memory interval [digits,p) contains a
+     * series of decimal digits zzzzzzz, such that our number X
+     * satisfies X = 0.zzzzzzz * 10^tenpwr.
+     */
+    q = digits;
+    dprintf(("X = 0."));
+    while (q < p) {
+        dprintf(("%c", *q + '0'));
+        q++;
+    }
+    dprintf((" * 10^%i\n", tenpwr));
+
+    /*
+     * Now convert [digits,p) to our internal representation.
+     */
+    bit = LIMB_TOP_BIT;
+    for (m = mant; m < mant + MANT_LIMBS; m++) {
+        *m = 0;
+    }
+    m = mant;
+    q = digits;
+    started = false;
+    twopwr = 0;
+    while (m < mant + MANT_LIMBS) {
+        fp_limb carry = 0;
+        while (p > q && !p[-1]) {
+            p--;
+        }
+        if (p <= q) {
+            break;
+        }
+        for (r = p; r-- > q;) {
+            int32_t i;
+            i = 2 * *r + carry;
+            if (i >= 10) {
+                carry = 1;
+                i -= 10;
+            } else {
+                carry = 0;
+            }
+            *r = i;
+        }
+        if (carry) {
+            *m |= bit;
+            started = true;
+        }
+        if (started) {
+            if (bit == 1) {
+                bit = LIMB_TOP_BIT;
+                m++;
+            } else {
+                bit >>= 1;
+            }
+        } else {
+            twopwr--;
+        }
+    }
+    twopwr += tenpwr;
+
+    /*
+     * At this point, the 'mant' array contains the first frac-
+     * tional places of a base-2^16 real number which when mul-
+     * tiplied by 2^twopwr and 5^tenpwr gives X.
+     */
+    dprintf(("X = " MANT_FMT " * 2^%i * 5^%i\n", MANT_ARG, twopwr,
+             tenpwr));
+
+    /*
+     * Now multiply 'mant' by 5^tenpwr.
+     */
+    if (tenpwr < 0) {           /* mult = 5^-1 = 0.2 */
+        for (m = mult; m < mult + MANT_LIMBS - 1; m++) {
+            *m = LIMB_BYTE(0xcc);
+        }
+        mult[MANT_LIMBS - 1] = LIMB_BYTE(0xcc)+1;
+        extratwos = -2;
+        tenpwr = -tenpwr;
+
+        /*
+         * If tenpwr was 1000...000b, then it becomes 1000...000b. See
+         * the "ANSI C" comment below for more details on that case.
+         *
+         * Because we already truncated tenpwr to +5000...-5000 inside
+         * the exponent parsing code, this shouldn't happen though.
+         */
+    } else if (tenpwr > 0) {    /* mult = 5^+1 = 5.0 */
+        mult[0] = (fp_limb)5 << (LIMB_BITS-3); /* 0xA000... */
+        for (m = mult + 1; m < mult + MANT_LIMBS; m++) {
+            *m = 0;
+        }
+        extratwos = 3;
+    } else {
+        extratwos = 0;
+    }
+    while (tenpwr) {
+        dprintf(("loop=" MANT_FMT " * 2^%i * 5^%i (%i)\n", MANT_ARG,
+                 twopwr, tenpwr, extratwos));
+        if (tenpwr & 1) {
+            dprintf(("mant*mult\n"));
+            twopwr += extratwos + float_multiply(mant, mult);
+        }
+        dprintf(("mult*mult\n"));
+        extratwos = extratwos * 2 + float_multiply(mult, mult);
+        tenpwr >>= 1;
+
+        /*
+         * In ANSI C, the result of right-shifting a signed integer is
+         * considered implementation-specific. To ensure that the loop
+         * terminates even if tenpwr was 1000...000b to begin with, we
+         * manually clear the MSB, in case a 1 was shifted in.
+         *
+         * Because we already truncated tenpwr to +5000...-5000 inside
+         * the exponent parsing code, this shouldn't matter; neverthe-
+         * less it is the right thing to do here.
+         */
+        tenpwr &= (uint32_t) - 1 >> 1;
+    }
+
+    /*
+     * At this point, the 'mant' array contains the first frac-
+     * tional places of a base-2^16 real number in [0.5,1) that
+     * when multiplied by 2^twopwr gives X. Or it contains zero
+     * of course. We are done.
+     */
+    *exponent = twopwr;
+    return true;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ *  operations of specific bits
+ * ---------------------------------------------------------------------------
+ */
+
+/* Set a bit, using *bigendian* bit numbering (0 = MSB) */
+static void set_bit(fp_limb *mant, int bit)
+{
+    mant[bit/LIMB_BITS] |= LIMB_TOP_BIT >> (bit & (LIMB_BITS-1));
+}
+
+/* Test a single bit */
+static int test_bit(const fp_limb *mant, int bit)
+{
+    return (mant[bit/LIMB_BITS] >> (~bit & (LIMB_BITS-1))) & 1;
+}
+
+/* Report if the mantissa value is all zero */
+static bool is_zero(const fp_limb *mant)
+{
+    int i;
+
+    for (i = 0; i < MANT_LIMBS; i++)
+        if (mant[i])
+            return false;
+
+    return true;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ *  round a mantissa off after i words
+ * ---------------------------------------------------------------------------
+ */
+
+#define ROUND_COLLECT_BITS                      \
+    do {                                        \
+        m = mant[i] & (2*bit-1);                \
+        for (j = i+1; j < MANT_LIMBS; j++)      \
+            m = m | mant[j];                    \
+    } while (0)
+
+#define ROUND_ABS_DOWN                          \
+    do {                                        \
+        mant[i] &= ~(bit-1);                    \
+        for (j = i+1; j < MANT_LIMBS; j++)      \
+            mant[j] = 0;                        \
+        return false;                           \
+    } while (0)
+
+#define ROUND_ABS_UP                            \
+    do {                                        \
+        mant[i] = (mant[i] & ~(bit-1)) + bit;   \
+        for (j = i+1; j < MANT_LIMBS; j++)      \
+            mant[j] = 0;                        \
+        while (i > 0 && !mant[i])               \
+            ++mant[--i];                        \
+        return !mant[0];                        \
+    } while (0)
+
+static bool ieee_round(bool minus, fp_limb *mant, int bits)
+{
+    fp_limb m = 0;
+    int32_t j;
+    int i = bits / LIMB_BITS;
+    int p = bits % LIMB_BITS;
+    fp_limb bit = LIMB_TOP_BIT >> p;
+
+    if (rc == FLOAT_RC_NEAR) {
+        if (mant[i] & bit) {
+            mant[i] &= ~bit;
+            ROUND_COLLECT_BITS;
+            mant[i] |= bit;
+            if (m) {
+                ROUND_ABS_UP;
+            } else {
+                if (test_bit(mant, bits-1)) {
+                    ROUND_ABS_UP;
+                } else {
+                    ROUND_ABS_DOWN;
+                }
+            }
+        } else {
+            ROUND_ABS_DOWN;
+        }
+    } else if (rc == FLOAT_RC_ZERO ||
+               rc == (minus ? FLOAT_RC_UP : FLOAT_RC_DOWN)) {
+        ROUND_ABS_DOWN;
+    } else {
+        /* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */
+        /* Round toward +/- infinity */
+        ROUND_COLLECT_BITS;
+        if (m) {
+            ROUND_ABS_UP;
+        } else {
+            ROUND_ABS_DOWN;
+        }
+    }
+    return false;
+}
+
+/* Returns a value >= 16 if not a valid hex digit */
+static unsigned int hexval(char c)
+{
+    unsigned int v = (unsigned char) c;
+
+    if (v >= '0' && v <= '9')
+        return v - '0';
+    else
+        return (v|0x20) - 'a' + 10;
+}
+
+/* Handle floating-point numbers with radix 2^bits and binary exponent */
+static bool ieee_flconvert_bin(const char *string, int bits,
+                               fp_limb *mant, int32_t *exponent)
+{
+    static const int log2tbl[16] =
+        { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
+    fp_limb mult[MANT_LIMBS + 1], *mp;
+    int ms;
+    int32_t twopwr;
+    bool seendot, seendigit;
+    unsigned char c;
+    const int radix = 1 << bits;
+    fp_limb v;
+
+    twopwr = 0;
+    seendot = seendigit = false;
+    ms = 0;
+    mp = NULL;
+
+    memset(mult, 0, sizeof mult);
+
+    while ((c = *string++) != '\0') {
+        if (c == '.') {
+            if (!seendot)
+                seendot = true;
+            else {
+                nasm_nonfatal("too many periods in floating-point constant");
+                return false;
+            }
+        } else if ((v = hexval(c)) < (unsigned int)radix) {
+            if (!seendigit && v) {
+                int l = log2tbl[v];
+
+                seendigit = true;
+                mp = mult;
+                ms = (LIMB_BITS-1)-l;
+
+                twopwr += l+1-bits;
+            }
+
+            if (seendigit) {
+                if (ms < 0) {
+                    /* Cast to fp_2limb as ms == -LIMB_BITS is possible. */
+                    *mp |= (fp_2limb)v >> -ms;
+                    mp++;
+                    if (mp > &mult[MANT_LIMBS])
+                        mp = &mult[MANT_LIMBS]; /* Guard slot */
+                    ms += LIMB_BITS;
+                }
+                *mp |= v << ms;
+                ms -= bits;
+
+                if (!seendot)
+                    twopwr += bits;
+            } else {
+                if (seendot)
+                    twopwr -= bits;
+            }
+        } else if (c == 'p' || c == 'P') {
+            int32_t e;
+            e = read_exponent(string, 20000);
+            if (e == INT32_MAX)
+                return false;
+            twopwr += e;
+            break;
+        } else if (c == '_') {
+            /* ignore */
+        } else {
+            nasm_nonfatal("floating-point constant: `%c' is invalid character", c);
+            return false;
+        }
+    }
+
+    if (!seendigit) {
+        memset(mant, 0, MANT_LIMBS*sizeof(fp_limb)); /* Zero */
+        *exponent = 0;
+    } else {
+        memcpy(mant, mult, MANT_LIMBS*sizeof(fp_limb));
+        *exponent = twopwr;
+    }
+
+    return true;
+}
+
+/*
+ * Shift a mantissa to the right by i bits.
+ */
+static void ieee_shr(fp_limb *mant, int i)
+{
+    fp_limb n, m;
+    int j = 0;
+    int sr, sl, offs;
+
+    sr = i % LIMB_BITS; sl = LIMB_BITS-sr;
+    offs = i/LIMB_BITS;
+
+    if (sr == 0) {
+        if (offs)
+            for (j = MANT_LIMBS-1; j >= offs; j--)
+                mant[j] = mant[j-offs];
+    } else if (MANT_LIMBS-1-offs < 0) {
+        j = MANT_LIMBS-1;
+    } else {
+        n = mant[MANT_LIMBS-1-offs] >> sr;
+        for (j = MANT_LIMBS-1; j > offs; j--) {
+            m = mant[j-offs-1];
+            mant[j] = (m << sl) | n;
+            n = m >> sr;
+        }
+        mant[j--] = n;
+    }
+    while (j >= 0)
+        mant[j--] = 0;
+}
+
+/* Produce standard IEEE formats, with implicit or explicit integer
+   bit; this makes the following assumptions:
+
+   - the sign bit is the MSB, followed by the exponent,
+     followed by the integer bit if present.
+   - the sign bit plus exponent fit in 16 bits.
+   - the exponent bias is 2^(n-1)-1 for an n-bit exponent */
+
+/*
+ * The 16- and 128-bit formats are expected to be in IEEE 754r.
+ * AMD SSE5 uses the 16-bit format.
+ *
+ * The 32- and 64-bit formats are the original IEEE 754 formats.
+ *
+ * The 80-bit format is x87-specific, but widely used.
+ *
+ * The 8-bit format appears to be the consensus 8-bit floating-point
+ * format.  It is apparently used in graphics applications.
+ *
+ * The b16 format is a 16-bit format with smaller mantissa and larger
+ * exponent field.  It is effectively a truncated version of the standard
+ * IEEE 32-bit (single) format, but is explicitly supported here in
+ * order to support proper rounding.
+ *
+ * This array must correspond to enum floatize in include/nasm.h.
+ * Note that there are some formats which have more than one enum;
+ * both need to be listed here with the appropriate offset into the
+ * floating-point byte array (use for the floatize operators.)
+ *
+ * FLOAT_ERR is a value that both represents "invalid format" and the
+ * size of this array.
+ */
+const struct ieee_format fp_formats[FLOAT_ERR] = {
+    {  1,   3, 0,  4, 0 },         /* FLOAT_8 */
+    {  2,  10, 0,  5, 0 },         /* FLOAT_16 */
+    {  2,   7, 0,  8, 0 },         /* FLOAT_B16 */
+    {  4,  23, 0,  8, 0 },         /* FLOAT_32 */
+    {  8,  52, 0, 11, 0 },         /* FLOAT_64 */
+    { 10,  63, 1, 15, 0 },         /* FLOAT_80M */
+    { 10,  63, 1, 15, 8 },         /* FLOAT_80E */
+    { 16, 112, 0, 15, 0 },         /* FLOAT_128L */
+    { 16, 112, 0, 15, 8 }          /* FLOAT_128H */
+};
+
+/* Types of values we can generate */
+enum floats {
+    FL_ZERO,
+    FL_DENORMAL,
+    FL_NORMAL,
+    FL_INFINITY,
+    FL_QNAN,
+    FL_SNAN
+};
+
+static int to_packed_bcd(const char *str, const char *p,
+                         int s, uint8_t *result,
+                         const struct ieee_format *fmt)
+{
+    int n = 0;
+    char c;
+    int tv = -1;
+
+    if (fmt->bytes != 10) {
+        nasm_nonfatal("packed BCD requires an 80-bit format");
+        return 0;
+    }
+
+    while (p >= str) {
+        c = *p--;
+        if (c >= '0' && c <= '9') {
+            if (tv < 0) {
+                if (n == 9)
+                    nasm_warn(WARN_OTHER|ERR_PASS2, "packed BCD truncated to 18 digits");
+                tv = c-'0';
+            } else {
+                if (n < 9)
+                    *result++ = tv + ((c-'0') << 4);
+                n++;
+                tv = -1;
+            }
+        } else if (c == '_') {
+            /* do nothing */
+        } else {
+            nasm_nonfatal("invalid character `%c' in packed BCD constant", c);
+            return 0;
+        }
+    }
+    if (tv >= 0) {
+        if (n < 9)
+            *result++ = tv;
+        n++;
+    }
+    while (n < 9) {
+        *result++ = 0;
+        n++;
+    }
+    *result = (s < 0) ? 0x80 : 0;
+
+    return 1;                   /* success */
+}
+
+int float_const(const char *str, int s, uint8_t *result, enum floatize ffmt)
+{
+    const struct ieee_format *fmt = &fp_formats[ffmt];
+    fp_limb mant[MANT_LIMBS];
+    int32_t exponent = 0;
+    const int32_t expmax = 1 << (fmt->exponent - 1);
+    fp_limb one_mask = LIMB_TOP_BIT >>
+        ((fmt->exponent+fmt->explicit) % LIMB_BITS);
+    const int one_pos = (fmt->exponent+fmt->explicit)/LIMB_BITS;
+    int i;
+    int shift;
+    enum floats type;
+    bool ok;
+    const bool minus = s < 0;
+    const int bits = fmt->bytes * 8;
+    const char *strend;
+
+    nasm_assert(str[0]);
+
+    strend = strchr(str, '\0');
+    if (strend[-1] == 'P' || strend[-1] == 'p')
+        return to_packed_bcd(str, strend-2, s, result, fmt);
+
+    if (str[0] == '_') {
+        /* Special tokens */
+
+        switch (str[3]) {
+        case 'n':              /* __?nan?__ */
+        case 'N':
+        case 'q':              /* __?qnan?__ */
+        case 'Q':
+            type = FL_QNAN;
+            break;
+        case 's':              /* __?snan?__ */
+        case 'S':
+            type = FL_SNAN;
+            break;
+        case 'i':              /* __?infinity?__ */
+        case 'I':
+            type = FL_INFINITY;
+            break;
+        default:
+            nasm_nonfatal("internal error: unknown FP constant token `%s'", str);
+            type = FL_QNAN;
+            break;
+        }
+    } else {
+        if (str[0] == '0') {
+            switch (str[1]) {
+            case 'x': case 'X':
+            case 'h': case 'H':
+                ok = ieee_flconvert_bin(str+2, 4, mant, &exponent);
+                break;
+            case 'o': case 'O':
+            case 'q': case 'Q':
+                ok = ieee_flconvert_bin(str+2, 3, mant, &exponent);
+                break;
+            case 'b': case 'B':
+            case 'y': case 'Y':
+                ok = ieee_flconvert_bin(str+2, 1, mant, &exponent);
+                break;
+            case 'd': case 'D':
+            case 't': case 'T':
+                ok = ieee_flconvert(str+2, mant, &exponent);
+                break;
+            case 'p': case 'P':
+                return to_packed_bcd(str+2, strend-1, s, result, fmt);
+            default:
+                /* Leading zero was just a zero? */
+                ok = ieee_flconvert(str, mant, &exponent);
+                break;
+            }
+        } else if (str[0] == '$') {
+            ok = ieee_flconvert_bin(str+1, 4, mant, &exponent);
+        } else {
+            ok = ieee_flconvert(str, mant, &exponent);
+        }
+
+        if (!ok) {
+            type = FL_QNAN;
+        } else if (mant[0] & LIMB_TOP_BIT) {
+            /*
+             * Non-zero.
+             */
+            exponent--;
+            if (exponent >= 2 - expmax && exponent <= expmax) {
+                type = FL_NORMAL;
+            } else if (exponent > 0) {
+                nasm_warn(WARN_FLOAT_OVERFLOW|ERR_PASS2,
+                           "overflow in floating-point constant");
+                type = FL_INFINITY;
+            } else {
+                /* underflow or denormal; the denormal code handles
+                   actual underflow. */
+                type = FL_DENORMAL;
+            }
+        } else {
+            /* Zero */
+            type = FL_ZERO;
+        }
+    }
+
+    switch (type) {
+    case FL_ZERO:
+    zero:
+        memset(mant, 0, sizeof mant);
+        break;
+
+    case FL_DENORMAL:
+    {
+        shift = -(exponent + expmax - 2 - fmt->exponent)
+            + fmt->explicit;
+        ieee_shr(mant, shift);
+        ieee_round(minus, mant, bits);
+        if (mant[one_pos] & one_mask) {
+            /* One's position is set, we rounded up into normal range */
+            exponent = 1;
+            if (!fmt->explicit)
+                mant[one_pos] &= ~one_mask;     /* remove explicit one */
+            mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
+        } else {
+            if (daz || is_zero(mant)) {
+                /*!
+                 *!float-underflow [off] floating point underflow
+                 *!  warns about floating point underflow (a nonzero
+                 *!  constant rounded to zero.)
+                 */
+                nasm_warn(WARN_FLOAT_UNDERFLOW|ERR_PASS2,
+                           "underflow in floating-point constant");
+                goto zero;
+            } else {
+                /*!
+                 *!float-denorm [off] floating point denormal
+                 *!  warns about denormal floating point constants.
+                 */
+                nasm_warn(WARN_FLOAT_DENORM|ERR_PASS2,
+                           "denormal floating-point constant");
+            }
+        }
+        break;
+    }
+
+    case FL_NORMAL:
+        exponent += expmax - 1;
+        ieee_shr(mant, fmt->exponent+fmt->explicit);
+        ieee_round(minus, mant, bits);
+        /* did we scale up by one? */
+        if (test_bit(mant, fmt->exponent+fmt->explicit-1)) {
+            ieee_shr(mant, 1);
+            exponent++;
+            if (exponent >= (expmax << 1)-1) {
+                /*!
+                 *!float-overflow [on] floating point overflow
+                 *!  warns about floating point underflow.
+                 */
+                nasm_warn(WARN_FLOAT_OVERFLOW|ERR_PASS2,
+                           "overflow in floating-point constant");
+                type = FL_INFINITY;
+                goto overflow;
+            }
+        }
+
+        if (!fmt->explicit)
+            mant[one_pos] &= ~one_mask; /* remove explicit one */
+        mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
+        break;
+
+    case FL_INFINITY:
+    case FL_QNAN:
+    case FL_SNAN:
+    overflow:
+        memset(mant, 0, sizeof mant);
+        mant[0] = (((fp_limb)1 << fmt->exponent)-1)
+            << (LIMB_BITS-1 - fmt->exponent);
+        if (fmt->explicit)
+            mant[one_pos] |= one_mask;
+        if (type == FL_QNAN)
+            set_bit(mant, fmt->exponent+fmt->explicit+1);
+        else if (type == FL_SNAN)
+            set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa);
+        break;
+    }
+
+    mant[0] |= minus ? LIMB_TOP_BIT : 0;
+
+    for (i = fmt->bytes - 1; i >= 0; i--)
+        *result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8);
+
+    return 1;                   /* success */
+}
+
+/*
+ * Get the default floating point format for this specific field size.
+ * Used for the Dx pseudoops.
+ */
+enum floatize float_deffmt(int bytes)
+{
+    enum floatize type;
+
+    for (type = 0; type < FLOAT_ERR; type++) {
+        if (fp_formats[type].bytes == bytes)
+            break;
+    }
+
+    return type;                /* FLOAT_ERR if invalid */
+}
+
+/* Set floating-point options */
+int float_option(const char *option)
+{
+    if (!nasm_stricmp(option, "daz")) {
+        daz = true;
+        return 0;
+    } else if (!nasm_stricmp(option, "nodaz")) {
+        daz = false;
+        return 0;
+    } else if (!nasm_stricmp(option, "near")) {
+        rc = FLOAT_RC_NEAR;
+        return 0;
+    } else if (!nasm_stricmp(option, "down")) {
+        rc = FLOAT_RC_DOWN;
+        return 0;
+    } else if (!nasm_stricmp(option, "up")) {
+        rc = FLOAT_RC_UP;
+        return 0;
+    } else if (!nasm_stricmp(option, "zero")) {
+        rc = FLOAT_RC_ZERO;
+        return 0;
+    } else if (!nasm_stricmp(option, "default")) {
+        rc = FLOAT_RC_NEAR;
+        daz = false;
+        return 0;
+    } else {
+        return -1;              /* Unknown option */
+    }
+}
diff --git a/vere/ext/nasm/asm/floats.h b/vere/ext/nasm/asm/floats.h
new file mode 100644
index 0000000..c463513
--- /dev/null
+++ b/vere/ext/nasm/asm/floats.h
@@ -0,0 +1,67 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * floats.h   header file for the floating-point constant module of
+ *	      the Netwide Assembler
+ */
+
+#ifndef NASM_FLOATS_H
+#define NASM_FLOATS_H
+
+#include "nasm.h"
+
+enum float_round {
+    FLOAT_RC_NEAR,
+    FLOAT_RC_ZERO,
+    FLOAT_RC_DOWN,
+    FLOAT_RC_UP
+};
+
+/* Note: enum floatize and FLOAT_ERR are defined in nasm.h */
+
+/* Floating-point format description */
+struct ieee_format {
+    int bytes;                  /* Total bytes */
+    int mantissa;               /* Fractional bits in the mantissa */
+    int explicit;               /* Explicit integer */
+    int exponent;               /* Bits in the exponent */
+    int offset;                 /* Offset into byte array for floatize op */
+};
+extern const struct ieee_format fp_formats[FLOAT_ERR];
+
+int float_const(const char *str, int s, uint8_t *result, enum floatize ffmt);
+enum floatize float_deffmt(int bytes);
+int float_option(const char *option);
+
+#endif /* NASM_FLOATS_H */
diff --git a/vere/ext/nasm/asm/labels.c b/vere/ext/nasm/asm/labels.c
new file mode 100644
index 0000000..f6b940f
--- /dev/null
+++ b/vere/ext/nasm/asm/labels.c
@@ -0,0 +1,720 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * labels.c  label handling for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "hashtbl.h"
+#include "labels.h"
+
+/*
+ * A dot-local label is one that begins with exactly one period. Things
+ * that begin with _two_ periods are NASM-specific things.
+ *
+ * If TASM compatibility is enabled, a local label can also begin with
+ * @@.
+ */
+static bool islocal(const char *l)
+{
+    if (tasm_compatible_mode) {
+        if (l[0] == '@' && l[1] == '@')
+            return true;
+    }
+
+    return (l[0] == '.' && l[1] != '.');
+}
+
+/*
+ * Return true if this falls into NASM's '..' namespace
+ */
+static bool ismagic(const char *l)
+{
+    return l[0] == '.' && l[1] == '.' && l[2] != '@';
+}
+
+/*
+ * Return true if we should update the local label base
+ * as a result of this symbol.  We must exclude local labels
+ * as well as any kind of special labels, including ..@ ones.
+ */
+static bool set_prevlabel(const char *l)
+{
+    if (tasm_compatible_mode) {
+        if (l[0] == '@' && l[1] == '@')
+            return false;
+    }
+
+    return l[0] != '.';
+}
+
+#define LABEL_BLOCK     128     /* no. of labels/block */
+#define LBLK_SIZE       (LABEL_BLOCK * sizeof(union label))
+
+#define END_LIST        -3      /* don't clash with NO_SEG! */
+#define END_BLOCK       -2
+
+#define PERMTS_SIZE     16384   /* size of text blocks */
+#if (PERMTS_SIZE < IDLEN_MAX)
+ #error "IPERMTS_SIZE must be greater than or equal to IDLEN_MAX"
+#endif
+
+/* string values for enum label_type */
+static const char * const types[] = {
+    "local", "static", "global", "extern", "required", "common",
+    "special", "output format special"
+};
+
+union label {                   /* actual label structures */
+    struct {
+        int32_t segment;
+        int32_t subsection;     /* Available for ofmt->herelabel() */
+        int64_t offset;
+        int64_t size;
+        int64_t defined;        /* 0 if undefined, passn+1 for when defn seen */
+        int64_t lastref;        /* Last pass where we saw a reference */
+        char *label, *mangled, *special;
+        const char *def_file;   /* Where defined */
+        int32_t def_line;
+        enum label_type type, mangled_type;
+    } defn;
+    struct {
+        int32_t movingon;
+        int64_t dummy;
+        union label *next;
+    } admin;
+};
+
+struct permts {                 /* permanent text storage */
+    struct permts *next;        /* for the linked list */
+    unsigned int size, usage;   /* size and used space in ... */
+    char data[PERMTS_SIZE];     /* ... the data block itself */
+};
+#define PERMTS_HEADER offsetof(struct permts, data)
+
+uint64_t global_offset_changed;		/* counter for global offset changes */
+
+static struct hash_table ltab;          /* labels hash table */
+static union label *ldata;              /* all label data blocks */
+static union label *lfree;              /* labels free block */
+static struct permts *perm_head;        /* start of perm. text storage */
+static struct permts *perm_tail;        /* end of perm. text storage */
+
+static void init_block(union label *blk);
+static char *perm_alloc(size_t len);
+static char *perm_copy(const char *string);
+static char *perm_copy3(const char *s1, const char *s2, const char *s3);
+static const char *mangle_label_name(union label *lptr);
+
+static const char *prevlabel;
+
+static bool initialized = false;
+
+/*
+ * Emit a symdef to the output and the debug format backends.
+ */
+static void out_symdef(union label *lptr)
+{
+    int backend_type;
+    int64_t backend_offset;
+
+    /* Backend-defined special segments are passed to symdef immediately */
+    if (pass_final()) {
+        /* Emit special fixups for globals and commons */
+        switch (lptr->defn.type) {
+        case LBL_GLOBAL:
+        case LBL_REQUIRED:
+        case LBL_COMMON:
+            if (lptr->defn.special)
+                ofmt->symdef(lptr->defn.mangled, 0, 0, 3, lptr->defn.special);
+            break;
+        default:
+            break;
+        }
+        return;
+    }
+
+    if (pass_type() != PASS_STAB && lptr->defn.type != LBL_BACKEND)
+        return;
+
+    /* Clean up this hack... */
+    switch(lptr->defn.type) {
+    case LBL_EXTERN:
+        /* If not seen in the previous or this pass, drop it */
+        if (lptr->defn.lastref < pass_count())
+            return;
+
+        /* Otherwise, promote to LBL_REQUIRED at this time */
+        lptr->defn.type = LBL_REQUIRED;
+
+        /* fall through */
+    case LBL_GLOBAL:
+    case LBL_REQUIRED:
+        backend_type = 1;
+        backend_offset = lptr->defn.offset;
+        break;
+    case LBL_COMMON:
+        backend_type = 2;
+        backend_offset = lptr->defn.size;
+        break;
+    default:
+        backend_type = 0;
+        backend_offset = lptr->defn.offset;
+        break;
+    }
+
+    /* Might be necessary for a backend symbol */
+    mangle_label_name(lptr);
+
+    ofmt->symdef(lptr->defn.mangled, lptr->defn.segment,
+                 backend_offset, backend_type,
+                 lptr->defn.special);
+
+    /*
+     * NASM special symbols are not passed to the debug format; none
+     * of the current backends want to see them.
+     */
+    if (lptr->defn.type == LBL_SPECIAL || lptr->defn.type == LBL_BACKEND)
+        return;
+
+    dfmt->debug_deflabel(lptr->defn.mangled, lptr->defn.segment,
+                         lptr->defn.offset, backend_type,
+                         lptr->defn.special);
+}
+
+/*
+ * Internal routine: finds the `union label' corresponding to the
+ * given label name. Creates a new one, if it isn't found, and if
+ * `create' is true.
+ */
+static union label *find_label(const char *label, bool create, bool *created)
+{
+    union label *lptr, **lpp;
+    char *label_str = NULL;
+    struct hash_insert ip;
+
+    nasm_assert(label != NULL);
+
+    if (islocal(label))
+        label = label_str = nasm_strcat(prevlabel, label);
+
+    lpp = (union label **) hash_find(&ltab, label, &ip);
+    lptr = lpp ? *lpp : NULL;
+
+    if (lptr || !create) {
+        if (created)
+            *created = false;
+        return lptr;
+    }
+
+    /* Create a new label... */
+    if (lfree->admin.movingon == END_BLOCK) {
+        /*
+         * must allocate a new block
+         */
+        lfree->admin.next = nasm_malloc(LBLK_SIZE);
+        lfree = lfree->admin.next;
+        init_block(lfree);
+    }
+
+    if (created)
+        *created = true;
+
+    nasm_zero(*lfree);
+    lfree->defn.label     = perm_copy(label);
+    lfree->defn.subsection = NO_SEG;
+    if (label_str)
+        nasm_free(label_str);
+
+    hash_add(&ip, lfree->defn.label, lfree);
+    return lfree++;
+}
+
+enum label_type lookup_label(const char *label,
+                             int32_t *segment, int64_t *offset)
+{
+    union label *lptr;
+
+    if (!initialized)
+        return LBL_none;
+
+    lptr = find_label(label, false, NULL);
+    if (lptr && lptr->defn.defined) {
+        int64_t lpass = pass_count() + 1;
+
+        lptr->defn.lastref = lpass;
+        *segment = lptr->defn.segment;
+        *offset = lptr->defn.offset;
+        return lptr->defn.type;
+    }
+
+    return LBL_none;
+}
+
+static inline bool is_global(enum label_type type)
+{
+    return type == LBL_GLOBAL || type == LBL_COMMON;
+}
+
+static const char *mangle_strings[] = {"", "", "", ""};
+static bool mangle_string_set[ARRAY_SIZE(mangle_strings)];
+
+/*
+ * Set a prefix or suffix
+ */
+void set_label_mangle(enum mangle_index which, const char *what)
+{
+    if (mangle_string_set[which])
+        return;                 /* Once set, do not change */
+
+    mangle_strings[which] = perm_copy(what);
+    mangle_string_set[which] = true;
+}
+
+/*
+ * Format a label name with appropriate prefixes and suffixes
+ */
+static const char *mangle_label_name(union label *lptr)
+{
+    const char *prefix;
+    const char *suffix;
+
+    if (likely(lptr->defn.mangled &&
+               lptr->defn.mangled_type == lptr->defn.type))
+        return lptr->defn.mangled; /* Already mangled */
+
+    switch (lptr->defn.type) {
+    case LBL_GLOBAL:
+    case LBL_STATIC:
+    case LBL_EXTERN:
+    case LBL_REQUIRED:
+        prefix = mangle_strings[LM_GPREFIX];
+        suffix = mangle_strings[LM_GSUFFIX];
+        break;
+    case LBL_BACKEND:
+    case LBL_SPECIAL:
+        prefix = suffix = "";
+        break;
+    default:
+        prefix = mangle_strings[LM_LPREFIX];
+        suffix = mangle_strings[LM_LSUFFIX];
+        break;
+    }
+
+    lptr->defn.mangled_type = lptr->defn.type;
+
+    if (!(*prefix) && !(*suffix))
+        lptr->defn.mangled = lptr->defn.label;
+    else
+        lptr->defn.mangled = perm_copy3(prefix, lptr->defn.label, suffix);
+
+    return lptr->defn.mangled;
+}
+
+static void
+handle_herelabel(union label *lptr, int32_t *segment, int64_t *offset)
+{
+    int32_t oldseg;
+
+    if (likely(!ofmt->herelabel))
+        return;
+
+    if (unlikely(location.segment == NO_SEG))
+        return;
+
+    oldseg = *segment;
+
+    if (oldseg == location.segment && *offset == location.offset) {
+        /* This label is defined at this location */
+        int32_t newseg;
+        bool copyoffset = false;
+
+        nasm_assert(lptr->defn.mangled);
+        newseg = ofmt->herelabel(lptr->defn.mangled, lptr->defn.type,
+                                 oldseg, &lptr->defn.subsection, &copyoffset);
+        if (likely(newseg == oldseg))
+            return;
+
+        *segment = newseg;
+        if (copyoffset) {
+            /* Maintain the offset from the old to the new segment */
+            switch_segment(newseg);
+            location.offset = *offset;
+        } else {
+            /* Keep a separate offset for the new segment */
+            *offset = switch_segment(newseg);
+        }
+    }
+}
+
+static bool declare_label_lptr(union label *lptr,
+                               enum label_type type, const char *special)
+{
+    enum label_type oldtype = lptr->defn.type;
+
+    if (special && !special[0])
+        special = NULL;
+
+    if (oldtype == type || (!pass_stable() && oldtype == LBL_LOCAL) ||
+        (oldtype == LBL_EXTERN && type == LBL_REQUIRED)) {
+        lptr->defn.type = type;
+
+        if (special) {
+            if (!lptr->defn.special)
+                lptr->defn.special = perm_copy(special);
+            else if (nasm_stricmp(lptr->defn.special, special))
+                nasm_nonfatal("symbol `%s' has inconsistent attributes `%s' and `%s'",
+                              lptr->defn.label, lptr->defn.special, special);
+        }
+        return true;
+    } else if (is_extern(oldtype) && is_global(type)) {
+        /* EXTERN or REQUIRED can be replaced with GLOBAL or COMMON */
+        lptr->defn.type = type;
+
+        /* Override special unconditionally */
+        if (special)
+            lptr->defn.special = perm_copy(special);
+        return true;
+    } else if (is_extern(type) && (is_global(oldtype) || is_extern(oldtype))) {
+        /*
+         * GLOBAL or COMMON ignore subsequent EXTERN or REQUIRED;
+         * REQUIRED ignores subsequent EXTERN.
+         */
+
+        /* Ignore special unless we don't already have one */
+        if (!lptr->defn.special)
+            lptr->defn.special = perm_copy(special);
+
+        return false; /* Don't call define_label() after this! */
+    }
+
+    nasm_nonfatal("symbol `%s' declared both as %s and %s",
+                  lptr->defn.label, types[lptr->defn.type], types[type]);
+    return false;
+}
+
+bool declare_label(const char *label, enum label_type type, const char *special)
+{
+    union label *lptr = find_label(label, true, NULL);
+    return declare_label_lptr(lptr, type, special);
+}
+
+/*
+ * The "normal" argument decides if we should update the local segment
+ * base name or not.
+ */
+void define_label(const char *label, int32_t segment,
+                  int64_t offset, bool normal)
+{
+    union label *lptr;
+    bool created, changed;
+    int64_t size;
+    int64_t lpass, lastdef;
+
+    /*
+     * The backend may invoke this during initialization, at which
+     * pass_count() is zero, so add one so we never have a zero value
+     * for a defined variable.
+     */
+    lpass = pass_count() + 1;
+
+    /*
+     * Phase errors here can be one of two types: a new label appears,
+     * or the offset changes. Increment global_offset_changed when that
+     * happens, to tell the assembler core to make another pass.
+     */
+    lptr = find_label(label, true, &created);
+
+    lastdef = lptr->defn.defined;
+
+    if (segment) {
+        /* We are actually defining this label */
+        if (is_extern(lptr->defn.type)) {
+            /* auto-promote EXTERN/REQUIRED to GLOBAL */
+            lptr->defn.type = LBL_GLOBAL;
+            lastdef = 0; /* We are "re-creating" this label */
+        }
+    } else {
+        /* It's a pseudo-segment (extern, required, common) */
+        segment = lptr->defn.segment ? lptr->defn.segment : seg_alloc();
+    }
+
+    if (lastdef || lptr->defn.type == LBL_BACKEND) {
+        /*
+         * We have seen this on at least one previous pass, or
+         * potentially earlier in this same pass (in which case we
+         * will probably error out further down.)
+         */
+        mangle_label_name(lptr);
+        handle_herelabel(lptr, &segment, &offset);
+    }
+
+    if (ismagic(label) && lptr->defn.type == LBL_LOCAL)
+        lptr->defn.type = LBL_SPECIAL;
+
+    if (set_prevlabel(label) && normal)
+        prevlabel = lptr->defn.label;
+
+    if (lptr->defn.type == LBL_COMMON) {
+        size = offset;
+        offset = 0;
+    } else {
+        size = 0;               /* This is a hack... */
+    }
+
+    changed = created || !lastdef ||
+        lptr->defn.segment != segment ||
+        lptr->defn.offset != offset ||
+        lptr->defn.size != size;
+    global_offset_changed += changed;
+
+    if (lastdef == lpass) {
+        int32_t saved_line = 0;
+        const char *saved_fname = NULL;
+        int noteflags;
+
+        /*
+         * Defined elsewhere in the program, seen in this pass.
+         */
+        if (changed) {
+            nasm_nonfatal("label `%s' inconsistently redefined", lptr->defn.label);
+            noteflags = ERR_NONFATAL|ERR_HERE|ERR_NO_SEVERITY;
+        } else {
+            /*!
+             *!label-redef [off] label redefined to an identical value
+             *!  warns if a label is defined more than once, but the
+             *!  value is identical. It is an unconditional error to
+             *!  define the same label more than once to \e{different} values.
+             */
+            nasm_warn(WARN_LABEL_REDEF,
+                       "info: label `%s' redefined to an identical value", lptr->defn.label);
+            noteflags = ERR_WARNING|ERR_HERE|ERR_NO_SEVERITY|WARN_LABEL_REDEF;
+        }
+
+        src_get(&saved_line, &saved_fname);
+        src_set(lptr->defn.def_line, lptr->defn.def_file);
+        nasm_error(noteflags, "info: label `%s' originally defined", lptr->defn.label);
+        src_set(saved_line, saved_fname);
+    } else if (changed && pass_final() && lptr->defn.type != LBL_SPECIAL) {
+        /*!
+         *!label-redef-late [err] label (re)defined during code generation
+         *!  the value of a label changed during the final, code-generation
+         *!  pass. This may be the result of strange use of the
+         *!  preprocessor. This is very likely to produce incorrect code and
+         *!  may end up being an unconditional error in a future
+         *!  version of NASM.
+         *
+         * WARN_LABEL_LATE defaults to an error, as this should never
+         * actually happen.  Just in case this is a backwards
+         * compatibility problem, still make it a warning so that the
+         * user can suppress or demote it.
+         *
+         * Note: As a special case, LBL_SPECIAL symbols are allowed
+         * to be changed even during the last pass.
+         */
+        nasm_warn(WARN_LABEL_REDEF_LATE|ERR_UNDEAD,
+                   "label `%s' %s during code generation",
+                   lptr->defn.label, created ? "defined" : "changed");
+    }
+    lptr->defn.segment = segment;
+    lptr->defn.offset  = offset;
+    lptr->defn.size    = size;
+    lptr->defn.defined = lpass;
+
+    if (changed || lastdef != lpass)
+        src_get(&lptr->defn.def_line, &lptr->defn.def_file);
+
+    if (lastdef != lpass)
+        out_symdef(lptr);
+}
+
+/*
+ * Define a special backend label
+ */
+void backend_label(const char *label, int32_t segment, int64_t offset)
+{
+    if (!declare_label(label, LBL_BACKEND, NULL))
+        return;
+
+    define_label(label, segment, offset, false);
+}
+
+int init_labels(void)
+{
+    ldata = lfree = nasm_malloc(LBLK_SIZE);
+    init_block(lfree);
+
+    perm_head = perm_tail =
+        nasm_malloc(sizeof(struct permts));
+
+    perm_head->next = NULL;
+    perm_head->size = PERMTS_SIZE;
+    perm_head->usage = 0;
+
+    prevlabel = "";
+
+    initialized = true;
+
+    return 0;
+}
+
+void cleanup_labels(void)
+{
+    union label *lptr, *lhold;
+
+    initialized = false;
+
+    hash_free(&ltab);
+
+    lptr = lhold = ldata;
+    while (lptr) {
+        lptr = &lptr[LABEL_BLOCK-1];
+        lptr = lptr->admin.next;
+        nasm_free(lhold);
+        lhold = lptr;
+    }
+
+    while (perm_head) {
+        perm_tail = perm_head;
+        perm_head = perm_head->next;
+        nasm_free(perm_tail);
+    }
+}
+
+static void init_block(union label *blk)
+{
+    int j;
+
+    for (j = 0; j < LABEL_BLOCK - 1; j++)
+        blk[j].admin.movingon = END_LIST;
+    blk[LABEL_BLOCK - 1].admin.movingon = END_BLOCK;
+    blk[LABEL_BLOCK - 1].admin.next = NULL;
+}
+
+static char * safe_alloc perm_alloc(size_t len)
+{
+    char *p;
+
+    if (perm_tail->size - perm_tail->usage < len) {
+        size_t alloc_len = (len > PERMTS_SIZE) ? len : PERMTS_SIZE;
+        perm_tail->next = nasm_malloc(PERMTS_HEADER + alloc_len);
+        perm_tail = perm_tail->next;
+        perm_tail->next = NULL;
+        perm_tail->size = alloc_len;
+        perm_tail->usage = 0;
+    }
+    p = perm_tail->data + perm_tail->usage;
+    perm_tail->usage += len;
+    return p;
+}
+
+static char *perm_copy(const char *string)
+{
+    char *p;
+    size_t len;
+
+    if (!string)
+        return NULL;
+
+    len = strlen(string)+1; /* Include final NUL */
+
+    p = perm_alloc(len);
+    memcpy(p, string, len);
+
+    return p;
+}
+
+static char *
+perm_copy3(const char *s1, const char *s2, const char *s3)
+{
+    char *p;
+    size_t l1 = strlen(s1);
+    size_t l2 = strlen(s2);
+    size_t l3 = strlen(s3)+1;   /* Include final NUL */
+
+    p = perm_alloc(l1+l2+l3);
+    memcpy(p, s1, l1);
+    memcpy(p+l1, s2, l2);
+    memcpy(p+l1+l2, s3, l3);
+
+    return p;
+}
+
+const char *local_scope(const char *label)
+{
+   return islocal(label) ? prevlabel : "";
+}
+
+/*
+ * Notes regarding bug involving redefinition of external segments.
+ *
+ * Up to and including v0.97, the following code didn't work. From 0.97
+ * developers release 2 onwards, it will generate an error.
+ *
+ * EXTERN extlabel
+ * newlabel EQU extlabel + 1
+ *
+ * The results of allowing this code through are that two import records
+ * are generated, one for 'extlabel' and one for 'newlabel'.
+ *
+ * The reason for this is an inadequacy in the defined interface between
+ * the label manager and the output formats. The problem lies in how the
+ * output format driver tells that a label is an external label for which
+ * a label import record must be produced. Most (all except bin?) produce
+ * the record if the segment number of the label is not one of the internal
+ * segments that the output driver is producing.
+ *
+ * A simple fix to this would be to make the output formats keep track of
+ * which symbols they've produced import records for, and make them not
+ * produce import records for segments that are already defined.
+ *
+ * The best way, which is slightly harder but reduces duplication of code
+ * and should therefore make the entire system smaller and more stable is
+ * to change the interface between assembler, define_label(), and
+ * the output module. The changes that are needed are:
+ *
+ * The semantics of the 'isextern' flag passed to define_label() need
+ * examining. This information may or may not tell us what we need to
+ * know (ie should we be generating an import record at this point for this
+ * label). If these aren't the semantics, the semantics should be changed
+ * to this.
+ *
+ * The output module interface needs changing, so that the `isextern' flag
+ * is passed to the module, so that it can be easily tested for.
+ */
diff --git a/vere/ext/nasm/asm/listing.c b/vere/ext/nasm/asm/listing.c
new file mode 100644
index 0000000..186b8b4
--- /dev/null
+++ b/vere/ext/nasm/asm/listing.c
@@ -0,0 +1,415 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * listing.c    listing file generator for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "strlist.h"
+#include "listing.h"
+
+#define LIST_MAX_LEN 1024       /* something sensible */
+#define LIST_INDENT  40
+#define LIST_HEXBIT  18
+
+static const char xdigit[] = "0123456789ABCDEF";
+
+#define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]);
+
+uint64_t list_options, active_list_options;
+
+static char listline[LIST_MAX_LEN];
+static bool listlinep;
+
+static struct strlist *list_errors;
+
+static char listdata[2 * LIST_INDENT];  /* we need less than that actually */
+static int32_t listoffset;
+
+static int32_t listlineno;
+
+static int suppress;            /* for INCBIN & TIMES special cases */
+
+static int listlevel, listlevel_e;
+
+static FILE *listfp;
+
+static void list_emit(void)
+{
+    int i;
+    const struct strlist_entry *e;
+
+    if (listlinep || *listdata) {
+        fprintf(listfp, "%6"PRId32" ", listlineno);
+
+        if (listdata[0])
+            fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1,
+                    listdata);
+        else
+            fprintf(listfp, "%*s", LIST_HEXBIT + 10, "");
+
+        if (listlevel_e)
+            fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""),
+                    listlevel_e);
+        else if (listlinep)
+            fprintf(listfp, "    ");
+
+        if (listlinep)
+            fprintf(listfp, " %s", listline);
+
+        putc('\n', listfp);
+        listlinep = false;
+        listdata[0] = '\0';
+    }
+
+    if (list_errors) {
+        static const char fillchars[] = " --***XX";
+        char fillchar;
+
+        strlist_for_each(e, list_errors) {
+            fprintf(listfp, "%6"PRId32"          ", listlineno);
+            fillchar = fillchars[e->pvt.u & ERR_MASK];
+            for (i = 0; i < LIST_HEXBIT; i++)
+                putc(fillchar, listfp);
+
+            if (listlevel_e)
+                fprintf(listfp, " %s<%d>", (listlevel < 10 ? " " : ""),
+                        listlevel_e);
+            else
+                fprintf(listfp, "     ");
+
+            fprintf(listfp, "  %s\n", e->str);
+        }
+
+        strlist_free(&list_errors);
+    }
+}
+
+static void list_cleanup(void)
+{
+    if (!listfp)
+        return;
+
+    list_emit();
+    fclose(listfp);
+    listfp = NULL;
+    active_list_options = 0;
+}
+
+static void list_init(const char *fname)
+{
+    enum file_flags flags = NF_TEXT;
+
+    if (listfp)
+        list_cleanup();
+
+    if (!fname || fname[0] == '\0') {
+	listfp = NULL;
+	return;
+    }
+
+    if (list_option('w'))
+        flags |= NF_IOLBF;
+
+    listfp = nasm_open_write(fname, flags);
+    if (!listfp) {
+        nasm_nonfatal("unable to open listing file `%s'", fname);
+        return;
+    }
+
+    active_list_options = list_options | 1;
+
+    *listline = '\0';
+    listlineno = 0;
+    list_errors = NULL;
+    listlevel = 0;
+    suppress = 0;
+}
+
+static void list_out(int64_t offset, char *str)
+{
+    if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
+        strcat(listdata, "-");
+        list_emit();
+    }
+    if (!listdata[0])
+        listoffset = offset;
+    strcat(listdata, str);
+}
+
+static void list_address(int64_t offset, const char *brackets,
+			 int64_t addr, int size)
+{
+    char q[20];
+    char *r = q;
+
+    nasm_assert(size <= 8);
+
+    *r++ = brackets[0];
+    while (size--) {
+	HEX(r, addr);
+	addr >>= 8;
+	r += 2;
+    }
+    *r++ = brackets[1];
+    *r = '\0';
+    list_out(offset, q);
+}
+
+static void list_size(int64_t offset, const char *tag, uint64_t size)
+{
+    char buf[64];
+    const char *fmt;
+
+    if (list_option('d'))
+        fmt = "<%s %"PRIu64">";
+    else
+        fmt = "<%s %"PRIX64"h>";
+
+    snprintf(buf, sizeof buf, fmt, tag, size);
+    list_out(offset, buf);
+}
+
+static void list_output(const struct out_data *data)
+{
+    char q[24];
+    uint64_t size = data->size;
+    uint64_t offset = data->offset;
+    const uint8_t *p = data->data;
+
+
+    if (!listfp || suppress || user_nolist)
+        return;
+
+    switch (data->type) {
+    case OUT_ZERODATA:
+        if (size > 16) {
+            list_size(offset, "zero", size);
+            break;
+        } else {
+            p = zero_buffer;
+        }
+        /* fall through */
+    case OUT_RAWDATA:
+    {
+	if (size == 0) {
+            if (!listdata[0])
+                listoffset = data->offset;
+        } else if (p) {
+            while (size--) {
+                HEX(q, *p);
+                q[2] = '\0';
+                list_out(offset++, q);
+                p++;
+            }
+        } else {
+            /* Used for listing on non-code generation passes with -Lp */
+            list_size(offset, "len", size);
+        }
+	break;
+    }
+    case OUT_ADDRESS:
+        list_address(offset, "[]", data->toffset, size);
+	break;
+    case OUT_SEGMENT:
+        q[0] = '[';
+        memset(q+1, 's', size << 1);
+        q[(size << 1)+1] = ']';
+        q[(size << 1)+2] = '\0';
+        list_out(offset, q);
+        offset += size;
+        break;
+    case OUT_RELADDR:
+	list_address(offset, "()", data->toffset, size);
+	break;
+    case OUT_RESERVE:
+    {
+        if (size > 8) {
+            list_size(offset, "res", size);
+        } else {
+            memset(q, '?', size << 1);
+            q[size << 1] = '\0';
+            list_out(offset, q);
+        }
+	break;
+    }
+    default:
+        panic();
+    }
+}
+
+static void list_line(int type, int32_t lineno, const char *line)
+{
+    (void)type;
+
+    if (!listfp)
+        return;
+
+    if (user_nolist)
+      return;
+
+    list_emit();
+    if (lineno >= 0)
+        listlineno = lineno;
+    listlinep = true;
+    strlcpy(listline, line, LIST_MAX_LEN-3);
+    memcpy(listline + LIST_MAX_LEN-4, "...", 4);
+    listlevel_e = listlevel;
+}
+
+static void list_uplevel(int type, int64_t size)
+{
+    if (!listfp)
+        return;
+
+    switch (type) {
+    case LIST_INCBIN:
+        suppress |= 1;
+        list_size(listoffset, "bin", size);
+        break;
+
+    case LIST_TIMES:
+        suppress |= 2;
+        list_size(listoffset, "rep", size);
+        break;
+
+    case LIST_INCLUDE:
+        listlevel++;
+        break;
+
+    default:
+        listlevel++;
+        break;
+    }
+}
+
+static void list_downlevel(int type)
+{
+    if (!listfp)
+        return;
+
+    switch (type) {
+    case LIST_INCBIN:
+        suppress &= ~1;
+        break;
+
+    case LIST_TIMES:
+        suppress &= ~2;
+        break;
+
+    default:
+        listlevel--;
+        break;
+    }
+}
+
+static void printf_func(2, 3) list_error(errflags severity, const char *fmt, ...)
+{
+    va_list ap;
+
+    if (!listfp)
+	return;
+
+    if (!list_errors)
+        list_errors = strlist_alloc(false);
+
+    va_start(ap, fmt);
+    strlist_vprintf(list_errors, fmt, ap);
+    va_end(ap);
+    strlist_tail(list_errors)->pvt.u = severity;
+
+    if ((severity & ERR_MASK) >= ERR_FATAL)
+	list_emit();
+}
+
+static void list_set_offset(uint64_t offset)
+{
+    listoffset = offset;
+}
+
+static void list_update_options(const char *str)
+{
+    bool state = true;
+    unsigned char c;
+    uint64_t mask;
+
+    while ((c = *str++)) {
+        switch (c) {
+        case '+':
+            state = true;
+            break;
+        case '-':
+            state = false;
+            break;
+        default:
+            mask = list_option_mask(c);
+            if (state)
+                list_options |= mask;
+            else
+                list_options &= ~mask;
+            break;
+        }
+    }
+}
+
+enum directive_result list_pragma(const struct pragma *pragma)
+{
+    switch (pragma->opcode) {
+    case D_OPTIONS:
+        list_update_options(pragma->tail);
+        return DIRR_OK;
+
+    default:
+        return DIRR_UNKNOWN;
+    }
+}
+
+static const struct lfmt nasm_list = {
+    list_init,
+    list_cleanup,
+    list_output,
+    list_line,
+    list_uplevel,
+    list_downlevel,
+    list_error,
+    list_set_offset
+};
+
+const struct lfmt *lfmt = &nasm_list;
diff --git a/vere/ext/nasm/asm/listing.h b/vere/ext/nasm/asm/listing.h
new file mode 100644
index 0000000..639a56e
--- /dev/null
+++ b/vere/ext/nasm/asm/listing.h
@@ -0,0 +1,196 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * listing.h   header file for listing.c
+ */
+
+#ifndef NASM_LISTING_H
+#define NASM_LISTING_H
+
+#include "nasm.h"
+
+/*
+ * List-file generators should look like this:
+ */
+struct lfmt {
+    /*
+     * Called to initialize the listing file generator. Before this
+     * is called, the other routines will silently do nothing when
+     * called. The `char *' parameter is the file name to write the
+     * listing to.
+     */
+    void (*init)(const char *fname);
+
+    /*
+     * Called to clear stuff up and close the listing file.
+     */
+    void (*cleanup)(void);
+
+    /*
+     * Called to output binary data. Parameters are: the offset;
+     * the data; the data type. Data types are similar to the
+     * output-format interface, only OUT_ADDRESS will _always_ be
+     * displayed as if it's relocatable, so ensure that any non-
+     * relocatable address has been converted to OUT_RAWDATA by
+     * then.
+     */
+    void (*output)(const struct out_data *data);
+
+    /*
+     * Called to send a text line to the listing generator. The
+     * `int' parameter is LIST_READ or LIST_MACRO depending on
+     * whether the line came directly from an input file or is the
+     * result of a multi-line macro expansion.
+     *
+     * If a line number is provided, print it; if the line number is
+     * -1 then use the same line number as the previous call.
+     */
+    void (*line)(int type, int32_t lineno, const char *line);
+
+    /*
+     * Called to change one of the various levelled mechanisms in the
+     * listing generator. LIST_INCLUDE and LIST_MACRO can be used to
+     * increase the nesting level of include files and macro
+     * expansions; LIST_TIMES and LIST_INCBIN switch on the two
+     * binary-output-suppression mechanisms for large-scale
+     * pseudo-instructions; the size argument prints the size or
+     * repetiiton count.
+     *
+     * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
+     * it indicates the beginning of the expansion of a `nolist'
+     * macro, so anything under that level won't be expanded unless
+     * it includes another file.
+     */
+    void (*uplevel)(int type, int64_t size);
+
+    /*
+     * Reverse the effects of uplevel.
+     */
+    void (*downlevel)(int type);
+
+    /*
+     * Called on a warning or error, with the error message.
+     */
+    void printf_func_ptr(2, 3) (*error)(errflags severity, const char *fmt, ...);
+
+    /*
+     * Update the current offset.  Used to give the listing generator
+     * an offset to work with when doing things like
+     * uplevel(LIST_TIMES) or uplevel(LIST_INCBIN); see
+     * list_set_offset();
+     */
+    void (*set_offset)(uint64_t offset);
+};
+
+extern const struct lfmt *lfmt;
+extern bool user_nolist;
+
+/*
+ * list_options are the requested options; active_list_options gets
+ * set when a pass starts.
+ *
+ * These are simple bitmasks of ASCII-64 mapping directly to option
+ * letters.
+ */
+extern uint64_t list_options, active_list_options;
+
+/*
+ * This maps the characters a-z, A-Z and 0-9 onto a 64-bit bitmask.
+ * Bit 0 is used to indicate that the listing engine is active, and
+ * bit 1 is reserved, so this will only return mask bits 2 and higher;
+ * as there are 62 possible characters this fits nicely.
+ *
+ * The mask returned is 0 for invalid characters, accessing no bits at
+ * all.
+ *
+ * This isn't particularly efficient code, but just about every
+ * instance of it should be fed a constant, so the entire function can
+ * be precomputed at compile time. The only cases where the full
+ * computation is needed is when parsing the -L option or %pragma list
+ * options, neither of which is in any way performance critical.
+ *
+ * The character + represents ALL listing options except -Lw (flush
+ * after every line.)
+ */
+static inline const_func uint64_t list_option_mask_val(unsigned char x)
+{
+    if (x >= 'a') {
+        if (x > 'z')
+            return 0;
+        x = x - 'a' + 2;
+    } else if (x >= 'A') {
+        if (x > 'Z')
+            return 0;
+        x = x - 'A' + 2 + 26;
+    } else if (x >= '0') {
+        if (x > '9')
+            return 0;
+        x = x - '0' + 2 + 26*2;
+    } else {
+        return 0;
+    }
+
+    return UINT64_C(1) << x;
+}
+
+static inline const_func uint64_t list_option_mask(unsigned char x)
+{
+    if (x == '+')
+        return ~(list_option_mask_val('w') | 3);
+    else
+        return list_option_mask_val(x);
+}
+
+/* Return true if the listing engine is active and a certain option is set. */
+static inline pure_func bool list_option(unsigned char x)
+{
+    return unlikely(active_list_options & list_option_mask(x));
+}
+
+/* We can't test this using active_list_options for obvious reasons... */
+static inline pure_func bool list_on_every_pass(void)
+{
+    return unlikely(list_options & list_option_mask('p'));
+}
+
+/* Is the listing engine active? */
+static inline pure_func bool list_active(void)
+{
+    return (active_list_options & 1);
+}
+
+/* Pragma handler */
+enum directive_result list_pragma(const struct pragma *);
+
+#endif
diff --git a/vere/ext/nasm/asm/nasm.c b/vere/ext/nasm/asm/nasm.c
new file mode 100644
index 0000000..76c70f6
--- /dev/null
+++ b/vere/ext/nasm/asm/nasm.c
@@ -0,0 +1,2352 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * The Netwide Assembler main program module
+ */
+
+#include "compiler.h"
+
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "nctype.h"
+#include "error.h"
+#include "saa.h"
+#include "raa.h"
+#include "floats.h"
+#include "stdscan.h"
+#include "insns.h"
+#include "preproc.h"
+#include "parser.h"
+#include "eval.h"
+#include "assemble.h"
+#include "labels.h"
+#include "outform.h"
+#include "listing.h"
+#include "iflag.h"
+#include "quote.h"
+#include "ver.h"
+
+/*
+ * This is the maximum number of optimization passes to do.  If we ever
+ * find a case where the optimizer doesn't naturally converge, we might
+ * have to drop this value so the assembler doesn't appear to just hang.
+ */
+#define MAX_OPTIMIZE (INT_MAX >> 1)
+
+struct forwrefinfo {            /* info held on forward refs. */
+    int lineno;
+    int operand;
+};
+
+const char *_progname;
+
+static void parse_cmdline(int, char **, int);
+static void assemble_file(const char *, struct strlist *);
+static bool skip_this_pass(errflags severity);
+static void usage(void);
+static void help(FILE *);
+
+struct error_format {
+    const char *beforeline;     /* Before line number, if present */
+    const char *afterline;      /* After line number, if present */
+    const char *beforemsg;      /* Before actual message */
+};
+
+static const struct error_format errfmt_gnu  = { ":", "",  ": "  };
+static const struct error_format errfmt_msvc = { "(", ")", " : " };
+static const struct error_format *errfmt = &errfmt_gnu;
+static struct strlist *warn_list;
+static struct nasm_errhold *errhold_stack;
+
+unsigned int debug_nasm;        /* Debugging messages? */
+
+static bool using_debug_info, opt_verbose_info;
+static const char *debug_format;
+
+#ifndef ABORT_ON_PANIC
+# define ABORT_ON_PANIC 0
+#endif
+static bool abort_on_panic = ABORT_ON_PANIC;
+static bool keep_all;
+
+bool tasm_compatible_mode = false;
+enum pass_type _pass_type;
+const char * const _pass_types[] =
+{
+    "init", "preproc-only", "first", "optimize", "stabilize", "final"
+};
+int64_t _passn;
+int globalrel = 0;
+int globalbnd = 0;
+
+struct compile_time official_compile_time;
+
+const char *inname;
+const char *outname;
+static const char *listname;
+static const char *errname;
+
+static int64_t globallineno;    /* for forward-reference tracking */
+
+const struct ofmt *ofmt = &OF_DEFAULT;
+const struct ofmt_alias *ofmt_alias = NULL;
+const struct dfmt *dfmt;
+
+FILE *error_file;               /* Where to write error messages */
+
+FILE *ofile = NULL;
+struct optimization optimizing =
+    { MAX_OPTIMIZE, OPTIM_ALL_ENABLED }; /* number of optimization passes to take */
+static int cmd_sb = 16;    /* by default */
+
+iflag_t cpu, cmd_cpu;
+
+struct location location;
+bool in_absolute;                 /* Flag we are in ABSOLUTE seg */
+struct location absolute;         /* Segment/offset inside ABSOLUTE */
+
+static struct RAA *offsets;
+
+static struct SAA *forwrefs;    /* keep track of forward references */
+static const struct forwrefinfo *forwref;
+
+static struct strlist *include_path;
+static enum preproc_opt ppopt;
+
+#define OP_NORMAL           (1U << 0)
+#define OP_PREPROCESS       (1U << 1)
+#define OP_DEPEND           (1U << 2)
+
+static unsigned int operating_mode;
+
+/* Dependency flags */
+static bool depend_emit_phony = false;
+static bool depend_missing_ok = false;
+static const char *depend_target = NULL;
+static const char *depend_file = NULL;
+struct strlist *depend_list;
+
+static bool want_usage;
+static bool terminate_after_phase;
+bool user_nolist = false;
+
+static char *quote_for_pmake(const char *str);
+static char *quote_for_wmake(const char *str);
+static char *(*quote_for_make)(const char *) = quote_for_pmake;
+
+/*
+ * Execution limits that can be set via a command-line option or %pragma
+ */
+
+/*
+ * This is really unlimited; it would take far longer than the
+ * current age of the universe for this limit to be reached even on
+ * much faster CPUs than currently exist.
+*/
+#define LIMIT_MAX_VAL	(INT64_MAX >> 1)
+
+int64_t nasm_limit[LIMIT_MAX+1];
+
+struct limit_info {
+    const char *name;
+    const char *help;
+    int64_t default_val;
+};
+/* The order here must match enum nasm_limit in nasm.h */
+static const struct limit_info limit_info[LIMIT_MAX+1] = {
+    { "passes", "total number of passes", LIMIT_MAX_VAL },
+    { "stalled-passes", "number of passes without forward progress", 1000 },
+    { "macro-levels", "levels of macro expansion", 10000 },
+    { "macro-tokens", "tokens processed during single-lime macro expansion", 10000000 },
+    { "mmacros", "multi-line macros before final return", 100000 },
+    { "rep", "%rep count", 1000000 },
+    { "eval", "expression evaluation descent", 8192 },
+    { "lines", "total source lines processed", 2000000000 }
+};
+
+static void set_default_limits(void)
+{
+    int i;
+    size_t rl;
+    int64_t new_limit;
+
+    for (i = 0; i <= LIMIT_MAX; i++)
+        nasm_limit[i] = limit_info[i].default_val;
+
+    /*
+     * Try to set a sensible default value for the eval depth based
+     * on the limit of the stack size, if knowable...
+     */
+    rl = nasm_get_stack_size_limit();
+    new_limit = rl / (128 * sizeof(void *)); /* Sensible heuristic */
+    if (new_limit < nasm_limit[LIMIT_EVAL])
+        nasm_limit[LIMIT_EVAL] = new_limit;
+}
+
+enum directive_result
+nasm_set_limit(const char *limit, const char *valstr)
+{
+    int i;
+    int64_t val;
+    bool rn_error;
+    int errlevel;
+
+    if (!limit)
+        limit = "";
+    if (!valstr)
+        valstr = "";
+
+    for (i = 0; i <= LIMIT_MAX; i++) {
+        if (!nasm_stricmp(limit, limit_info[i].name))
+            break;
+    }
+    if (i > LIMIT_MAX) {
+        if (not_started())
+            errlevel = ERR_WARNING|WARN_OTHER|ERR_USAGE;
+        else
+            errlevel = ERR_WARNING|WARN_PRAGMA_UNKNOWN;
+        nasm_error(errlevel, "unknown limit: `%s'", limit);
+        return DIRR_ERROR;
+    }
+
+    if (!nasm_stricmp(valstr, "unlimited")) {
+        val = LIMIT_MAX_VAL;
+    } else {
+        val = readnum(valstr, &rn_error);
+        if (rn_error || val < 0) {
+            if (not_started())
+                errlevel = ERR_WARNING|WARN_OTHER|ERR_USAGE;
+            else
+                errlevel = ERR_WARNING|WARN_PRAGMA_BAD;
+            nasm_error(errlevel, "invalid limit value: `%s'", valstr);
+            return DIRR_ERROR;
+        }
+        if (val > LIMIT_MAX_VAL)
+            val = LIMIT_MAX_VAL;
+    }
+
+    nasm_limit[i] = val;
+    return DIRR_OK;
+}
+
+int64_t switch_segment(int32_t segment)
+{
+    location.segment = segment;
+    if (segment == NO_SEG) {
+        location.offset = absolute.offset;
+        in_absolute = true;
+    } else {
+        location.offset = raa_read(offsets, segment);
+        in_absolute = false;
+    }
+    return location.offset;
+}
+
+static void set_curr_offs(int64_t l_off)
+{
+        if (in_absolute)
+            absolute.offset = l_off;
+        else
+            offsets = raa_write(offsets, location.segment, l_off);
+}
+
+static void increment_offset(int64_t delta)
+{
+    if (unlikely(delta == 0))
+        return;
+
+    location.offset += delta;
+    set_curr_offs(location.offset);
+}
+
+/*
+ * Define system-defined macros that are not part of
+ * macros/standard.mac.
+ */
+static void define_macros(void)
+{
+    const struct compile_time * const oct = &official_compile_time;
+    char temp[128];
+
+    if (oct->have_local) {
+        strftime(temp, sizeof temp, "__?DATE?__=\"%Y-%m-%d\"", &oct->local);
+        pp_pre_define(temp);
+        strftime(temp, sizeof temp, "__?DATE_NUM?__=%Y%m%d", &oct->local);
+        pp_pre_define(temp);
+        strftime(temp, sizeof temp, "__?TIME?__=\"%H:%M:%S\"", &oct->local);
+        pp_pre_define(temp);
+        strftime(temp, sizeof temp, "__?TIME_NUM?__=%H%M%S", &oct->local);
+        pp_pre_define(temp);
+    }
+
+    if (oct->have_gm) {
+        strftime(temp, sizeof temp, "__?UTC_DATE?__=\"%Y-%m-%d\"", &oct->gm);
+        pp_pre_define(temp);
+        strftime(temp, sizeof temp, "__?UTC_DATE_NUM?__=%Y%m%d", &oct->gm);
+        pp_pre_define(temp);
+        strftime(temp, sizeof temp, "__?UTC_TIME?__=\"%H:%M:%S\"", &oct->gm);
+        pp_pre_define(temp);
+        strftime(temp, sizeof temp, "__?UTC_TIME_NUM?__=%H%M%S", &oct->gm);
+        pp_pre_define(temp);
+    }
+
+    if (oct->have_posix) {
+        snprintf(temp, sizeof temp, "__?POSIX_TIME?__=%"PRId64, oct->posix);
+        pp_pre_define(temp);
+    }
+
+    /*
+     * In case if output format is defined by alias
+     * we have to put shortname of the alias itself here
+     * otherwise ABI backward compatibility gets broken.
+     */
+    snprintf(temp, sizeof(temp), "__?OUTPUT_FORMAT?__=%s",
+             ofmt_alias ? ofmt_alias->shortname : ofmt->shortname);
+    pp_pre_define(temp);
+
+    /*
+     * Output-format specific macros.
+     */
+    if (ofmt->stdmac)
+        pp_extra_stdmac(ofmt->stdmac);
+
+    /*
+     * Debug format, if any
+     */
+    if (dfmt != &null_debug_form) {
+        snprintf(temp, sizeof(temp), "__?DEBUG_FORMAT?__=%s", dfmt->shortname);
+        pp_pre_define(temp);
+    }
+}
+
+/*
+ * Initialize the preprocessor, set up the include path, and define
+ * the system-included macros.  This is called between passes 1 and 2
+ * of parsing the command options; ofmt and dfmt are defined at this
+ * point.
+ *
+ * Command-line specified preprocessor directives (-p, -d, -u,
+ * --pragma, --before) are processed after this function.
+ */
+static void preproc_init(struct strlist *ipath)
+{
+    pp_init(ppopt);
+    define_macros();
+    pp_include_path(ipath);
+}
+
+static void emit_dependencies(struct strlist *list)
+{
+    FILE *deps;
+    int linepos, len;
+    bool wmake = (quote_for_make == quote_for_wmake);
+    const char *wrapstr, *nulltarget;
+    const struct strlist_entry *l;
+
+    if (!list)
+        return;
+
+    wrapstr = wmake ? " &\n " : " \\\n ";
+    nulltarget = wmake ? "\t%null\n" : "";
+
+    if (depend_file && strcmp(depend_file, "-")) {
+        deps = nasm_open_write(depend_file, NF_TEXT);
+        if (!deps) {
+            nasm_nonfatal("unable to write dependency file `%s'", depend_file);
+            return;
+        }
+    } else {
+        deps = stdout;
+    }
+
+    linepos = fprintf(deps, "%s :", depend_target);
+    strlist_for_each(l, list) {
+        char *file = quote_for_make(l->str);
+        len = strlen(file);
+        if (linepos + len > 62 && linepos > 1) {
+            fputs(wrapstr, deps);
+            linepos = 1;
+        }
+        fprintf(deps, " %s", file);
+        linepos += len+1;
+        nasm_free(file);
+    }
+    fputs("\n\n", deps);
+
+    strlist_for_each(l, list) {
+        if (depend_emit_phony) {
+            char *file = quote_for_make(l->str);
+            fprintf(deps, "%s :\n%s\n", file, nulltarget);
+            nasm_free(file);
+        }
+    }
+
+    strlist_free(&list);
+
+    if (deps != stdout)
+        fclose(deps);
+}
+
+/* Convert a struct tm to a POSIX-style time constant */
+static int64_t make_posix_time(const struct tm *tm)
+{
+    int64_t t;
+    int64_t y = tm->tm_year;
+
+    /* See IEEE 1003.1:2004, section 4.14 */
+
+    t = (y-70)*365 + (y-69)/4 - (y-1)/100 + (y+299)/400;
+    t += tm->tm_yday;
+    t *= 24;
+    t += tm->tm_hour;
+    t *= 60;
+    t += tm->tm_min;
+    t *= 60;
+    t += tm->tm_sec;
+
+    return t;
+}
+
+/*
+ * Quote a filename string if and only if it is necessary.
+ * It is considered necessary if any one of these is true:
+ * 1. The filename contains control characters;
+ * 2. The filename starts or ends with a space or quote mark;
+ * 3. The filename contains more than one space in a row;
+ * 4. The filename is empty.
+ *
+ * The filename is returned in a newly allocated buffer.
+ */
+static char *nasm_quote_filename(const char *fn)
+{
+    const unsigned char *p =
+        (const unsigned char *)fn;
+    size_t len;
+
+    if (!p || !*p)
+        return nasm_strdup("\"\"");
+
+    if (*p <= ' ' || nasm_isquote(*p)) {
+        goto quote;
+    } else {
+        unsigned char cutoff = ' ';
+
+        while (*p) {
+            if (*p < cutoff)
+                goto quote;
+            cutoff = ' ' + (*p == ' ');
+            p++;
+        }
+        if (p[-1] <= ' ' || nasm_isquote(p[-1]))
+            goto quote;
+    }
+
+    /* Quoting not necessary */
+    return nasm_strdup(fn);
+
+quote:
+    len = strlen(fn);
+    return nasm_quote(fn, &len);
+}
+
+static void timestamp(void)
+{
+    struct compile_time * const oct = &official_compile_time;
+    const struct tm *tp, *best_gm;
+
+    time(&oct->t);
+
+    best_gm = NULL;
+
+    tp = localtime(&oct->t);
+    if (tp) {
+        oct->local = *tp;
+        best_gm = &oct->local;
+        oct->have_local = true;
+    }
+
+    tp = gmtime(&oct->t);
+    if (tp) {
+        oct->gm = *tp;
+        best_gm = &oct->gm;
+        oct->have_gm = true;
+        if (!oct->have_local)
+            oct->local = oct->gm;
+    } else {
+        oct->gm = oct->local;
+    }
+
+    if (best_gm) {
+        oct->posix = make_posix_time(best_gm);
+        oct->have_posix = true;
+    }
+}
+
+int main(int argc, char **argv)
+{
+    /* Do these as early as possible */
+    error_file = stderr;
+    _progname = argv[0];
+    if (!_progname || !_progname[0])
+        _progname = "nasm";
+
+    timestamp();
+
+    set_cpu(NULL);
+    cmd_cpu = cpu;
+
+    set_default_limits();
+
+    include_path = strlist_alloc(true);
+
+    _pass_type = PASS_INIT;
+    _passn = 0;
+
+    want_usage = terminate_after_phase = false;
+
+    nasm_ctype_init();
+    src_init();
+
+    /*
+     * We must call init_labels() before the command line parsing,
+     * because we may be setting prefixes/suffixes from the command
+     * line.
+     */
+    init_labels();
+
+    offsets = raa_init();
+    forwrefs = saa_init((int32_t)sizeof(struct forwrefinfo));
+
+    operating_mode = OP_NORMAL;
+
+    parse_cmdline(argc, argv, 1);
+    if (terminate_after_phase) {
+        if (want_usage)
+            usage();
+        return 1;
+    }
+
+    /* At this point we have ofmt and the name of the desired debug format */
+    if (!using_debug_info) {
+        /* No debug info, redirect to the null backend (empty stubs) */
+        dfmt = &null_debug_form;
+    } else if (!debug_format) {
+        /* Default debug format for this backend */
+        dfmt = ofmt->default_dfmt;
+    } else {
+        dfmt = dfmt_find(ofmt, debug_format);
+        if (!dfmt) {
+            nasm_fatalf(ERR_USAGE, "unrecognized debug format `%s' for output format `%s'",
+                       debug_format, ofmt->shortname);
+        }
+    }
+
+    /* Have we enabled TASM mode? */
+    if (tasm_compatible_mode) {
+        ppopt |= PP_TASM;
+        nasm_ctype_tasm_mode();
+    }
+    preproc_init(include_path);
+
+    parse_cmdline(argc, argv, 2);
+    if (terminate_after_phase) {
+        if (want_usage)
+            usage();
+        return 1;
+    }
+
+    /* Save away the default state of warnings */
+    init_warnings();
+
+    /* Dependency filename if we are also doing other things */
+    if (!depend_file && (operating_mode & ~OP_DEPEND)) {
+        if (outname)
+            depend_file = nasm_strcat(outname, ".d");
+        else
+            depend_file = filename_set_extension(inname, ".d");
+    }
+
+    /*
+     * If no output file name provided and this
+     * is preprocess mode, we're perfectly
+     * fine to output into stdout.
+     */
+    if (!outname && !(operating_mode & OP_PREPROCESS)) {
+        outname = filename_set_extension(inname, ofmt->extension);
+        if (!strcmp(outname, inname)) {
+            outname = "nasm.out";
+            nasm_warn(WARN_OTHER, "default output file same as input, using `%s' for output\n", outname);
+        }
+    }
+
+    depend_list = (operating_mode & OP_DEPEND) ? strlist_alloc(true) : NULL;
+
+    if (!depend_target)
+        depend_target = quote_for_make(outname);
+
+    if (!(operating_mode & (OP_PREPROCESS|OP_NORMAL))) {
+            char *line;
+
+            if (depend_missing_ok)
+                pp_include_path(NULL);    /* "assume generated" */
+
+            pp_reset(inname, PP_DEPS, depend_list);
+            ofile = NULL;
+            while ((line = pp_getline()))
+                nasm_free(line);
+            pp_cleanup_pass();
+            reset_warnings();
+    } else if (operating_mode & OP_PREPROCESS) {
+            char *line;
+            const char *file_name = NULL;
+            char *quoted_file_name = nasm_quote_filename(file_name);
+            int32_t linnum  = 0;
+            int32_t lineinc = 0;
+            FILE *out;
+
+            if (outname) {
+                ofile = nasm_open_write(outname, NF_TEXT);
+                if (!ofile)
+                    nasm_fatal("unable to open output file `%s'", outname);
+                out = ofile;
+            } else {
+                ofile = NULL;
+                out = stdout;
+            }
+
+            location.known = false;
+
+            _pass_type = PASS_PREPROC;
+            pp_reset(inname, PP_PREPROC, depend_list);
+
+            while ((line = pp_getline())) {
+                /*
+                 * We generate %line directives if needed for later programs
+                 */
+                struct src_location where = src_where();
+                if (file_name != where.filename) {
+                    file_name = where.filename;
+                    linnum = -1; /* Force a new %line statement */
+                    lineinc = file_name ? 1 : 0;
+                    nasm_free(quoted_file_name);
+                    quoted_file_name = nasm_quote_filename(file_name);
+                } else if (lineinc) {
+                    if (linnum + lineinc == where.lineno) {
+                        /* Add one blank line to account for increment */
+                        fputc('\n', out);
+                        linnum += lineinc;
+                    } else if (linnum - lineinc == where.lineno) {
+                        /*
+                         * Standing still, probably a macro. Set increment
+                         * to zero.
+                         */
+                        lineinc = 0;
+                    }
+                } else {
+                    /* lineinc == 0 */
+                    if (linnum + 1 == where.lineno)
+                        lineinc = 1;
+                }
+
+                /* Skip blank lines if we will need a %line anyway */
+                if (linnum == -1 && !line[0])
+                    continue;
+
+                if (linnum != where.lineno) {
+                    fprintf(out, "%%line %"PRId32"%+"PRId32" %s\n",
+                            where.lineno, lineinc, quoted_file_name);
+                }
+                linnum = where.lineno + lineinc;
+
+                fputs(line, out);
+                fputc('\n', out);
+            }
+
+            nasm_free(quoted_file_name);
+
+            pp_cleanup_pass();
+            reset_warnings();
+            if (ofile)
+                fclose(ofile);
+            if (ofile && terminate_after_phase && !keep_all)
+                remove(outname);
+            ofile = NULL;
+    }
+
+    if (operating_mode & OP_NORMAL) {
+        ofile = nasm_open_write(outname, (ofmt->flags & OFMT_TEXT) ? NF_TEXT : NF_BINARY);
+        if (!ofile)
+            nasm_fatal("unable to open output file `%s'", outname);
+
+        ofmt->init();
+        dfmt->init();
+
+        assemble_file(inname, depend_list);
+
+        if (!terminate_after_phase) {
+            ofmt->cleanup();
+            cleanup_labels();
+            fflush(ofile);
+            if (ferror(ofile))
+                nasm_nonfatal("write error on output file `%s'", outname);
+        }
+
+        if (ofile) {
+            fclose(ofile);
+            if (terminate_after_phase && !keep_all)
+                remove(outname);
+            ofile = NULL;
+        }
+    }
+
+    pp_cleanup_session();
+
+    if (depend_list && !terminate_after_phase)
+        emit_dependencies(depend_list);
+
+    if (want_usage)
+        usage();
+
+    raa_free(offsets);
+    saa_free(forwrefs);
+    eval_cleanup();
+    stdscan_cleanup();
+    src_free();
+    strlist_free(&include_path);
+
+    return terminate_after_phase;
+}
+
+/*
+ * Get a parameter for a command line option.
+ * First arg must be in the form of e.g. -f...
+ */
+static char *get_param(char *p, char *q, bool *advance)
+{
+    *advance = false;
+    if (p[2]) /* the parameter's in the option */
+        return nasm_skip_spaces(p + 2);
+    if (q && q[0]) {
+        *advance = true;
+        return q;
+    }
+    nasm_nonfatalf(ERR_USAGE, "option `-%c' requires an argument", p[1]);
+    return NULL;
+}
+
+/*
+ * Copy a filename
+ */
+static void copy_filename(const char **dst, const char *src, const char *what)
+{
+    if (*dst)
+        nasm_fatal("more than one %s file specified: %s\n", what, src);
+
+    *dst = nasm_strdup(src);
+}
+
+/*
+ * Convert a string to a POSIX make-safe form
+ */
+static char *quote_for_pmake(const char *str)
+{
+    const char *p;
+    char *os, *q;
+
+    size_t n = 1; /* Terminating zero */
+    size_t nbs = 0;
+
+    if (!str)
+        return NULL;
+
+    for (p = str; *p; p++) {
+        switch (*p) {
+        case ' ':
+        case '\t':
+            /* Convert N backslashes + ws -> 2N+1 backslashes + ws */
+            n += nbs + 2;
+            nbs = 0;
+            break;
+        case '$':
+        case '#':
+            nbs = 0;
+            n += 2;
+            break;
+        case '\\':
+            nbs++;
+            n++;
+            break;
+        default:
+            nbs = 0;
+            n++;
+            break;
+        }
+    }
+
+    /* Convert N backslashes at the end of filename to 2N backslashes */
+    n += nbs;
+
+    os = q = nasm_malloc(n);
+
+    nbs = 0;
+    for (p = str; *p; p++) {
+        switch (*p) {
+        case ' ':
+        case '\t':
+            q = mempset(q, '\\', nbs);
+            *q++ = '\\';
+            *q++ = *p;
+            nbs = 0;
+            break;
+        case '$':
+            *q++ = *p;
+            *q++ = *p;
+            nbs = 0;
+            break;
+        case '#':
+            *q++ = '\\';
+            *q++ = *p;
+            nbs = 0;
+            break;
+        case '\\':
+            *q++ = *p;
+            nbs++;
+            break;
+        default:
+            *q++ = *p;
+            nbs = 0;
+            break;
+        }
+    }
+
+    q = mempset(q, '\\', nbs);
+    *q = '\0';
+
+    return os;
+}
+
+/*
+ * Convert a string to a Watcom make-safe form
+ */
+static char *quote_for_wmake(const char *str)
+{
+    const char *p;
+    char *os, *q;
+    bool quote = false;
+
+    size_t n = 1; /* Terminating zero */
+
+    if (!str)
+        return NULL;
+
+    for (p = str; *p; p++) {
+        switch (*p) {
+        case ' ':
+        case '\t':
+        case '&':
+            quote = true;
+            n++;
+            break;
+        case '\"':
+            quote = true;
+            n += 2;
+            break;
+        case '$':
+        case '#':
+            n += 2;
+            break;
+        default:
+            n++;
+            break;
+        }
+    }
+
+    if (quote)
+        n += 2;
+
+    os = q = nasm_malloc(n);
+
+    if (quote)
+        *q++ = '\"';
+
+    for (p = str; *p; p++) {
+        switch (*p) {
+        case '$':
+        case '#':
+            *q++ = '$';
+            *q++ = *p;
+            break;
+        case '\"':
+            *q++ = *p;
+            *q++ = *p;
+            break;
+        default:
+            *q++ = *p;
+            break;
+        }
+    }
+
+    if (quote)
+        *q++ = '\"';
+
+    *q = '\0';
+
+    return os;
+}
+
+enum text_options {
+    OPT_BOGUS,
+    OPT_VERSION,
+    OPT_HELP,
+    OPT_ABORT_ON_PANIC,
+    OPT_MANGLE,
+    OPT_INCLUDE,
+    OPT_PRAGMA,
+    OPT_BEFORE,
+    OPT_LIMIT,
+    OPT_KEEP_ALL,
+    OPT_NO_LINE,
+    OPT_DEBUG,
+    OPT_REPRODUCIBLE
+};
+enum need_arg {
+    ARG_NO,
+    ARG_YES,
+    ARG_MAYBE
+};
+
+struct textargs {
+    const char *label;
+    enum text_options opt;
+    enum need_arg need_arg;
+    int pvt;
+};
+static const struct textargs textopts[] = {
+    {"v", OPT_VERSION, ARG_NO, 0},
+    {"version", OPT_VERSION, ARG_NO, 0},
+    {"help",     OPT_HELP,  ARG_NO, 0},
+    {"abort-on-panic", OPT_ABORT_ON_PANIC, ARG_NO, 0},
+    {"prefix",   OPT_MANGLE, ARG_YES, LM_GPREFIX},
+    {"postfix",  OPT_MANGLE, ARG_YES, LM_GSUFFIX},
+    {"gprefix",  OPT_MANGLE, ARG_YES, LM_GPREFIX},
+    {"gpostfix", OPT_MANGLE, ARG_YES, LM_GSUFFIX},
+    {"lprefix",  OPT_MANGLE, ARG_YES, LM_LPREFIX},
+    {"lpostfix", OPT_MANGLE, ARG_YES, LM_LSUFFIX},
+    {"include",  OPT_INCLUDE, ARG_YES, 0},
+    {"pragma",   OPT_PRAGMA,  ARG_YES, 0},
+    {"before",   OPT_BEFORE,  ARG_YES, 0},
+    {"limit-",   OPT_LIMIT,   ARG_YES, 0},
+    {"keep-all", OPT_KEEP_ALL, ARG_NO, 0},
+    {"no-line",  OPT_NO_LINE, ARG_NO, 0},
+    {"debug",    OPT_DEBUG, ARG_MAYBE, 0},
+    {"reproducible", OPT_REPRODUCIBLE, ARG_NO, 0},
+    {NULL, OPT_BOGUS, ARG_NO, 0}
+};
+
+static void show_version(void)
+{
+    printf("NASM version %s compiled on %s%s\n",
+           nasm_version, nasm_date, nasm_compile_options);
+    exit(0);
+}
+
+static bool stopoptions = false;
+static bool process_arg(char *p, char *q, int pass)
+{
+    char *param;
+    bool advance = false;
+
+    if (!p || !p[0])
+        return false;
+
+    if (p[0] == '-' && !stopoptions) {
+        if (strchr("oOfpPdDiIlLFXuUZwW", p[1])) {
+            /* These parameters take values */
+            if (!(param = get_param(p, q, &advance)))
+                return advance;
+        }
+
+        switch (p[1]) {
+        case 's':
+            if (pass == 1)
+                error_file = stdout;
+            break;
+
+        case 'o':       /* output file */
+            if (pass == 2)
+                copy_filename(&outname, param, "output");
+            break;
+
+        case 'f':       /* output format */
+            if (pass == 1) {
+                ofmt = ofmt_find(param, &ofmt_alias);
+                if (!ofmt) {
+                    nasm_fatalf(ERR_USAGE, "unrecognised output format `%s' - use -hf for a list", param);
+                }
+            }
+            break;
+
+        case 'O':       /* Optimization level */
+            if (pass == 1) {
+                int opt;
+
+                if (!*param) {
+                    /* Naked -O == -Ox */
+                    optimizing.level = MAX_OPTIMIZE;
+                } else {
+                    while (*param) {
+                        switch (*param) {
+                        case '0': case '1': case '2': case '3': case '4':
+                        case '5': case '6': case '7': case '8': case '9':
+                            opt = strtoul(param, &param, 10);
+
+                            /* -O0 -> optimizing.level == -1, 0.98 behaviour */
+                            /* -O1 -> optimizing.level == 0, 0.98.09 behaviour */
+                            if (opt < 2)
+                                optimizing.level = opt - 1;
+                            else
+                                optimizing.level = opt;
+                            break;
+
+                        case 'v':
+                        case '+':
+                        param++;
+                        opt_verbose_info = true;
+                        break;
+
+                        case 'x':
+                            param++;
+                            optimizing.level = MAX_OPTIMIZE;
+                            break;
+
+                        default:
+                            nasm_fatal("unknown optimization option -O%c\n",
+                                       *param);
+                            break;
+                        }
+                    }
+                    if (optimizing.level > MAX_OPTIMIZE)
+                        optimizing.level = MAX_OPTIMIZE;
+                }
+            }
+            break;
+
+        case 'p':       /* pre-include */
+        case 'P':
+            if (pass == 2)
+                pp_pre_include(param);
+            break;
+
+        case 'd':       /* pre-define */
+        case 'D':
+            if (pass == 2)
+                pp_pre_define(param);
+            break;
+
+        case 'u':       /* un-define */
+        case 'U':
+            if (pass == 2)
+                pp_pre_undefine(param);
+            break;
+
+        case 'i':       /* include search path */
+        case 'I':
+            if (pass == 1)
+                strlist_add(include_path, param);
+            break;
+
+        case 'l':       /* listing file */
+            if (pass == 2)
+                copy_filename(&listname, param, "listing");
+            break;
+
+        case 'L':        /* listing options */
+            if (pass == 2) {
+                while (*param)
+                    list_options |= list_option_mask(*param++);
+            }
+            break;
+
+        case 'Z':       /* error messages file */
+            if (pass == 1)
+                copy_filename(&errname, param, "error");
+            break;
+
+        case 'F':       /* specify debug format */
+            if (pass == 1) {
+                using_debug_info = true;
+                debug_format = param;
+            }
+            break;
+
+        case 'X':       /* specify error reporting format */
+            if (pass == 1) {
+                if (!nasm_stricmp("vc", param) || !nasm_stricmp("msvc", param) || !nasm_stricmp("ms", param))
+                    errfmt = &errfmt_msvc;
+                else if (!nasm_stricmp("gnu", param) || !nasm_stricmp("gcc", param))
+                    errfmt = &errfmt_gnu;
+                else
+                    nasm_fatalf(ERR_USAGE, "unrecognized error reporting format `%s'", param);
+            }
+            break;
+
+        case 'g':
+            if (pass == 1) {
+                using_debug_info = true;
+                if (p[2])
+                    debug_format = nasm_skip_spaces(p + 2);
+            }
+            break;
+
+        case 'h':
+            help(stdout);
+            exit(0);    /* never need usage message here */
+            break;
+
+        case 'y':
+            /* legacy option */
+            dfmt_list(stdout);
+            exit(0);
+            break;
+
+        case 't':
+            if (pass == 1)
+                tasm_compatible_mode = true;
+            break;
+
+        case 'v':
+            show_version();
+            break;
+
+        case 'e':       /* preprocess only */
+        case 'E':
+            if (pass == 1)
+                operating_mode = OP_PREPROCESS;
+            break;
+
+        case 'a':       /* assemble only - don't preprocess */
+            if (pass == 1)
+                ppopt |= PP_TRIVIAL;
+            break;
+
+        case 'w':
+        case 'W':
+            if (pass == 2)
+                set_warning_status(param);
+        break;
+
+        case 'M':
+            if (pass == 1) {
+                switch (p[2]) {
+                case 'W':
+                    quote_for_make = quote_for_wmake;
+                    break;
+                case 'D':
+                case 'F':
+                case 'T':
+                case 'Q':
+                    advance = true;
+                    break;
+                default:
+                    break;
+                }
+            } else {
+                switch (p[2]) {
+                case 0:
+                    operating_mode = OP_DEPEND;
+                    break;
+                case 'G':
+                    operating_mode = OP_DEPEND;
+                    depend_missing_ok = true;
+                    break;
+                case 'P':
+                    depend_emit_phony = true;
+                    break;
+                case 'D':
+                    operating_mode |= OP_DEPEND;
+                    if (q && (q[0] != '-' || q[1] == '\0')) {
+                        depend_file = q;
+                        advance = true;
+                    }
+                    break;
+                case 'F':
+                    depend_file = q;
+                    advance = true;
+                    break;
+                case 'T':
+                    depend_target = q;
+                    advance = true;
+                    break;
+                case 'Q':
+                    depend_target = quote_for_make(q);
+                    advance = true;
+                    break;
+                case 'W':
+                    /* handled in pass 1 */
+                    break;
+                default:
+                    nasm_nonfatalf(ERR_USAGE, "unknown dependency option `-M%c'", p[2]);
+                    break;
+                }
+            }
+            if (advance && (!q || !q[0])) {
+                nasm_nonfatalf(ERR_USAGE, "option `-M%c' requires a parameter", p[2]);
+                break;
+            }
+            break;
+
+        case '-':
+            {
+                const struct textargs *tx;
+                size_t olen, plen;
+                char *eqsave;
+                enum text_options opt;
+
+                p += 2;
+
+                if (!*p) {        /* -- => stop processing options */
+                    stopoptions = true;
+                    break;
+                }
+
+                olen = 0;       /* Placate gcc at lower optimization levels */
+                plen = strlen(p);
+                for (tx = textopts; tx->label; tx++) {
+                    olen = strlen(tx->label);
+
+                    if (olen > plen)
+                        continue;
+
+                    if (nasm_memicmp(p, tx->label, olen))
+                        continue;
+
+                    if (tx->label[olen-1] == '-')
+                        break;  /* Incomplete option */
+
+                    if (!p[olen] || p[olen] == '=')
+                        break;  /* Complete option */
+                }
+
+                if (!tx->label) {
+                    nasm_nonfatalf(ERR_USAGE, "unrecognized option `--%s'", p);
+                }
+
+                opt = tx->opt;
+
+                eqsave = param = strchr(p+olen, '=');
+                if (param)
+                    *param++ = '\0';
+
+                switch (tx->need_arg) {
+                case ARG_YES:   /* Argument required, and may be standalone */
+                    if (!param) {
+                        param = q;
+                        advance = true;
+                    }
+
+                    /* Note: a null string is a valid parameter */
+                    if (!param) {
+                        nasm_nonfatalf(ERR_USAGE, "option `--%s' requires an argument", p);
+                        opt = OPT_BOGUS;
+                    }
+                    break;
+
+                case ARG_NO:    /* Argument prohibited */
+                    if (param) {
+                        nasm_nonfatalf(ERR_USAGE, "option `--%s' does not take an argument", p);
+                        opt = OPT_BOGUS;
+                    }
+                    break;
+
+                case ARG_MAYBE: /* Argument permitted, but must be attached with = */
+                    break;
+                }
+
+                switch (opt) {
+                case OPT_BOGUS:
+                    break;      /* We have already errored out */
+                case OPT_VERSION:
+                    show_version();
+                    break;
+                case OPT_ABORT_ON_PANIC:
+                    abort_on_panic = true;
+                    break;
+                case OPT_MANGLE:
+                    if (pass == 2)
+                        set_label_mangle(tx->pvt, param);
+                    break;
+                case OPT_INCLUDE:
+                    if (pass == 2)
+                        pp_pre_include(q);
+                    break;
+                case OPT_PRAGMA:
+                    if (pass == 2)
+                        pp_pre_command("%pragma", param);
+                    break;
+                case OPT_BEFORE:
+                    if (pass == 2)
+                        pp_pre_command(NULL, param);
+                    break;
+                case OPT_LIMIT:
+                    if (pass == 1)
+                        nasm_set_limit(p+olen, param);
+                    break;
+                case OPT_KEEP_ALL:
+                    keep_all = true;
+                    break;
+                case OPT_NO_LINE:
+                    ppopt |= PP_NOLINE;
+                    break;
+                case OPT_DEBUG:
+                    debug_nasm = param ? strtoul(param, NULL, 10) : debug_nasm+1;
+                    break;
+                case OPT_REPRODUCIBLE:
+                    reproducible = true;
+                    break;
+                case OPT_HELP:
+                    help(stdout);
+                    exit(0);
+                default:
+                    panic();
+                }
+
+                if (eqsave)
+                    *eqsave = '='; /* Restore = argument separator */
+
+                break;
+            }
+
+        default:
+            nasm_nonfatalf(ERR_USAGE, "unrecognised option `-%c'", p[1]);
+            break;
+        }
+    } else if (pass == 2) {
+        /* In theory we could allow multiple input files... */
+        copy_filename(&inname, p, "input");
+    }
+
+    return advance;
+}
+
+#define ARG_BUF_DELTA 128
+
+static void process_respfile(FILE * rfile, int pass)
+{
+    char *buffer, *p, *q, *prevarg;
+    int bufsize, prevargsize;
+
+    bufsize = prevargsize = ARG_BUF_DELTA;
+    buffer = nasm_malloc(ARG_BUF_DELTA);
+    prevarg = nasm_malloc(ARG_BUF_DELTA);
+    prevarg[0] = '\0';
+
+    while (1) {                 /* Loop to handle all lines in file */
+        p = buffer;
+        while (1) {             /* Loop to handle long lines */
+            q = fgets(p, bufsize - (p - buffer), rfile);
+            if (!q)
+                break;
+            p += strlen(p);
+            if (p > buffer && p[-1] == '\n')
+                break;
+            if (p - buffer > bufsize - 10) {
+                int offset;
+                offset = p - buffer;
+                bufsize += ARG_BUF_DELTA;
+                buffer = nasm_realloc(buffer, bufsize);
+                p = buffer + offset;
+            }
+        }
+
+        if (!q && p == buffer) {
+            if (prevarg[0])
+                process_arg(prevarg, NULL, pass);
+            nasm_free(buffer);
+            nasm_free(prevarg);
+            return;
+        }
+
+        /*
+         * Play safe: remove CRs, LFs and any spurious ^Zs, if any of
+         * them are present at the end of the line.
+         */
+        *(p = &buffer[strcspn(buffer, "\r\n\032")]) = '\0';
+
+        while (p > buffer && nasm_isspace(p[-1]))
+            *--p = '\0';
+
+        p = nasm_skip_spaces(buffer);
+
+        if (process_arg(prevarg, p, pass))
+            *p = '\0';
+
+        if ((int) strlen(p) > prevargsize - 10) {
+            prevargsize += ARG_BUF_DELTA;
+            prevarg = nasm_realloc(prevarg, prevargsize);
+        }
+        strncpy(prevarg, p, prevargsize);
+    }
+}
+
+/* Function to process args from a string of args, rather than the
+ * argv array. Used by the environment variable and response file
+ * processing.
+ */
+static void process_args(char *args, int pass)
+{
+    char *p, *q, *arg, *prevarg;
+    char separator = ' ';
+
+    p = args;
+    if (*p && *p != '-')
+        separator = *p++;
+    arg = NULL;
+    while (*p) {
+        q = p;
+        while (*p && *p != separator)
+            p++;
+        while (*p == separator)
+            *p++ = '\0';
+        prevarg = arg;
+        arg = q;
+        if (process_arg(prevarg, arg, pass))
+            arg = NULL;
+    }
+    if (arg)
+        process_arg(arg, NULL, pass);
+}
+
+static void process_response_file(const char *file, int pass)
+{
+    char str[2048];
+    FILE *f = nasm_open_read(file, NF_TEXT);
+    if (!f) {
+        perror(file);
+        exit(-1);
+    }
+    while (fgets(str, sizeof str, f)) {
+        process_args(str, pass);
+    }
+    fclose(f);
+}
+
+static void parse_cmdline(int argc, char **argv, int pass)
+{
+    FILE *rfile;
+    char *envreal, *envcopy = NULL, *p;
+
+    /*
+     * Initialize all the warnings to their default state, including
+     * warning index 0 used for "always on".
+     */
+    memcpy(warning_state, warning_default, sizeof warning_state);
+
+    /*
+     * First, process the NASMENV environment variable.
+     */
+    envreal = getenv("NASMENV");
+    if (envreal) {
+        envcopy = nasm_strdup(envreal);
+        process_args(envcopy, pass);
+        nasm_free(envcopy);
+    }
+
+    /*
+     * Now process the actual command line.
+     */
+    while (--argc) {
+        bool advance;
+        argv++;
+        if (argv[0][0] == '@') {
+            /*
+             * We have a response file, so process this as a set of
+             * arguments like the environment variable. This allows us
+             * to have multiple arguments on a single line, which is
+             * different to the -@resp file processing below for regular
+             * NASM.
+             */
+            process_response_file(argv[0]+1, pass);
+            argc--;
+            argv++;
+        }
+        if (!stopoptions && argv[0][0] == '-' && argv[0][1] == '@') {
+            p = get_param(argv[0], argc > 1 ? argv[1] : NULL, &advance);
+            if (p) {
+                rfile = nasm_open_read(p, NF_TEXT);
+                if (rfile) {
+                    process_respfile(rfile, pass);
+                    fclose(rfile);
+                } else {
+                    nasm_nonfatalf(ERR_USAGE, "unable to open response file `%s'", p);
+                }
+            }
+        } else
+            advance = process_arg(argv[0], argc > 1 ? argv[1] : NULL, pass);
+        argv += advance, argc -= advance;
+    }
+
+    /*
+     * Look for basic command line typos. This definitely doesn't
+     * catch all errors, but it might help cases of fumbled fingers.
+     */
+    if (pass != 2)
+        return;
+
+    if (!inname)
+        nasm_fatalf(ERR_USAGE, "no input file specified");
+    else if ((errname && !strcmp(inname, errname)) ||
+             (outname && !strcmp(inname, outname)) ||
+             (listname &&  !strcmp(inname, listname))  ||
+             (depend_file && !strcmp(inname, depend_file)))
+        nasm_fatalf(ERR_USAGE, "will not overwrite input file");
+
+    if (errname) {
+        error_file = nasm_open_write(errname, NF_TEXT);
+        if (!error_file) {
+            error_file = stderr;        /* Revert to default! */
+            nasm_fatalf(ERR_USAGE, "cannot open file `%s' for error messages", errname);
+        }
+    }
+}
+
+static void forward_refs(insn *instruction)
+{
+    int i;
+    struct forwrefinfo *fwinf;
+
+    instruction->forw_ref = false;
+
+    if (!optimizing.level)
+        return;                 /* For -O0 don't bother */
+
+    if (!forwref)
+        return;
+
+    if (forwref->lineno != globallineno)
+        return;
+
+    instruction->forw_ref = true;
+    do {
+        instruction->oprs[forwref->operand].opflags |= OPFLAG_FORWARD;
+        forwref = saa_rstruct(forwrefs);
+    } while (forwref && forwref->lineno == globallineno);
+
+    if (!pass_first())
+        return;
+
+    for (i = 0; i < instruction->operands; i++) {
+        if (instruction->oprs[i].opflags & OPFLAG_FORWARD) {
+            fwinf = saa_wstruct(forwrefs);
+            fwinf->lineno = globallineno;
+            fwinf->operand = i;
+        }
+    }
+}
+
+static void process_insn(insn *instruction)
+{
+    int32_t n;
+    int64_t l;
+
+    if (!instruction->times)
+        return;                 /* Nothing to do... */
+
+    nasm_assert(instruction->times > 0);
+
+    /*
+     * NOTE: insn_size() can change instruction->times
+     * (usually to 1) when called.
+     */
+    if (!pass_final()) {
+        int64_t start = location.offset;
+        for (n = 1; n <= instruction->times; n++) {
+            l = insn_size(location.segment, location.offset,
+                          globalbits, instruction);
+            /* l == -1 -> invalid instruction */
+            if (l != -1)
+                increment_offset(l);
+        }
+        if (list_option('p')) {
+            struct out_data dummy;
+            memset(&dummy, 0, sizeof dummy);
+            dummy.type   = OUT_RAWDATA; /* Handled specially with .data NULL */
+            dummy.offset = start;
+            dummy.size   = location.offset - start;
+            lfmt->output(&dummy);
+        }
+    } else {
+        l = assemble(location.segment, location.offset,
+                     globalbits, instruction);
+                /* We can't get an invalid instruction here */
+        increment_offset(l);
+
+        if (instruction->times > 1) {
+            lfmt->uplevel(LIST_TIMES, instruction->times);
+            for (n = 2; n <= instruction->times; n++) {
+                l = assemble(location.segment, location.offset,
+                             globalbits, instruction);
+                increment_offset(l);
+            }
+            lfmt->downlevel(LIST_TIMES);
+        }
+    }
+}
+
+static void assemble_file(const char *fname, struct strlist *depend_list)
+{
+    char *line;
+    insn output_ins;
+    uint64_t prev_offset_changed;
+    int64_t stall_count = 0; /* Make sure we make forward progress... */
+
+    switch (cmd_sb) {
+    case 16:
+        break;
+    case 32:
+        if (!iflag_cpu_level_ok(&cmd_cpu, IF_386))
+            nasm_fatal("command line: 32-bit segment size requires a higher cpu");
+        break;
+    case 64:
+        if (!iflag_cpu_level_ok(&cmd_cpu, IF_X86_64))
+            nasm_fatal("command line: 64-bit segment size requires a higher cpu");
+        break;
+    default:
+        panic();
+        break;
+    }
+
+    prev_offset_changed = INT64_MAX;
+
+    if (listname && !keep_all) {
+        /* Remove the list file in case we die before the output pass */
+        remove(listname);
+    }
+
+    while (!terminate_after_phase && !pass_final()) {
+        _passn++;
+        switch (pass_type()) {
+        case PASS_INIT:
+            _pass_type = PASS_FIRST;
+            break;
+        case PASS_OPT:
+            if (global_offset_changed)
+                break;          /* One more optimization pass */
+            /* fall through */
+        default:
+            _pass_type++;
+            break;
+        }
+
+        global_offset_changed = 0;
+
+	/*
+	 * Create a warning buffer list unless we are in
+         * pass 2 (everything will be emitted immediately in pass 2.)
+	 */
+	if (warn_list) {
+            if (warn_list->nstr || pass_final())
+                strlist_free(&warn_list);
+        }
+
+	if (!pass_final() && !warn_list)
+            warn_list = strlist_alloc(false);
+
+        globalbits = cmd_sb;  /* set 'bits' to command line default */
+        cpu = cmd_cpu;
+        if (listname) {
+            if (pass_final() || list_on_every_pass()) {
+                lfmt->init(listname);
+            } else if (list_active()) {
+                /*
+                 * Looks like we used the list engine on a previous pass,
+                 * but now it is turned off, presumably via %pragma -p
+                 */
+                lfmt->cleanup();
+                if (!keep_all)
+                    remove(listname);
+            }
+        }
+
+        in_absolute = false;
+        if (!pass_first()) {
+            saa_rewind(forwrefs);
+            forwref = saa_rstruct(forwrefs);
+            raa_free(offsets);
+            offsets = raa_init();
+        }
+        location.segment = NO_SEG;
+        location.offset  = 0;
+        if (pass_first())
+            location.known = true;
+        ofmt->reset();
+        switch_segment(ofmt->section(NULL, &globalbits));
+        pp_reset(fname, PP_NORMAL, pass_final() ? depend_list : NULL);
+
+        globallineno = 0;
+
+        while ((line = pp_getline())) {
+            if (++globallineno > nasm_limit[LIMIT_LINES])
+                nasm_fatal("overall line count exceeds the maximum %"PRId64"\n",
+                           nasm_limit[LIMIT_LINES]);
+
+            /*
+             * Here we parse our directives; this is not handled by the
+             * main parser.
+             */
+            if (process_directives(line))
+                goto end_of_line; /* Just do final cleanup */
+
+            /* Not a directive, or even something that starts with [ */
+            parse_line(line, &output_ins);
+            forward_refs(&output_ins);
+            process_insn(&output_ins);
+            cleanup_insn(&output_ins);
+
+        end_of_line:
+            nasm_free(line);
+        }                       /* end while (line = pp_getline... */
+
+        pp_cleanup_pass();
+
+        /* We better not be having an error hold still... */
+        nasm_assert(!errhold_stack);
+
+        if (global_offset_changed) {
+            switch (pass_type()) {
+            case PASS_OPT:
+                /*
+                 * This is the only pass type that can be executed more
+                 * than once, and therefore has the ability to stall.
+                 */
+                if (global_offset_changed < prev_offset_changed) {
+                    prev_offset_changed = global_offset_changed;
+                    stall_count = 0;
+                } else {
+                    stall_count++;
+                }
+
+                if (stall_count > nasm_limit[LIMIT_STALLED] ||
+                    pass_count() >= nasm_limit[LIMIT_PASSES]) {
+                    /* No convergence, almost certainly dead */
+                    nasm_nonfatalf(ERR_UNDEAD,
+                                   "unable to find valid values for all labels "
+                                   "after %"PRId64" passes; "
+                                   "stalled for %"PRId64", giving up.",
+                                   pass_count(), stall_count);
+                    nasm_nonfatalf(ERR_UNDEAD,
+                               "Possible causes: recursive EQUs, macro abuse.");
+                }
+                break;
+
+            case PASS_STAB:
+                /*!
+                 *!phase [off] phase error during stabilization
+                 *!  warns about symbols having changed values during
+                 *!  the second-to-last assembly pass. This is not
+                 *!  inherently fatal, but may be a source of bugs.
+                 */
+                nasm_warn(WARN_PHASE|ERR_UNDEAD,
+                          "phase error during stabilization "
+                          "pass, hoping for the best");
+                break;
+
+            case PASS_FINAL:
+                nasm_nonfatalf(ERR_UNDEAD,
+                               "phase error during code generation pass");
+                break;
+
+            default:
+                /* This is normal, we'll keep going... */
+                break;
+            }
+        }
+
+        reset_warnings();
+    }
+
+    if (opt_verbose_info && pass_final()) {
+        /*  -On and -Ov switches */
+        nasm_info("assembly required 1+%"PRId64"+2 passes\n", pass_count()-3);
+    }
+
+    lfmt->cleanup();
+    strlist_free(&warn_list);
+}
+
+/**
+ * get warning index; 0 if this is non-suppressible.
+ */
+static size_t warn_index(errflags severity)
+{
+    size_t index;
+
+    if ((severity & ERR_MASK) >= ERR_FATAL)
+        return 0;               /* Fatal errors are never suppressible */
+
+    /* Warnings MUST HAVE a warning category specifier! */
+    nasm_assert((severity & (ERR_MASK|WARN_MASK)) != ERR_WARNING);
+
+    index = WARN_IDX(severity);
+    nasm_assert(index < WARN_IDX_ALL);
+
+    return index;
+}
+
+static bool skip_this_pass(errflags severity)
+{
+    errflags type = severity & ERR_MASK;
+
+    /*
+     * See if it's a pass-specific error or warning which should be skipped.
+     * We can never skip fatal errors as by definition they cannot be
+     * resumed from.
+     */
+    if (type >= ERR_FATAL)
+        return false;
+
+    /*
+     * ERR_LISTMSG messages are always skipped; the list file
+     * receives them anyway as this function is not consulted
+     * for sending to the list file.
+     */
+    if (type == ERR_LISTMSG)
+        return true;
+
+    /*
+     * This message not applicable unless it is the last pass we are going
+     * to execute; this can be either the final code-generation pass or
+     * the single pass executed in preproc-only mode.
+     */
+    return (severity & ERR_PASS2) && !pass_final_or_preproc();
+}
+
+/**
+ * check for suppressed message (usually warnings or notes)
+ *
+ * @param severity the severity of the warning or error
+ * @return true if we should abort error/warning printing
+ */
+static bool is_suppressed(errflags severity)
+{
+    /* Fatal errors must never be suppressed */
+    if ((severity & ERR_MASK) >= ERR_FATAL)
+        return false;
+
+    /* This error/warning is pointless if we are dead anyway */
+    if ((severity & ERR_UNDEAD) && terminate_after_phase)
+        return true;
+
+    if (!(warning_state[warn_index(severity)] & WARN_ST_ENABLED))
+        return true;
+
+    if (!(severity & ERR_PP_LISTMACRO))
+        return pp_suppress_error(severity);
+
+    return false;
+}
+
+/**
+ * Return the true error type (the ERR_MASK part) of the given
+ * severity, accounting for warnings that may need to be promoted to
+ * error.
+ *
+ * @param severity the severity of the warning or error
+ * @return true if we should error out
+ */
+static errflags true_error_type(errflags severity)
+{
+    const uint8_t warn_is_err = WARN_ST_ENABLED|WARN_ST_ERROR;
+    int type;
+
+    type = severity & ERR_MASK;
+
+    /* Promote warning to error? */
+    if (type == ERR_WARNING) {
+        uint8_t state = warning_state[warn_index(severity)];
+        if ((state & warn_is_err) == warn_is_err)
+            type = ERR_NONFATAL;
+    }
+
+    return type;
+}
+
+/*
+ * The various error type prefixes
+ */
+static const char * const error_pfx_table[ERR_MASK+1] = {
+    ";;; ", "debug: ", "info: ", "warning: ",
+        "error: ", "fatal: ", "critical: ", "panic: "
+};
+static const char no_file_name[] = "nasm"; /* What to print if no file name */
+
+/*
+ * For fatal/critical/panic errors, kill this process.
+ */
+static fatal_func die_hard(errflags true_type, errflags severity)
+{
+    fflush(NULL);
+
+    if (true_type == ERR_PANIC && abort_on_panic)
+        abort();
+
+    if (ofile) {
+        fclose(ofile);
+        if (!keep_all)
+            remove(outname);
+        ofile = NULL;
+    }
+
+    if (severity & ERR_USAGE)
+        usage();
+
+    /* Terminate immediately */
+    exit(true_type - ERR_FATAL + 1);
+}
+
+/*
+ * Returns the struct src_location appropriate for use, after some
+ * potential filename mangling.
+ */
+static struct src_location error_where(errflags severity)
+{
+    struct src_location where;
+
+    if (severity & ERR_NOFILE) {
+        where.filename = NULL;
+        where.lineno = 0;
+    } else {
+        where = src_where_error();
+
+        if (!where.filename) {
+            where.filename =
+            inname && inname[0] ? inname :
+                outname && outname[0] ? outname :
+                NULL;
+            where.lineno = 0;
+        }
+    }
+
+    return where;
+}
+
+/*
+ * error reporting for critical and panic errors: minimize
+ * the amount of system dependencies for getting a message out,
+ * and in particular try to avoid memory allocations.
+ */
+fatal_func nasm_verror_critical(errflags severity, const char *fmt, va_list args)
+{
+    struct src_location where;
+    errflags true_type = severity & ERR_MASK;
+    static bool been_here = false;
+
+    if (unlikely(been_here))
+        abort();                /* Recursive error... just die */
+
+    been_here = true;
+
+    where = error_where(severity);
+    if (!where.filename)
+        where.filename = no_file_name;
+
+    fputs(error_pfx_table[severity], error_file);
+    fputs(where.filename, error_file);
+    if (where.lineno) {
+        fprintf(error_file, "%s%"PRId32"%s",
+                errfmt->beforeline, where.lineno, errfmt->afterline);
+    }
+    fputs(errfmt->beforemsg, error_file);
+    vfprintf(error_file, fmt, args);
+    fputc('\n', error_file);
+
+    die_hard(true_type, severity);
+}
+
+/**
+ * Stack of tentative error hold lists.
+ */
+struct nasm_errtext {
+    struct nasm_errtext *next;
+    char *msg;                  /* Owned by this structure */
+    struct src_location where;  /* Owned by the srcfile system */
+    errflags severity;
+    errflags true_type;
+};
+struct nasm_errhold {
+    struct nasm_errhold *up;
+    struct nasm_errtext *head, **tail;
+};
+
+static void nasm_free_error(struct nasm_errtext *et)
+{
+    nasm_free(et->msg);
+    nasm_free(et);
+}
+
+static void nasm_issue_error(struct nasm_errtext *et);
+
+struct nasm_errhold *nasm_error_hold_push(void)
+{
+    struct nasm_errhold *eh;
+
+    nasm_new(eh);
+    eh->up = errhold_stack;
+    eh->tail = &eh->head;
+    errhold_stack = eh;
+
+    return eh;
+}
+
+void nasm_error_hold_pop(struct nasm_errhold *eh, bool issue)
+{
+    struct nasm_errtext *et, *etmp;
+
+    /* Allow calling with a null argument saying no hold in the first place */
+    if (!eh)
+        return;
+
+    /* This *must* be the current top of the errhold stack */
+    nasm_assert(eh == errhold_stack);
+
+    if (eh->head) {
+        if (issue) {
+            if (eh->up) {
+                /* Commit the current hold list to the previous level */
+                *eh->up->tail = eh->head;
+                eh->up->tail = eh->tail;
+            } else {
+                /* Issue errors */
+                list_for_each_safe(et, etmp, eh->head)
+                    nasm_issue_error(et);
+            }
+        } else {
+            /* Free the list, drop errors */
+            list_for_each_safe(et, etmp, eh->head)
+                nasm_free_error(et);
+        }
+    }
+
+    errhold_stack = eh->up;
+    nasm_free(eh);
+}
+
+/**
+ * common error reporting
+ * This is the common back end of the error reporting schemes currently
+ * implemented.  It prints the nature of the warning and then the
+ * specific error message to error_file and may or may not return.  It
+ * doesn't return if the error severity is a "panic" or "debug" type.
+ *
+ * @param severity the severity of the warning or error
+ * @param fmt the printf style format string
+ */
+void nasm_verror(errflags severity, const char *fmt, va_list args)
+{
+    struct nasm_errtext *et;
+    errflags true_type = true_error_type(severity);
+
+    if (true_type >= ERR_CRITICAL)
+        nasm_verror_critical(severity, fmt, args);
+
+    if (is_suppressed(severity))
+        return;
+
+    nasm_new(et);
+    et->severity = severity;
+    et->true_type = true_type;
+    et->msg = nasm_vasprintf(fmt, args);
+    et->where = error_where(severity);
+
+    if (errhold_stack && true_type <= ERR_NONFATAL) {
+        /* It is a tentative error */
+        *errhold_stack->tail = et;
+        errhold_stack->tail = &et->next;
+    } else {
+        nasm_issue_error(et);
+    }
+
+    /*
+     * Don't do this before then, if we do, we lose messages in the list
+     * file, as the list file is only generated in the last pass.
+     */
+    if (skip_this_pass(severity))
+        return;
+
+    if (!(severity & (ERR_HERE|ERR_PP_LISTMACRO)))
+        pp_error_list_macros(severity);
+}
+
+/*
+ * Actually print, list and take action on an error
+ */
+static void nasm_issue_error(struct nasm_errtext *et)
+{
+    const char *pfx;
+    char warnsuf[64];           /* Warning suffix */
+    char linestr[64];           /* Formatted line number if applicable */
+    const errflags severity  = et->severity;
+    const errflags true_type = et->true_type;
+    const struct src_location where = et->where;
+
+    if (severity & ERR_NO_SEVERITY)
+        pfx = "";
+    else
+        pfx = error_pfx_table[true_type];
+
+    *warnsuf = 0;
+    if ((severity & (ERR_MASK|ERR_HERE|ERR_PP_LISTMACRO)) == ERR_WARNING) {
+        /*
+         * It's a warning without ERR_HERE defined, and we are not already
+         * unwinding the macros that led us here.
+         */
+        snprintf(warnsuf, sizeof warnsuf, " [-w+%s%s]",
+                 (true_type >= ERR_NONFATAL) ? "error=" : "",
+                 warning_name[warn_index(severity)]);
+    }
+
+    *linestr = 0;
+    if (where.lineno) {
+        snprintf(linestr, sizeof linestr, "%s%"PRId32"%s",
+                 errfmt->beforeline, where.lineno, errfmt->afterline);
+    }
+
+    if (!skip_this_pass(severity)) {
+        const char *file = where.filename ? where.filename : no_file_name;
+        const char *here = "";
+
+        if (severity & ERR_HERE) {
+            here = where.filename ? " here" : " in an unknown location";
+        }
+
+        if (warn_list && true_type < ERR_NONFATAL) {
+            /*
+             * Buffer up warnings until we either get an error
+             * or we are on the code-generation pass.
+             */
+            strlist_printf(warn_list, "%s%s%s%s%s%s%s",
+                           file, linestr, errfmt->beforemsg,
+                           pfx, et->msg, here, warnsuf);
+        } else {
+            /*
+             * Actually output an error.  If we have buffered
+             * warnings, and this is a non-warning, output them now.
+             */
+            if (true_type >= ERR_NONFATAL && warn_list) {
+                strlist_write(warn_list, "\n", error_file);
+                strlist_free(&warn_list);
+            }
+
+            fprintf(error_file, "%s%s%s%s%s%s%s\n",
+                    file, linestr, errfmt->beforemsg,
+                    pfx, et->msg, here, warnsuf);
+        }
+    }
+
+    /* Are we recursing from error_list_macros? */
+    if (severity & ERR_PP_LISTMACRO)
+        goto done;
+
+    /*
+     * Don't suppress this with skip_this_pass(), or we don't get
+     * pass1 or preprocessor warnings in the list file
+     */
+    if (severity & ERR_HERE) {
+        if (where.lineno)
+            lfmt->error(severity, "%s%s at %s:%"PRId32"%s",
+                        pfx, et->msg, where.filename, where.lineno, warnsuf);
+        else if (where.filename)
+            lfmt->error(severity, "%s%s in file %s%s",
+                        pfx, et->msg, where.filename, warnsuf);
+        else
+            lfmt->error(severity, "%s%s in an unknown location%s",
+                        pfx, et->msg, warnsuf);
+    } else {
+        lfmt->error(severity, "%s%s%s", pfx, et->msg, warnsuf);
+    }
+
+    if (skip_this_pass(severity))
+        goto done;
+
+    if (true_type >= ERR_FATAL)
+        die_hard(true_type, severity);
+    else if (true_type >= ERR_NONFATAL)
+        terminate_after_phase = true;
+
+done:
+    nasm_free_error(et);
+}
+
+static void usage(void)
+{
+    fprintf(error_file, "Type %s -h for help.\n", _progname);
+}
+
+static void help(FILE *out)
+{
+    int i;
+
+    fprintf(out,
+            "Usage: %s [-@ response_file] [options...] [--] filename\n"
+            "       %s -v (or --v)\n",
+            _progname, _progname);
+    fputs(
+        "\n"
+        "Options (values in brackets indicate defaults):\n"
+        "\n"
+        "    -h            show this text and exit (also --help)\n"
+        "    -v (or --v)   print the NASM version number and exit\n"
+        "    -@ file       response file; one command line option per line\n"
+        "\n"
+        "    -o outfile    write output to outfile\n"
+        "    --keep-all    output files will not be removed even if an error happens\n"
+        "\n"
+        "    -Xformat      specify error reporting format (gnu or vc)\n"
+        "    -s            redirect error messages to stdout\n"
+        "    -Zfile        redirect error messages to file\n"
+        "\n"
+        "    -M            generate Makefile dependencies on stdout\n"
+        "    -MG           d:o, missing files assumed generated\n"
+        "    -MF file      set Makefile dependency file\n"
+        "    -MD file      assemble and generate dependencies\n"
+        "    -MT file      dependency target name\n"
+        "    -MQ file      dependency target name (quoted)\n"
+        "    -MP           emit phony targets\n"
+        "\n"
+        "    -f format     select output file format\n"
+        , out);
+    ofmt_list(ofmt, out);
+    fputs(
+        "\n"
+        "    -g            generate debugging information\n"
+        "    -F format     select a debugging format (output format dependent)\n"
+        "    -gformat      same as -g -F format\n"
+        , out);
+    dfmt_list(out);
+    fputs(
+        "\n"
+        "    -l listfile   write listing to a list file\n"
+        "    -Lflags...    add optional information to the list file\n"
+        "       -Lb        show builtin macro packages (standard and %use)\n"
+        "       -Ld        show byte and repeat counts in decimal, not hex\n"
+        "       -Le        show the preprocessed output\n"
+        "       -Lf        ignore .nolist (force output)\n"
+        "       -Lm        show multi-line macro calls with expanded parameters\n"
+        "       -Lp        output a list file every pass, in case of errors\n"
+        "       -Ls        show all single-line macro definitions\n"
+        "       -Lw        flush the output after every line (very slow!)\n"
+        "       -L+        enable all listing options except -Lw (very verbose!)\n"
+        "\n"
+        "    -Oflags...    optimize opcodes, immediates and branch offsets\n"
+        "       -O0        no optimization\n"
+        "       -O1        minimal optimization\n"
+        "       -Ox        multipass optimization (default)\n"
+        "       -Ov        display the number of passes executed at the end\n"
+        "    -t            assemble in limited SciTech TASM compatible mode\n"
+        "\n"
+        "    -E (or -e)    preprocess only (writes output to stdout by default)\n"
+        "    -a            don't preprocess (assemble only)\n"
+        "    -Ipath        add a pathname to the include file path\n"
+        "    -Pfile        pre-include a file (also --include)\n"
+        "    -Dmacro[=str] pre-define a macro\n"
+        "    -Umacro       undefine a macro\n"
+        "   --pragma str   pre-executes a specific %%pragma\n"
+        "   --before str   add line (usually a preprocessor statement) before the input\n"
+        "   --no-line      ignore %line directives in input\n"
+        "\n"
+        "   --prefix str   prepend the given string to the names of all extern,\n"
+        "                  common and global symbols (also --gprefix)\n"
+        "   --suffix str   append the given string to the names of all extern,\n"
+        "                  common and global symbols (also --gprefix)\n"
+        "   --lprefix str  prepend the given string to local symbols\n"
+        "   --lpostfix str append the given string to local symbols\n"
+        "\n"
+        "   --reproducible attempt to produce run-to-run identical output\n"
+        "\n"
+        "    -w+x          enable warning x (also -Wx)\n"
+        "    -w-x          disable warning x (also -Wno-x)\n"
+        "    -w[+-]error   promote all warnings to errors (also -Werror)\n"
+        "    -w[+-]error=x promote warning x to errors (also -Werror=x)\n"
+        , out);
+
+    fprintf(out, "       %-20s %s\n",
+            warning_name[WARN_IDX_ALL], warning_help[WARN_IDX_ALL]);
+
+    for (i = 1; i < WARN_IDX_ALL; i++) {
+        const char *me   = warning_name[i];
+        const char *prev = warning_name[i-1];
+        const char *next = warning_name[i+1];
+
+        if (prev) {
+            int prev_len = strlen(prev);
+            const char *dash = me;
+
+            while ((dash = strchr(dash+1, '-'))) {
+                int prefix_len = dash - me; /* Not including final dash */
+                if (strncmp(next, me, prefix_len+1)) {
+                    /* Only one or last option with this prefix */
+                    break;
+                }
+                if (prefix_len >= prev_len ||
+                    strncmp(prev, me, prefix_len) ||
+                    (prev[prefix_len] != '-' && prev[prefix_len] != '\0')) {
+                    /* This prefix is different from the previous option */
+                    fprintf(out, "       %-20.*s all warnings prefixed with \"%.*s\"\n",
+                            prefix_len, me, prefix_len+1, me);
+                }
+            }
+        }
+
+        fprintf(out, "       %-20s %s%s\n",
+                warning_name[i], warning_help[i],
+                (warning_default[i] & WARN_ST_ERROR) ? " [error]" :
+                (warning_default[i] & WARN_ST_ENABLED) ? " [on]" : " [off]");
+    }
+
+    fputs(
+        "\n"
+        "   --limit-X val  set execution limit X\n"
+        , out);
+
+
+    for (i = 0; i <= LIMIT_MAX; i++) {
+        fprintf(out, "       %-20s %s [",
+                limit_info[i].name, limit_info[i].help);
+        if (nasm_limit[i] < LIMIT_MAX_VAL) {
+            fprintf(out, "%"PRId64"]\n", nasm_limit[i]);
+        } else {
+            fputs("unlimited]\n", out);
+        }
+    }
+}
diff --git a/vere/ext/nasm/asm/parser.c b/vere/ext/nasm/asm/parser.c
new file mode 100644
index 0000000..6b19ffa
--- /dev/null
+++ b/vere/ext/nasm/asm/parser.c
@@ -0,0 +1,1322 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * parser.c   source line parser for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "insns.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "stdscan.h"
+#include "eval.h"
+#include "parser.h"
+#include "floats.h"
+#include "assemble.h"
+#include "tables.h"
+
+
+static int end_expression_next(void);
+
+static struct tokenval tokval;
+
+static void process_size_override(insn *result, operand *op)
+{
+    if (tasm_compatible_mode) {
+        switch (tokval.t_integer) {
+            /* For TASM compatibility a size override inside the
+             * brackets changes the size of the operand, not the
+             * address type of the operand as it does in standard
+             * NASM syntax. Hence:
+             *
+             *  mov     eax,[DWORD val]
+             *
+             * is valid syntax in TASM compatibility mode. Note that
+             * you lose the ability to override the default address
+             * type for the instruction, but we never use anything
+             * but 32-bit flat model addressing in our code.
+             */
+        case S_BYTE:
+            op->type |= BITS8;
+            break;
+        case S_WORD:
+            op->type |= BITS16;
+            break;
+        case S_DWORD:
+        case S_LONG:
+            op->type |= BITS32;
+            break;
+        case S_QWORD:
+            op->type |= BITS64;
+            break;
+        case S_TWORD:
+            op->type |= BITS80;
+            break;
+        case S_OWORD:
+            op->type |= BITS128;
+            break;
+        default:
+            nasm_nonfatal("invalid operand size specification");
+            break;
+        }
+    } else {
+        /* Standard NASM compatible syntax */
+        switch (tokval.t_integer) {
+        case S_NOSPLIT:
+            op->eaflags |= EAF_TIMESTWO;
+            break;
+        case S_REL:
+            op->eaflags |= EAF_REL;
+            break;
+        case S_ABS:
+            op->eaflags |= EAF_ABS;
+            break;
+        case S_BYTE:
+            op->disp_size = 8;
+            op->eaflags |= EAF_BYTEOFFS;
+            break;
+        case P_A16:
+        case P_A32:
+        case P_A64:
+            if (result->prefixes[PPS_ASIZE] &&
+                result->prefixes[PPS_ASIZE] != tokval.t_integer)
+                nasm_nonfatal("conflicting address size specifications");
+            else
+                result->prefixes[PPS_ASIZE] = tokval.t_integer;
+            break;
+        case S_WORD:
+            op->disp_size = 16;
+            op->eaflags |= EAF_WORDOFFS;
+            break;
+        case S_DWORD:
+        case S_LONG:
+            op->disp_size = 32;
+            op->eaflags |= EAF_WORDOFFS;
+            break;
+        case S_QWORD:
+            op->disp_size = 64;
+            op->eaflags |= EAF_WORDOFFS;
+            break;
+        default:
+            nasm_nonfatal("invalid size specification in"
+                          " effective address");
+            break;
+        }
+    }
+}
+
+/*
+ * Braced keywords are parsed here.  opmask and zeroing
+ * decorators can be placed in any order.  e.g. zmm1 {k2}{z} or zmm2
+ * {z}{k3} decorator(s) are placed at the end of an operand.
+ */
+static bool parse_braces(decoflags_t *decoflags)
+{
+    int i, j;
+
+    i = tokval.t_type;
+
+    while (true) {
+        switch (i) {
+        case TOKEN_OPMASK:
+            if (*decoflags & OPMASK_MASK) {
+                nasm_nonfatal("opmask k%"PRIu64" is already set",
+                              *decoflags & OPMASK_MASK);
+                *decoflags &= ~OPMASK_MASK;
+            }
+            *decoflags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]);
+            break;
+        case TOKEN_DECORATOR:
+            j = tokval.t_integer;
+            switch (j) {
+            case BRC_Z:
+                *decoflags |= Z_MASK;
+                break;
+            case BRC_1TO2:
+            case BRC_1TO4:
+            case BRC_1TO8:
+            case BRC_1TO16:
+            case BRC_1TO32:
+                *decoflags |= BRDCAST_MASK | VAL_BRNUM(j - BRC_1TO2);
+                break;
+            default:
+                nasm_nonfatal("{%s} is not an expected decorator",
+                              tokval.t_charptr);
+                break;
+            }
+            break;
+        case ',':
+        case TOKEN_EOS:
+            return false;
+        default:
+            nasm_nonfatal("only a series of valid decorators expected");
+            return true;
+        }
+        i = stdscan(NULL, &tokval);
+    }
+}
+
+static inline unused_func
+const expr *next_expr(const expr *e, const expr **next_list)
+{
+    e++;
+    if (!e->type) {
+        if (next_list) {
+            e = *next_list;
+            *next_list = NULL;
+        } else {
+            e = NULL;
+        }
+    }
+    return e;
+}
+
+static inline void init_operand(operand *op)
+{
+    memset(op, 0, sizeof *op);
+
+    op->basereg  = -1;
+    op->indexreg = -1;
+    op->segment  = NO_SEG;
+    op->wrt      = NO_SEG;
+}
+
+static int parse_mref(operand *op, const expr *e)
+{
+    int b, i, s;        /* basereg, indexreg, scale */
+    int64_t o;          /* offset */
+
+    b = op->basereg;
+    i = op->indexreg;
+    s = op->scale;
+    o = op->offset;
+
+    for (; e->type; e++) {
+        if (e->type <= EXPR_REG_END) {
+            bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]);
+
+            if (is_gpr && e->value == 1 && b == -1) {
+                /* It can be basereg */
+                b = e->type;
+            } else if (i == -1) {
+                /* Must be index register */
+                i = e->type;
+                s = e->value;
+            } else {
+                if (b == -1)
+                    nasm_nonfatal("invalid effective address: two index registers");
+                else if (!is_gpr)
+                    nasm_nonfatal("invalid effective address: impossible register");
+                else
+                    nasm_nonfatal("invalid effective address: too many registers");
+                return -1;
+            }
+        } else if (e->type == EXPR_UNKNOWN) {
+            op->opflags |= OPFLAG_UNKNOWN;
+        } else if (e->type == EXPR_SIMPLE) {
+            o += e->value;
+        } else if  (e->type == EXPR_WRT) {
+            op->wrt = e->value;
+        } else if (e->type >= EXPR_SEGBASE) {
+            if (e->value == 1) {
+                if (op->segment != NO_SEG) {
+                    nasm_nonfatal("invalid effective address: multiple base segments");
+                    return -1;
+                }
+                op->segment = e->type - EXPR_SEGBASE;
+            } else if (e->value == -1 &&
+                       e->type == location.segment + EXPR_SEGBASE &&
+                       !(op->opflags & OPFLAG_RELATIVE)) {
+                op->opflags |= OPFLAG_RELATIVE;
+            } else {
+                nasm_nonfatal("invalid effective address: impossible segment base multiplier");
+                return -1;
+            }
+        } else {
+            nasm_nonfatal("invalid effective address: bad subexpression type");
+            return -1;
+        }
+   }
+
+    op->basereg  = b;
+    op->indexreg = i;
+    op->scale    = s;
+    op->offset   = o;
+    return 0;
+}
+
+static void mref_set_optype(operand *op)
+{
+    int b = op->basereg;
+    int i = op->indexreg;
+    int s = op->scale;
+
+    /* It is memory, but it can match any r/m operand */
+    op->type |= MEMORY_ANY;
+
+    if (b == -1 && (i == -1 || s == 0)) {
+        int is_rel = globalbits == 64 &&
+            !(op->eaflags & EAF_ABS) &&
+            ((globalrel &&
+              !(op->eaflags & EAF_FSGS)) ||
+             (op->eaflags & EAF_REL));
+
+        op->type |= is_rel ? IP_REL : MEM_OFFS;
+    }
+
+    if (i != -1) {
+        opflags_t iclass = nasm_reg_flags[i];
+
+        if (is_class(XMMREG,iclass))
+            op->type |= XMEM;
+        else if (is_class(YMMREG,iclass))
+            op->type |= YMEM;
+        else if (is_class(ZMMREG,iclass))
+            op->type |= ZMEM;
+    }
+}
+
+/*
+ * Convert an expression vector returned from evaluate() into an
+ * extop structure.  Return zero on success.  Note that the eop
+ * already has dup and elem set, so we can't clear it here.
+ */
+static int value_to_extop(expr *vect, extop *eop, int32_t myseg)
+{
+    eop->type = EOT_DB_NUMBER;
+    eop->val.num.offset = 0;
+    eop->val.num.segment = eop->val.num.wrt = NO_SEG;
+    eop->val.num.relative = false;
+
+    for (; vect->type; vect++) {
+        if (!vect->value)       /* zero term, safe to ignore */
+            continue;
+
+        if (vect->type <= EXPR_REG_END) /* false if a register is present */
+            return -1;
+
+        if (vect->type == EXPR_UNKNOWN) /* something we can't resolve yet */
+            return 0;
+
+        if (vect->type == EXPR_SIMPLE) {
+            /* Simple number expression */
+            eop->val.num.offset += vect->value;
+            continue;
+        }
+        if (eop->val.num.wrt == NO_SEG && !eop->val.num.relative &&
+            vect->type == EXPR_WRT) {
+            /* WRT term */
+            eop->val.num.wrt = vect->value;
+            continue;
+        }
+
+        if (!eop->val.num.relative &&
+            vect->type == EXPR_SEGBASE + myseg && vect->value == -1) {
+            /* Expression of the form: foo - $ */
+            eop->val.num.relative = true;
+            continue;
+        }
+
+        if (eop->val.num.segment == NO_SEG &&
+            vect->type >= EXPR_SEGBASE && vect->value == 1) {
+            eop->val.num.segment = vect->type - EXPR_SEGBASE;
+            continue;
+        }
+
+        /* Otherwise, badness */
+        return -1;
+    }
+
+    /* We got to the end and it was all okay */
+    return 0;
+}
+
+/*
+ * Parse an extended expression, used by db et al. "elem" is the element
+ * size; initially comes from the specific opcode (e.g. db == 1) but
+ * can be overridden.
+ */
+static int parse_eops(extop **result, bool critical, int elem)
+{
+    extop *eop = NULL, *prev = NULL;
+    extop **tail = result;
+    int sign;
+    int i = tokval.t_type;
+    int oper_num = 0;
+    bool do_subexpr = false;
+
+    *tail = NULL;
+
+    /* End of string is obvious; ) ends a sub-expression list e.g. DUP */
+    for (i = tokval.t_type; i != TOKEN_EOS; i = stdscan(NULL, &tokval)) {
+        char endparen = ')';   /* Is a right paren the end of list? */
+
+        if (i == ')')
+            break;
+
+        if (!eop) {
+            nasm_new(eop);
+            eop->dup  = 1;
+            eop->elem = elem;
+            do_subexpr = false;
+        }
+        sign = +1;
+
+        /*
+         * end_expression_next() here is to distinguish this from
+         * a string used as part of an expression...
+         */
+        if (i == TOKEN_QMARK) {
+            eop->type = EOT_DB_RESERVE;
+        } else if (do_subexpr && i == '(') {
+            extop *subexpr;
+
+            stdscan(NULL, &tokval); /* Skip paren */
+            if (parse_eops(&eop->val.subexpr, critical, eop->elem) < 0)
+                goto fail;
+
+            subexpr = eop->val.subexpr;
+            if (!subexpr) {
+                /* Subexpression is empty */
+                eop->type = EOT_NOTHING;
+            } else if (!subexpr->next) {
+                /*
+                 * Subexpression is a single element, flatten.
+                 * Note that if subexpr has an allocated buffer associated
+                 * with it, freeing it would free the buffer, too, so
+                 * we need to move subexpr up, not eop down.
+                 */
+                if (!subexpr->elem)
+                    subexpr->elem = eop->elem;
+                subexpr->dup *= eop->dup;
+                nasm_free(eop);
+                eop = subexpr;
+            } else {
+                eop->type = EOT_EXTOP;
+            }
+
+            /* We should have ended on a closing paren */
+            if (tokval.t_type != ')') {
+                nasm_nonfatal("expected `)' after subexpression, got `%s'",
+                              i == TOKEN_EOS ?
+                              "end of line" : tokval.t_charptr);
+                goto fail;
+            }
+            endparen = 0;       /* This time the paren is not the end */
+        } else if (i == '%') {
+            /* %(expression_list) */
+            do_subexpr = true;
+            continue;
+        } else if (i == TOKEN_SIZE) {
+            /* Element size override */
+            eop->elem = tokval.t_inttwo;
+            do_subexpr = true;
+            continue;
+        } else if (i == TOKEN_STR && end_expression_next()) {
+            eop->type            = EOT_DB_STRING;
+            eop->val.string.data = tokval.t_charptr;
+            eop->val.string.len  = tokval.t_inttwo;
+        } else if (i == TOKEN_STRFUNC) {
+            bool parens = false;
+            const char *funcname = tokval.t_charptr;
+            enum strfunc func = tokval.t_integer;
+
+            i = stdscan(NULL, &tokval);
+            if (i == '(') {
+                parens = true;
+                endparen = 0;
+                i = stdscan(NULL, &tokval);
+            }
+            if (i != TOKEN_STR) {
+                nasm_nonfatal("%s must be followed by a string constant",
+                              funcname);
+                eop->type = EOT_NOTHING;
+            } else {
+                eop->type = EOT_DB_STRING_FREE;
+                eop->val.string.len =
+                    string_transform(tokval.t_charptr, tokval.t_inttwo,
+                                     &eop->val.string.data, func);
+                if (eop->val.string.len == (size_t)-1) {
+                    nasm_nonfatal("invalid input string to %s", funcname);
+                    eop->type = EOT_NOTHING;
+                }
+            }
+            if (parens && i && i != ')') {
+                i = stdscan(NULL, &tokval);
+                if (i != ')')
+                    nasm_nonfatal("unterminated %s function", funcname);
+            }
+        } else if (i == '-' || i == '+') {
+            char *save = stdscan_get();
+            struct tokenval tmptok;
+
+            sign = (i == '-') ? -1 : 1;
+            if (stdscan(NULL, &tmptok) != TOKEN_FLOAT) {
+                stdscan_set(save);
+                goto is_expression;
+            } else {
+                tokval = tmptok;
+                goto is_float;
+            }
+        } else if (i == TOKEN_FLOAT) {
+            enum floatize fmt;
+        is_float:
+            eop->type = EOT_DB_FLOAT;
+
+            fmt = float_deffmt(eop->elem);
+            if (fmt == FLOAT_ERR) {
+                nasm_nonfatal("no %d-bit floating-point format supported",
+                              eop->elem << 3);
+                eop->val.string.len = 0;
+            } else if (eop->elem < 1) {
+                nasm_nonfatal("floating-point constant"
+                              " encountered in unknown instruction");
+                /*
+                 * fix suggested by Pedro Gimeno... original line was:
+                 * eop->type = EOT_NOTHING;
+                 */
+                eop->val.string.len = 0;
+            } else {
+                eop->val.string.len = eop->elem;
+
+                eop = nasm_realloc(eop, sizeof(extop) + eop->val.string.len);
+                eop->val.string.data = (char *)eop + sizeof(extop);
+                if (!float_const(tokval.t_charptr, sign,
+                                 (uint8_t *)eop->val.string.data, fmt))
+                    eop->val.string.len = 0;
+            }
+            if (!eop->val.string.len)
+                eop->type = EOT_NOTHING;
+        } else {
+            /* anything else, assume it is an expression */
+            expr *value;
+
+        is_expression:
+            value = evaluate(stdscan, NULL, &tokval, NULL,
+                             critical, NULL);
+            i = tokval.t_type;
+            if (!value)                  /* Error in evaluator */
+                goto fail;
+            if (tokval.t_flag & TFLAG_DUP) {
+                /* Expression followed by DUP */
+                if (!is_simple(value)) {
+                    nasm_nonfatal("non-constant argument supplied to DUP");
+                    goto fail;
+                } else if (value->value < 0) {
+                    nasm_nonfatal("negative argument supplied to DUP");
+                    goto fail;
+                }
+                eop->dup *= (size_t)value->value;
+                do_subexpr = true;
+                continue;
+            }
+            if (value_to_extop(value, eop, location.segment)) {
+                nasm_nonfatal("expression is not simple or relocatable");
+            }
+        }
+
+        if (eop->dup == 0 || eop->type == EOT_NOTHING) {
+            nasm_free(eop);
+        } else if (eop->type == EOT_DB_RESERVE &&
+                   prev && prev->type == EOT_DB_RESERVE &&
+                   prev->elem == eop->elem) {
+            /* Coalesce multiple EOT_DB_RESERVE */
+            prev->dup += eop->dup;
+            nasm_free(eop);
+        } else {
+            /* Add this eop to the end of the chain */
+            prev = eop;
+            *tail = eop;
+            tail = &eop->next;
+        }
+
+        oper_num++;
+        eop = NULL;             /* Done with this operand */
+
+        /*
+         * We're about to call stdscan(), which will eat the
+         * comma that we're currently sitting on between
+         * arguments. However, we'd better check first that it
+         * _is_ a comma.
+         */
+        if (i == TOKEN_EOS || i == endparen)	/* Already at end? */
+            break;
+        if (i != ',') {
+            i = stdscan(NULL, &tokval);		/* eat the comma or final paren */
+            if (i == TOKEN_EOS || i == ')')	/* got end of expression */
+                break;
+            if (i != ',') {
+                nasm_nonfatal("comma expected after operand");
+                goto fail;
+            }
+        }
+    }
+
+    return oper_num;
+
+fail:
+    if (eop)
+        nasm_free(eop);
+    return -1;
+}
+
+insn *parse_line(char *buffer, insn *result)
+{
+    bool insn_is_label = false;
+    struct eval_hints hints;
+    int opnum;
+    bool critical;
+    bool first;
+    bool recover;
+    bool far_jmp_ok;
+    int i;
+
+    nasm_static_assert(P_none == 0);
+
+restart_parse:
+    first               = true;
+    result->forw_ref    = false;
+
+    stdscan_reset();
+    stdscan_set(buffer);
+    i = stdscan(NULL, &tokval);
+
+    memset(result->prefixes, P_none, sizeof(result->prefixes));
+    result->times       = 1;    /* No TIMES either yet */
+    result->label       = NULL; /* Assume no label */
+    result->eops        = NULL; /* must do this, whatever happens */
+    result->operands    = 0;    /* must initialize this */
+    result->evex_rm     = 0;    /* Ensure EVEX rounding mode is reset */
+    result->evex_brerop = -1;   /* Reset EVEX broadcasting/ER op position */
+
+    /* Ignore blank lines */
+    if (i == TOKEN_EOS)
+        goto fail;
+
+    if (i != TOKEN_ID       &&
+        i != TOKEN_INSN     &&
+        i != TOKEN_PREFIX   &&
+        (i != TOKEN_REG || !IS_SREG(tokval.t_integer))) {
+        nasm_nonfatal("label or instruction expected at start of line");
+        goto fail;
+    }
+
+    if (i == TOKEN_ID || (insn_is_label && i == TOKEN_INSN)) {
+        /* there's a label here */
+        first = false;
+        result->label = tokval.t_charptr;
+        i = stdscan(NULL, &tokval);
+        if (i == ':') {         /* skip over the optional colon */
+            i = stdscan(NULL, &tokval);
+        } else if (i == 0) {
+            /*!
+             *!label-orphan [on] labels alone on lines without trailing `:'
+             *!=orphan-labels
+             *!  warns about source lines which contain no instruction but define
+             *!  a label without a trailing colon. This is most likely indicative
+             *!  of a typo, but is technically correct NASM syntax (see \k{syntax}.)
+             */
+            nasm_warn(WARN_LABEL_ORPHAN ,
+                       "label alone on a line without a colon might be in error");
+        }
+        if (i != TOKEN_INSN || tokval.t_integer != I_EQU) {
+            /*
+             * FIXME: location.segment could be NO_SEG, in which case
+             * it is possible we should be passing 'absolute.segment'. Look into this.
+             * Work out whether that is *really* what we should be doing.
+             * Generally fix things. I think this is right as it is, but
+             * am still not certain.
+             */
+            define_label(result->label,
+                         in_absolute ? absolute.segment : location.segment,
+                         location.offset, true);
+        }
+    }
+
+    /* Just a label here */
+    if (i == TOKEN_EOS)
+        goto fail;
+
+    while (i) {
+        int slot = PPS_SEG;
+
+        if (i == TOKEN_PREFIX) {
+            slot = tokval.t_inttwo;
+
+            if (slot == PPS_TIMES) {
+                /* TIMES is a very special prefix */
+                expr *value;
+
+                i = stdscan(NULL, &tokval);
+                value = evaluate(stdscan, NULL, &tokval, NULL,
+                                 pass_stable(), NULL);
+                i = tokval.t_type;
+                if (!value)                  /* Error in evaluator */
+                    goto fail;
+                if (!is_simple(value)) {
+                    nasm_nonfatal("non-constant argument supplied to TIMES");
+                    result->times = 1;
+                } else {
+                    result->times = value->value;
+                    if (value->value < 0) {
+                        nasm_nonfatalf(ERR_PASS2, "TIMES value %"PRId64" is negative", value->value);
+                        result->times = 0;
+                    }
+                }
+                first = false;
+                continue;
+            }
+        } else if (i == TOKEN_REG && IS_SREG(tokval.t_integer)) {
+            slot = PPS_SEG;
+            first = false;
+        } else {
+            break;              /* Not a prefix */
+        }
+
+        if (result->prefixes[slot]) {
+            if (result->prefixes[slot] == tokval.t_integer)
+                nasm_warn(WARN_OTHER, "instruction has redundant prefixes");
+            else
+                nasm_nonfatal("instruction has conflicting prefixes");
+        }
+        result->prefixes[slot] = tokval.t_integer;
+        i = stdscan(NULL, &tokval);
+        first = false;
+    }
+
+    if (i != TOKEN_INSN) {
+        int j;
+        enum prefixes pfx;
+
+        for (j = 0; j < MAXPREFIX; j++) {
+            if ((pfx = result->prefixes[j]) != P_none)
+                break;
+        }
+
+        if (i == 0 && pfx != P_none) {
+            /*
+             * Instruction prefixes are present, but no actual
+             * instruction. This is allowed: at this point we
+             * invent a notional instruction of RESB 0.
+             */
+            result->opcode          = I_RESB;
+            result->operands        = 1;
+            nasm_zero(result->oprs);
+            result->oprs[0].type    = IMMEDIATE;
+            result->oprs[0].offset  = 0L;
+            result->oprs[0].segment = result->oprs[0].wrt = NO_SEG;
+            return result;
+        } else {
+            nasm_nonfatal("parser: instruction expected");
+            goto fail;
+        }
+    }
+
+    result->opcode = tokval.t_integer;
+
+    /*
+     * INCBIN cannot be satisfied with incorrectly
+     * evaluated operands, since the correct values _must_ be known
+     * on the first pass. Hence, even in pass one, we set the
+     * `critical' flag on calling evaluate(), so that it will bomb
+     * out on undefined symbols.
+     */
+    critical = pass_final() || (result->opcode == I_INCBIN);
+
+    if (opcode_is_db(result->opcode) || result->opcode == I_INCBIN) {
+        int oper_num;
+
+        i = stdscan(NULL, &tokval);
+
+        if (first && i == ':') {
+            /* Really a label */
+            insn_is_label = true;
+            goto restart_parse;
+        }
+        first = false;
+        oper_num = parse_eops(&result->eops, critical, db_bytes(result->opcode));
+        if (oper_num < 0)
+            goto fail;
+
+        if (result->opcode == I_INCBIN) {
+            /*
+             * Correct syntax for INCBIN is that there should be
+             * one string operand, followed by one or two numeric
+             * operands.
+             */
+            if (!result->eops || result->eops->type != EOT_DB_STRING)
+                nasm_nonfatal("`incbin' expects a file name");
+            else if (result->eops->next &&
+                     result->eops->next->type != EOT_DB_NUMBER)
+                nasm_nonfatal("`incbin': second parameter is"
+                              " non-numeric");
+            else if (result->eops->next && result->eops->next->next &&
+                     result->eops->next->next->type != EOT_DB_NUMBER)
+                nasm_nonfatal("`incbin': third parameter is"
+                              " non-numeric");
+            else if (result->eops->next && result->eops->next->next &&
+                     result->eops->next->next->next)
+                nasm_nonfatal("`incbin': more than three parameters");
+            else
+                return result;
+            /*
+             * If we reach here, one of the above errors happened.
+             * Throw the instruction away.
+             */
+            goto fail;
+        } else {
+            /* DB et al */
+            result->operands = oper_num;
+            if (oper_num == 0)
+                /*!
+                 *!db-empty [on] no operand for data declaration
+                 *!  warns about a \c{DB}, \c{DW}, etc declaration
+                 *!  with no operands, producing no output.
+                 *!  This is permitted, but often indicative of an error.
+                 *!  See \k{db}.
+                 */
+                nasm_warn(WARN_DB_EMPTY, "no operand for data declaration");
+        }
+        return result;
+    }
+
+    /*
+     * Now we begin to parse the operands. There may be up to four
+     * of these, separated by commas, and terminated by a zero token.
+     */
+    far_jmp_ok = result->opcode == I_JMP || result->opcode == I_CALL;
+
+    for (opnum = 0; opnum < MAX_OPERANDS; opnum++) {
+        operand *op = &result->oprs[opnum];
+        expr *value;            /* used most of the time */
+        bool mref = false;      /* is this going to be a memory ref? */
+        int bracket = 0;        /* is it a [] mref, or a "naked" mref? */
+        bool mib;               /* compound (mib) mref? */
+        int setsize = 0;
+        decoflags_t brace_flags = 0;    /* flags for decorators in braces */
+
+        init_operand(op);
+
+        i = stdscan(NULL, &tokval);
+        if (i == TOKEN_EOS)
+            break;              /* end of operands: get out of here */
+        else if (first && i == ':') {
+            insn_is_label = true;
+            goto restart_parse;
+        }
+        first = false;
+        op->type = 0; /* so far, no override */
+        /* size specifiers */
+        while (i == TOKEN_SPECIAL || i == TOKEN_SIZE) {
+            switch (tokval.t_integer) {
+            case S_BYTE:
+                if (!setsize)   /* we want to use only the first */
+                    op->type |= BITS8;
+                setsize = 1;
+                break;
+            case S_WORD:
+                if (!setsize)
+                    op->type |= BITS16;
+                setsize = 1;
+                break;
+            case S_DWORD:
+            case S_LONG:
+                if (!setsize)
+                    op->type |= BITS32;
+                setsize = 1;
+                break;
+            case S_QWORD:
+                if (!setsize)
+                    op->type |= BITS64;
+                setsize = 1;
+                break;
+            case S_TWORD:
+                if (!setsize)
+                    op->type |= BITS80;
+                setsize = 1;
+                break;
+            case S_OWORD:
+                if (!setsize)
+                    op->type |= BITS128;
+                setsize = 1;
+                break;
+            case S_YWORD:
+                if (!setsize)
+                    op->type |= BITS256;
+                setsize = 1;
+                break;
+            case S_ZWORD:
+                if (!setsize)
+                    op->type |= BITS512;
+                setsize = 1;
+                break;
+            case S_TO:
+                op->type |= TO;
+                break;
+            case S_STRICT:
+                op->type |= STRICT;
+                break;
+            case S_FAR:
+                op->type |= FAR;
+                break;
+            case S_NEAR:
+                op->type |= NEAR;
+                break;
+            case S_SHORT:
+                op->type |= SHORT;
+                break;
+            default:
+                nasm_nonfatal("invalid operand size specification");
+            }
+            i = stdscan(NULL, &tokval);
+        }
+
+        if (i == '[' || i == TOKEN_MASM_PTR || i == '&') {
+            /* memory reference */
+            mref = true;
+            bracket += (i == '[');
+            i = stdscan(NULL, &tokval);
+        }
+
+    mref_more:
+        if (mref) {
+            bool done = false;
+            bool nofw = false;
+
+            while (!done) {
+                switch (i) {
+                case TOKEN_SPECIAL:
+                case TOKEN_SIZE:
+                case TOKEN_PREFIX:
+                    process_size_override(result, op);
+                    break;
+
+                case '[':
+                    bracket++;
+                    break;
+
+                case ',':
+                    tokval.t_type = TOKEN_NUM;
+                    tokval.t_integer = 0;
+                    stdscan_set(stdscan_get() - 1);     /* rewind the comma */
+                    done = nofw = true;
+                    break;
+
+                case TOKEN_MASM_FLAT:
+                    i = stdscan(NULL, &tokval);
+                    if (i != ':') {
+                        nasm_nonfatal("unknown use of FLAT in MASM emulation");
+                        nofw = true;
+                    }
+                    done = true;
+                    break;
+
+                default:
+                    done = nofw = true;
+                    break;
+                }
+
+                if (!nofw)
+                    i = stdscan(NULL, &tokval);
+            }
+        }
+
+        value = evaluate(stdscan, NULL, &tokval,
+                         &op->opflags, critical, &hints);
+        i = tokval.t_type;
+        if (op->opflags & OPFLAG_FORWARD) {
+            result->forw_ref = true;
+        }
+        if (!value)                  /* Error in evaluator */
+            goto fail;
+
+        if (i == '[' && !bracket) {
+            /* displacement[regs] syntax */
+            mref = true;
+            parse_mref(op, value); /* Process what we have so far */
+            goto mref_more;
+        }
+
+        if (i == ':' && (mref || !far_jmp_ok)) {
+            /* segment override? */
+            mref = true;
+
+            /*
+             * Process the segment override.
+             */
+            if (!IS_SREG(value->type) || value->value != 1 ||
+                value[1].type != 0) {
+                nasm_nonfatal("invalid segment override");
+            } else if (result->prefixes[PPS_SEG]) {
+                nasm_nonfatal("instruction has conflicting segment overrides");
+            } else {
+                result->prefixes[PPS_SEG] = value->type;
+                if (IS_FSGS(value->type))
+                    op->eaflags |= EAF_FSGS;
+            }
+
+            i = stdscan(NULL, &tokval); /* then skip the colon */
+            goto mref_more;
+        }
+
+        mib = false;
+        if (mref && bracket && i == ',') {
+            /* [seg:base+offset,index*scale] syntax (mib) */
+            operand o2;         /* Index operand */
+
+            if (parse_mref(op, value))
+                goto fail;
+
+            i = stdscan(NULL, &tokval); /* Eat comma */
+            value = evaluate(stdscan, NULL, &tokval, &op->opflags,
+                             critical, &hints);
+            i = tokval.t_type;
+            if (!value)
+                goto fail;
+
+            init_operand(&o2);
+            if (parse_mref(&o2, value))
+                goto fail;
+
+            if (o2.basereg != -1 && o2.indexreg == -1) {
+                o2.indexreg = o2.basereg;
+                o2.scale = 1;
+                o2.basereg = -1;
+            }
+
+            if (op->indexreg != -1 || o2.basereg != -1 || o2.offset != 0 ||
+                o2.segment != NO_SEG || o2.wrt != NO_SEG) {
+                nasm_nonfatal("invalid mib expression");
+                goto fail;
+            }
+
+            op->indexreg = o2.indexreg;
+            op->scale = o2.scale;
+
+            if (op->basereg != -1) {
+                op->hintbase = op->basereg;
+                op->hinttype = EAH_MAKEBASE;
+            } else if (op->indexreg != -1) {
+                op->hintbase = op->indexreg;
+                op->hinttype = EAH_NOTBASE;
+            } else {
+                op->hintbase = -1;
+                op->hinttype = EAH_NOHINT;
+            }
+
+            mib = true;
+        }
+
+        recover = false;
+        if (mref) {
+            if (bracket == 1) {
+                if (i == ']') {
+                    bracket--;
+                    i = stdscan(NULL, &tokval);
+                } else {
+                    nasm_nonfatal("expecting ] at end of memory operand");
+                    recover = true;
+                }
+            } else if (bracket == 0) {
+                /* Do nothing */
+            } else if (bracket > 0) {
+                nasm_nonfatal("excess brackets in memory operand");
+                recover = true;
+            } else if (bracket < 0) {
+                nasm_nonfatal("unmatched ] in memory operand");
+                recover = true;
+            }
+
+            if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) {
+                /* parse opmask (and zeroing) after an operand */
+                recover = parse_braces(&brace_flags);
+                i = tokval.t_type;
+            }
+            if (!recover && i != 0 && i != ',') {
+                nasm_nonfatal("comma, decorator or end of line expected, got %d", i);
+                recover = true;
+            }
+        } else {                /* immediate operand */
+            if (i != 0 && i != ',' && i != ':' &&
+                i != TOKEN_DECORATOR && i != TOKEN_OPMASK) {
+                nasm_nonfatal("comma, colon, decorator or end of "
+                              "line expected after operand");
+                recover = true;
+            } else if (i == ':') {
+                op->type |= COLON;
+            } else if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) {
+                /* parse opmask (and zeroing) after an operand */
+                recover = parse_braces(&brace_flags);
+            }
+        }
+        if (recover) {
+            do {                /* error recovery */
+                i = stdscan(NULL, &tokval);
+            } while (i != 0 && i != ',');
+        }
+
+        /*
+         * now convert the exprs returned from evaluate()
+         * into operand descriptions...
+         */
+        op->decoflags |= brace_flags;
+
+        if (mref) {             /* it's a memory reference */
+            /* A mib reference was fully parsed already */
+            if (!mib) {
+                if (parse_mref(op, value))
+                    goto fail;
+                op->hintbase = hints.base;
+                op->hinttype = hints.type;
+            }
+            mref_set_optype(op);
+        } else if ((op->type & FAR) && !far_jmp_ok) {
+                nasm_nonfatal("invalid use of FAR operand specifier");
+                recover = true;
+        } else {                /* it's not a memory reference */
+            if (is_just_unknown(value)) {       /* it's immediate but unknown */
+                op->type      |= IMMEDIATE;
+                op->opflags   |= OPFLAG_UNKNOWN;
+                op->offset    = 0;        /* don't care */
+                op->segment   = NO_SEG;   /* don't care again */
+                op->wrt       = NO_SEG;   /* still don't care */
+
+                if(optimizing.level >= 0 && !(op->type & STRICT)) {
+                    /* Be optimistic */
+                    op->type |=
+                        UNITY | SBYTEWORD | SBYTEDWORD | UDWORD | SDWORD;
+                }
+            } else if (is_reloc(value)) {       /* it's immediate */
+                uint64_t n = reloc_value(value);
+
+                op->type      |= IMMEDIATE;
+                op->offset    = n;
+                op->segment   = reloc_seg(value);
+                op->wrt       = reloc_wrt(value);
+                op->opflags   |= is_self_relative(value) ? OPFLAG_RELATIVE : 0;
+
+                if (is_simple(value)) {
+                    if (n == 1)
+                        op->type |= UNITY;
+                    if (optimizing.level >= 0 && !(op->type & STRICT)) {
+                        if ((uint32_t) (n + 128) <= 255)
+                            op->type |= SBYTEDWORD;
+                        if ((uint16_t) (n + 128) <= 255)
+                            op->type |= SBYTEWORD;
+                        if (n <= UINT64_C(0xFFFFFFFF))
+                            op->type |= UDWORD;
+                        if (n + UINT64_C(0x80000000) <= UINT64_C(0xFFFFFFFF))
+                            op->type |= SDWORD;
+                    }
+                }
+            } else if (value->type == EXPR_RDSAE) {
+                /*
+                 * it's not an operand but a rounding or SAE decorator.
+                 * put the decorator information in the (opflag_t) type field
+                 * of previous operand.
+                 */
+                opnum--; op--;
+                switch (value->value) {
+                case BRC_RN:
+                case BRC_RU:
+                case BRC_RD:
+                case BRC_RZ:
+                case BRC_SAE:
+                    op->decoflags |= (value->value == BRC_SAE ? SAE : ER);
+                    result->evex_rm = value->value;
+                    break;
+                default:
+                    nasm_nonfatal("invalid decorator");
+                    break;
+                }
+            } else {            /* it's a register */
+                opflags_t rs;
+                uint64_t regset_size = 0;
+
+                if (value->type >= EXPR_SIMPLE || value->value != 1) {
+                    nasm_nonfatal("invalid operand type");
+                    goto fail;
+                }
+
+                /*
+                 * We do not allow any kind of expression, except for
+                 * reg+value in which case it is a register set.
+                 */
+                for (i = 1; value[i].type; i++) {
+                    if (!value[i].value)
+                        continue;
+
+                    switch (value[i].type) {
+                    case EXPR_SIMPLE:
+                        if (!regset_size) {
+                            regset_size = value[i].value + 1;
+                            break;
+                        }
+                        /* fallthrough */
+                    default:
+                        nasm_nonfatal("invalid operand type");
+                        goto fail;
+                    }
+                }
+
+                if ((regset_size & (regset_size - 1)) ||
+                    regset_size >= (UINT64_C(1) << REGSET_BITS)) {
+                    nasm_nonfatalf(ERR_PASS2, "invalid register set size");
+                    regset_size = 0;
+                }
+
+                /* clear overrides, except TO which applies to FPU regs */
+                if (op->type & ~TO) {
+                    /*
+                     * we want to produce a warning iff the specified size
+                     * is different from the register size
+                     */
+                    rs = op->type & SIZE_MASK;
+                } else {
+                    rs = 0;
+                }
+
+                /*
+                 * Make sure we're not out of nasm_reg_flags, still
+                 * probably this should be fixed when we're defining
+                 * the label.
+                 *
+                 * An easy trigger is
+                 *
+                 *      e equ 0x80000000:0
+                 *      pshufw word e-0
+                 *
+                 */
+                if (value->type < EXPR_REG_START ||
+                    value->type > EXPR_REG_END) {
+                        nasm_nonfatal("invalid operand type");
+                        goto fail;
+                }
+
+                op->type      &= TO;
+                op->type      |= REGISTER;
+                op->type      |= nasm_reg_flags[value->type];
+                op->type      |= (regset_size >> 1) << REGSET_SHIFT;
+                op->decoflags |= brace_flags;
+                op->basereg   = value->type;
+
+                if (rs) {
+                    opflags_t opsize = nasm_reg_flags[value->type] & SIZE_MASK;
+                    if (!opsize) {
+                        op->type |= rs; /* For non-size-specific registers, permit size override */
+                    } else if (opsize != rs) {
+                        /*!
+                         *!regsize [on] register size specification ignored
+                         *!
+                         *!  warns about a register with implicit size (such as \c{EAX}, which is always 32 bits)
+                         *!  been given an explicit size specification which is inconsistent with the size
+                         *!  of the named register, e.g. \c{WORD EAX}. \c{DWORD EAX} or \c{WORD AX} are
+                         *!  permitted, and do not trigger this warning. Some registers which \e{do not} imply
+                         *!  a specific size, such as \c{K0}, may need this specification unless the instruction
+                         *!  itself implies the instruction size:
+                         *!-
+                         *!  \c      KMOVW K0,[foo]          ; Permitted, KMOVW implies 16 bits
+                         *!  \c      KMOV  WORD K0,[foo]     ; Permitted, WORD K0 specifies instruction size
+                         *!  \c      KMOV  K0,WORD [foo]     ; Permitted, WORD [foo] specifies instruction size
+                         *!  \c      KMOV  K0,[foo]          ; Not permitted, instruction size ambiguous
+                         */
+                        nasm_warn(WARN_REGSIZE, "invalid register size specification ignored");
+                    }
+                }
+            }
+        }
+
+        /* remember the position of operand having broadcasting/ER mode */
+        if (op->decoflags & (BRDCAST_MASK | ER | SAE))
+            result->evex_brerop = opnum;
+    }
+
+    result->operands = opnum; /* set operand count */
+
+    /* clear remaining operands */
+    while (opnum < MAX_OPERANDS)
+        result->oprs[opnum++].type = 0;
+
+    return result;
+
+fail:
+    result->opcode = I_none;
+    return result;
+}
+
+static int end_expression_next(void)
+{
+    struct tokenval tv;
+    char *p;
+    int i;
+
+    p = stdscan_get();
+    i = stdscan(NULL, &tv);
+    stdscan_set(p);
+
+    return (i == ',' || i == ';' || i == ')' || !i);
+}
+
+static void free_eops(extop *e)
+{
+    extop *next;
+
+    while (e) {
+        next = e->next;
+        switch (e->type) {
+        case EOT_EXTOP:
+            free_eops(e->val.subexpr);
+            break;
+
+        case EOT_DB_STRING_FREE:
+            nasm_free(e->val.string.data);
+            break;
+
+        default:
+            break;
+        }
+
+        nasm_free(e);
+        e = next;
+    }
+}
+
+void cleanup_insn(insn * i)
+{
+    free_eops(i->eops);
+}
diff --git a/vere/ext/nasm/asm/parser.h b/vere/ext/nasm/asm/parser.h
new file mode 100644
index 0000000..15298cb
--- /dev/null
+++ b/vere/ext/nasm/asm/parser.h
@@ -0,0 +1,45 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * parser.h   header file for the parser module of the Netwide
+ *            Assembler
+ */
+
+#ifndef NASM_PARSER_H
+#define NASM_PARSER_H
+
+insn *parse_line(char *buffer, insn *result);
+void cleanup_insn(insn *instruction);
+
+#endif
diff --git a/vere/ext/nasm/asm/pptok.c b/vere/ext/nasm/asm/pptok.c
new file mode 100644
index 0000000..c88d130
--- /dev/null
+++ b/vere/ext/nasm/asm/pptok.c
@@ -0,0 +1,848 @@
+/* Automatically generated from ./asm/pptok.dat by ./asm/pptok.pl */
+/* Do not edit */
+
+#include "compiler.h"
+#include "nctype.h"
+#include "nasmlib.h"
+#include "hashtbl.h"
+#include "preproc.h"
+
+const char * const pp_directives[120] = {
+    "%if",
+    "%ifctx",
+    "%ifdef",
+    "%ifdefalias",
+    "%ifdifi",
+    "%ifempty",
+    "%ifenv",
+    "%ifid",
+    "%ifidn",
+    "%ifidni",
+    "%ifmacro",
+    "%ifnum",
+    "%ifstr",
+    "%iftoken",
+    "%ifusable",
+    "%ifusing",
+    "%ifn",
+    "%ifnctx",
+    "%ifndef",
+    "%ifndefalias",
+    "%ifndifi",
+    "%ifnempty",
+    "%ifnenv",
+    "%ifnid",
+    "%ifnidn",
+    "%ifnidni",
+    "%ifnmacro",
+    "%ifnnum",
+    "%ifnstr",
+    "%ifntoken",
+    "%ifnusable",
+    "%ifnusing",
+    "%elif",
+    "%elifctx",
+    "%elifdef",
+    "%elifdefalias",
+    "%elifdifi",
+    "%elifempty",
+    "%elifenv",
+    "%elifid",
+    "%elifidn",
+    "%elifidni",
+    "%elifmacro",
+    "%elifnum",
+    "%elifstr",
+    "%eliftoken",
+    "%elifusable",
+    "%elifusing",
+    "%elifn",
+    "%elifnctx",
+    "%elifndef",
+    "%elifndefalias",
+    "%elifndifi",
+    "%elifnempty",
+    "%elifnenv",
+    "%elifnid",
+    "%elifnidn",
+    "%elifnidni",
+    "%elifnmacro",
+    "%elifnnum",
+    "%elifnstr",
+    "%elifntoken",
+    "%elifnusable",
+    "%elifnusing",
+    "%aliases",
+    "%arg",
+    "%clear",
+    "%depend",
+    "%else",
+    "%endif",
+    "%endm",
+    "%endmacro",
+    "%endrep",
+    "%error",
+    "%exitmacro",
+    "%exitrep",
+    "%fatal",
+    "%include",
+    "%line",
+    "%local",
+    "%null",
+    "%pop",
+    "%pragma",
+    "%push",
+    "%rep",
+    "%repl",
+    "%require",
+    "%rotate",
+    "%stacksize",
+    "%undef",
+    "%undefalias",
+    "%use",
+    "%warning",
+    NULL,
+    "%assign",
+    "%iassign",
+    "%defalias",
+    "%idefalias",
+    "%define",
+    "%idefine",
+    "%defstr",
+    "%idefstr",
+    "%deftok",
+    "%ideftok",
+    "%macro",
+    "%imacro",
+    "%pathsearch",
+    "%ipathsearch",
+    "%rmacro",
+    "%irmacro",
+    "%strcat",
+    "%istrcat",
+    "%strlen",
+    "%istrlen",
+    "%substr",
+    "%isubstr",
+    "%xdefine",
+    "%ixdefine",
+    "%unmacro",
+    "%unimacro",
+};
+const uint8_t pp_directives_len[120] = {
+    3,
+    6,
+    6,
+    11,
+    7,
+    8,
+    6,
+    5,
+    6,
+    7,
+    8,
+    6,
+    6,
+    8,
+    9,
+    8,
+    4,
+    7,
+    7,
+    12,
+    8,
+    9,
+    7,
+    6,
+    7,
+    8,
+    9,
+    7,
+    7,
+    9,
+    10,
+    9,
+    5,
+    8,
+    8,
+    13,
+    9,
+    10,
+    8,
+    7,
+    8,
+    9,
+    10,
+    8,
+    8,
+    10,
+    11,
+    10,
+    6,
+    9,
+    9,
+    14,
+    10,
+    11,
+    9,
+    8,
+    9,
+    10,
+    11,
+    9,
+    9,
+    11,
+    12,
+    11,
+    8,
+    4,
+    6,
+    7,
+    5,
+    6,
+    5,
+    9,
+    7,
+    6,
+    10,
+    8,
+    6,
+    8,
+    5,
+    6,
+    5,
+    4,
+    7,
+    5,
+    4,
+    5,
+    8,
+    7,
+    10,
+    6,
+    11,
+    4,
+    8,
+    9,
+    7,
+    8,
+    9,
+    10,
+    7,
+    8,
+    7,
+    8,
+    7,
+    8,
+    6,
+    7,
+    11,
+    12,
+    7,
+    8,
+    7,
+    8,
+    7,
+    8,
+    7,
+    8,
+    8,
+    9,
+    8,
+    9,
+};
+
+#define INVALID_HASH_ENTRY (65535/3)
+
+
+/* Primary preprocessor token hash */
+
+enum preproc_token pp_token_hash(const char *token)
+{
+    static const int16_t hashdata[512] = {
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        107,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        74,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        67,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        65,
+        -66,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        94,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        31,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        38,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        78,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        54,
+        70,
+        INVALID_HASH_ENTRY,
+        12,
+        21,
+        0,
+        0,
+        3,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        80,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        49,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -77,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        56,
+        INVALID_HASH_ENTRY,
+        47,
+        INVALID_HASH_ENTRY,
+        37,
+        0,
+        INVALID_HASH_ENTRY,
+        37,
+        0,
+        INVALID_HASH_ENTRY,
+        -20,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        7,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        116,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -32,
+        39,
+        INVALID_HASH_ENTRY,
+        72,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        179,
+        -72,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        26,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -40,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        25,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        98,
+        0,
+        71,
+        INVALID_HASH_ENTRY,
+        53,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        76,
+        INVALID_HASH_ENTRY,
+        63,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        20,
+        INVALID_HASH_ENTRY,
+        99,
+        INVALID_HASH_ENTRY,
+        14,
+        0,
+        -6,
+        91,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        164,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        37,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        59,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        117,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        19,
+        INVALID_HASH_ENTRY,
+        16,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        105,
+        INVALID_HASH_ENTRY,
+        18,
+        -47,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        104,
+        8,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        109,
+        INVALID_HASH_ENTRY,
+        4,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        100,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -53,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        85,
+        INVALID_HASH_ENTRY,
+        87,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        32,
+        0,
+        60,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        29,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -12,
+        104,
+        63,
+        INVALID_HASH_ENTRY,
+        113,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        28,
+        112,
+        59,
+        INVALID_HASH_ENTRY,
+        -5,
+        62,
+        INVALID_HASH_ENTRY,
+        50,
+        24,
+        44,
+        INVALID_HASH_ENTRY,
+        46,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        90,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        51,
+        -14,
+        83,
+        58,
+        INVALID_HASH_ENTRY,
+        40,
+        INVALID_HASH_ENTRY,
+        97,
+        0,
+        INVALID_HASH_ENTRY,
+        103,
+        22,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        69,
+        INVALID_HASH_ENTRY,
+        -61,
+        INVALID_HASH_ENTRY,
+        79,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        33,
+        INVALID_HASH_ENTRY,
+        52,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        45,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        87,
+        17,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        111,
+        -97,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        108,
+        43,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        86,
+        118,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -23,
+        66,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        89,
+        INVALID_HASH_ENTRY,
+        69,
+        INVALID_HASH_ENTRY,
+        41,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        75,
+        15,
+        -90,
+        5,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        9,
+        INVALID_HASH_ENTRY,
+        75,
+        INVALID_HASH_ENTRY,
+        48,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        68,
+        -9,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        11,
+        -31,
+        INVALID_HASH_ENTRY,
+        73,
+        INVALID_HASH_ENTRY,
+        119,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        110,
+        INVALID_HASH_ENTRY,
+        92,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+    };
+    uint32_t k1, k2;
+    uint64_t crc;
+    uint16_t ix;
+
+    crc = crc64i(UINT64_C(0x076259c3e291c26c), token);
+    k1 = ((uint32_t)crc & 0x1fe) + 0;
+    k2 = ((uint32_t)(crc >> 32) & 0x1fe) + 1;
+
+    ix = hashdata[k1] + hashdata[k2];
+    if (ix >= 120)
+        return PP_invalid;
+
+    if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix], token))
+        return PP_invalid;
+
+    return ix;
+}
+
+
+/* TASM compatibility preprocessor token hash */
+enum preproc_token pp_tasm_token_hash(const char *token)
+{
+    static const int16_t hashdata[32] = {
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        69,
+        0,
+        83,
+        32,
+        2,
+        0,
+        0,
+        77,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        79,
+        68,
+        INVALID_HASH_ENTRY,
+        63,
+        INVALID_HASH_ENTRY,
+        -65,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+    };
+    uint32_t k1, k2;
+    uint64_t crc;
+    uint16_t ix;
+
+    crc = crc64i(UINT64_C(0x076259c3e291c26c), token);
+    k1 = ((uint32_t)crc & 0x1e) + 0;
+    k2 = ((uint32_t)(crc >> 32) & 0x1e) + 1;
+
+    ix = hashdata[k1] + hashdata[k2];
+    if (ix >= 120)
+        return PP_invalid;
+
+    if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix]+1, token))
+        return PP_invalid;
+
+    return ix;
+}
diff --git a/vere/ext/nasm/asm/pptok.dat b/vere/ext/nasm/asm/pptok.dat
new file mode 100644
index 0000000..2114497
--- /dev/null
+++ b/vere/ext/nasm/asm/pptok.dat
@@ -0,0 +1,117 @@
+## --------------------------------------------------------------------------
+##   
+##   Copyright 1996-2019 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##     
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# A * at the end indicates a condition; the list of conditions are
+# on lines starting with *; the negatives are auto-generated
+#
+
+# Condition stems. %if MUST BE FIRST in this list.
+%if*
+%elif*
+
+# Condition tests.
+*
+*ctx
+*def
+*defalias
+*difi
+*empty
+*env
+*id
+*idn
+*idni
+*macro
+*num
+*str
+*token
+*usable
+*using
+
+# Directives with -i- versions for case insensitive
+%!assign
+%!defalias
+%!define
+%!defstr
+%!deftok
+%!macro
+%!pathsearch
+%!rmacro
+%!strcat
+%!strlen
+%!substr
+%!xdefine
+%un!macro
+
+# Other directives
+%aliases
+%arg
+%clear
+%depend
+%else
+%endif
+%endm
+%endmacro
+%endrep
+%error
+%exitmacro
+%exitrep
+%fatal
+%include
+%line
+%local
+%null
+%pop
+%pragma
+%push
+%rep
+%repl
+%require
+%rotate
+%stacksize
+%undef
+%undefalias
+%use
+%warning
+
+# These directives do not require % in TASM-compatible mode
+@arg
+@elif
+@else
+@endif
+@if
+@ifdef
+@ifdifi
+@ifndef
+@include
+@local
diff --git a/vere/ext/nasm/asm/pptok.h b/vere/ext/nasm/asm/pptok.h
new file mode 100644
index 0000000..aead8b5
--- /dev/null
+++ b/vere/ext/nasm/asm/pptok.h
@@ -0,0 +1,202 @@
+/* Automatically generated from ./asm/pptok.dat by ./asm/pptok.pl */
+/* Do not edit */
+
+enum preproc_token {
+    PP_IF                    =   0,
+    PP_IFCTX                 =   1,
+    PP_IFDEF                 =   2,
+    PP_IFDEFALIAS            =   3,
+    PP_IFDIFI                =   4,
+    PP_IFEMPTY               =   5,
+    PP_IFENV                 =   6,
+    PP_IFID                  =   7,
+    PP_IFIDN                 =   8,
+    PP_IFIDNI                =   9,
+    PP_IFMACRO               =  10,
+    PP_IFNUM                 =  11,
+    PP_IFSTR                 =  12,
+    PP_IFTOKEN               =  13,
+    PP_IFUSABLE              =  14,
+    PP_IFUSING               =  15,
+    PP_IFN                   =  16,
+    PP_IFNCTX                =  17,
+    PP_IFNDEF                =  18,
+    PP_IFNDEFALIAS           =  19,
+    PP_IFNDIFI               =  20,
+    PP_IFNEMPTY              =  21,
+    PP_IFNENV                =  22,
+    PP_IFNID                 =  23,
+    PP_IFNIDN                =  24,
+    PP_IFNIDNI               =  25,
+    PP_IFNMACRO              =  26,
+    PP_IFNNUM                =  27,
+    PP_IFNSTR                =  28,
+    PP_IFNTOKEN              =  29,
+    PP_IFNUSABLE             =  30,
+    PP_IFNUSING              =  31,
+    PP_ELIF                  =  32,
+    PP_ELIFCTX               =  33,
+    PP_ELIFDEF               =  34,
+    PP_ELIFDEFALIAS          =  35,
+    PP_ELIFDIFI              =  36,
+    PP_ELIFEMPTY             =  37,
+    PP_ELIFENV               =  38,
+    PP_ELIFID                =  39,
+    PP_ELIFIDN               =  40,
+    PP_ELIFIDNI              =  41,
+    PP_ELIFMACRO             =  42,
+    PP_ELIFNUM               =  43,
+    PP_ELIFSTR               =  44,
+    PP_ELIFTOKEN             =  45,
+    PP_ELIFUSABLE            =  46,
+    PP_ELIFUSING             =  47,
+    PP_ELIFN                 =  48,
+    PP_ELIFNCTX              =  49,
+    PP_ELIFNDEF              =  50,
+    PP_ELIFNDEFALIAS         =  51,
+    PP_ELIFNDIFI             =  52,
+    PP_ELIFNEMPTY            =  53,
+    PP_ELIFNENV              =  54,
+    PP_ELIFNID               =  55,
+    PP_ELIFNIDN              =  56,
+    PP_ELIFNIDNI             =  57,
+    PP_ELIFNMACRO            =  58,
+    PP_ELIFNNUM              =  59,
+    PP_ELIFNSTR              =  60,
+    PP_ELIFNTOKEN            =  61,
+    PP_ELIFNUSABLE           =  62,
+    PP_ELIFNUSING            =  63,
+    PP_ALIASES               =  64,
+    PP_ARG                   =  65,
+    PP_CLEAR                 =  66,
+    PP_DEPEND                =  67,
+    PP_ELSE                  =  68,
+    PP_ENDIF                 =  69,
+    PP_ENDM                  =  70,
+    PP_ENDMACRO              =  71,
+    PP_ENDREP                =  72,
+    PP_ERROR                 =  73,
+    PP_EXITMACRO             =  74,
+    PP_EXITREP               =  75,
+    PP_FATAL                 =  76,
+    PP_INCLUDE               =  77,
+    PP_LINE                  =  78,
+    PP_LOCAL                 =  79,
+    PP_NULL                  =  80,
+    PP_POP                   =  81,
+    PP_PRAGMA                =  82,
+    PP_PUSH                  =  83,
+    PP_REP                   =  84,
+    PP_REPL                  =  85,
+    PP_REQUIRE               =  86,
+    PP_ROTATE                =  87,
+    PP_STACKSIZE             =  88,
+    PP_UNDEF                 =  89,
+    PP_UNDEFALIAS            =  90,
+    PP_USE                   =  91,
+    PP_WARNING               =  92,
+    PP_CASE_PAD              =  93,
+    PP_ASSIGN                =  94,
+    PP_IASSIGN               =  95,
+    PP_DEFALIAS              =  96,
+    PP_IDEFALIAS             =  97,
+    PP_DEFINE                =  98,
+    PP_IDEFINE               =  99,
+    PP_DEFSTR                = 100,
+    PP_IDEFSTR               = 101,
+    PP_DEFTOK                = 102,
+    PP_IDEFTOK               = 103,
+    PP_MACRO                 = 104,
+    PP_IMACRO                = 105,
+    PP_PATHSEARCH            = 106,
+    PP_IPATHSEARCH           = 107,
+    PP_RMACRO                = 108,
+    PP_IRMACRO               = 109,
+    PP_STRCAT                = 110,
+    PP_ISTRCAT               = 111,
+    PP_STRLEN                = 112,
+    PP_ISTRLEN               = 113,
+    PP_SUBSTR                = 114,
+    PP_ISUBSTR               = 115,
+    PP_XDEFINE               = 116,
+    PP_IXDEFINE              = 117,
+    PP_UNMACRO               = 118,
+    PP_UNIMACRO              = 119,
+    PP_count                 = 120,
+    PP_invalid               =  -1
+};
+
+#define PP_COND(x)     ((x) & 0xf)
+#define PP_IS_COND(x)  ((unsigned int)(x) < PP_ALIASES)
+#define PP_COND_NEGATIVE(x) (!!((x) & 0x10))
+
+#define PP_HAS_CASE(x) ((x) >= PP_ASSIGN)
+#define PP_INSENSITIVE(x) ((x) & 1)
+#define PP_TOKLEN_MAX 14
+
+#define CASE_PP_IF \
+	case PP_IF:\
+	case PP_IFCTX:\
+	case PP_IFDEF:\
+	case PP_IFDEFALIAS:\
+	case PP_IFDIFI:\
+	case PP_IFEMPTY:\
+	case PP_IFENV:\
+	case PP_IFID:\
+	case PP_IFIDN:\
+	case PP_IFIDNI:\
+	case PP_IFMACRO:\
+	case PP_IFNUM:\
+	case PP_IFSTR:\
+	case PP_IFTOKEN:\
+	case PP_IFUSABLE:\
+	case PP_IFUSING:\
+	case PP_IFN:\
+	case PP_IFNCTX:\
+	case PP_IFNDEF:\
+	case PP_IFNDEFALIAS:\
+	case PP_IFNDIFI:\
+	case PP_IFNEMPTY:\
+	case PP_IFNENV:\
+	case PP_IFNID:\
+	case PP_IFNIDN:\
+	case PP_IFNIDNI:\
+	case PP_IFNMACRO:\
+	case PP_IFNNUM:\
+	case PP_IFNSTR:\
+	case PP_IFNTOKEN:\
+	case PP_IFNUSABLE:\
+	case PP_IFNUSING
+#define CASE_PP_ELIF \
+	case PP_ELIF:\
+	case PP_ELIFCTX:\
+	case PP_ELIFDEF:\
+	case PP_ELIFDEFALIAS:\
+	case PP_ELIFDIFI:\
+	case PP_ELIFEMPTY:\
+	case PP_ELIFENV:\
+	case PP_ELIFID:\
+	case PP_ELIFIDN:\
+	case PP_ELIFIDNI:\
+	case PP_ELIFMACRO:\
+	case PP_ELIFNUM:\
+	case PP_ELIFSTR:\
+	case PP_ELIFTOKEN:\
+	case PP_ELIFUSABLE:\
+	case PP_ELIFUSING:\
+	case PP_ELIFN:\
+	case PP_ELIFNCTX:\
+	case PP_ELIFNDEF:\
+	case PP_ELIFNDEFALIAS:\
+	case PP_ELIFNDIFI:\
+	case PP_ELIFNEMPTY:\
+	case PP_ELIFNENV:\
+	case PP_ELIFNID:\
+	case PP_ELIFNIDN:\
+	case PP_ELIFNIDNI:\
+	case PP_ELIFNMACRO:\
+	case PP_ELIFNNUM:\
+	case PP_ELIFNSTR:\
+	case PP_ELIFNTOKEN:\
+	case PP_ELIFNUSABLE:\
+	case PP_ELIFNUSING
diff --git a/vere/ext/nasm/asm/pptok.pl b/vere/ext/nasm/asm/pptok.pl
new file mode 100755
index 0000000..0b8ef25
--- /dev/null
+++ b/vere/ext/nasm/asm/pptok.pl
@@ -0,0 +1,353 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# Produce pptok.c, pptok.h and pptok.ph from pptok.dat
+#
+
+require 'phash.ph';
+
+my($what, $in, $out) = @ARGV;
+
+#
+# Read pptok.dat
+#
+open(IN, '<', $in) or die "$0: cannot open: $in\n";
+while (defined($line = <IN>)) {
+    $line =~ s/\r?\n$//;	# Remove trailing \r\n or \n
+    $line =~ s/^\s+//;		# Remove leading whitespace
+    $line =~ s/\s*\#.*$//;	# Remove comments and trailing whitespace
+    next if ($line eq '');
+
+    if ($line =~ /^\%(.*)\*$/) {
+	# Condition stem
+	push(@cctok, $1);
+    } elsif ($line =~ /^\%(.*\!.*)$/) {
+	# Directive with case insensitity "i" option
+	# Mnemonic: ! is "upside down i"
+	push(@ppitok, $1);
+    } elsif ($line =~ /^\%(.*)$/) {
+	# Other directive
+	push(@pptok, $1);
+    } elsif ($line =~ /^\*(.*)$/) {
+	# Condition tail
+	push(@cond, $1);
+    } elsif ($line =~ /^\@(.*)$/) {
+	# TASM compatibility directive
+	push(@tasm, $1);
+    }
+}
+close(IN);
+
+# Always sort %if first
+@cctok  = sort { $a eq 'if' ? -1 : $b eq 'if' ? 1 : $a cmp $b } @cctok;
+@cond   = sort @cond;
+@pptok  = sort @pptok;
+@ppitok = sort @ppitok;
+@tasm   = sort @tasm;
+
+# Generate the expanded list including conditionals.  The conditionals
+# are at the beginning, padded to a power of 2, with the inverses
+# following each group; this allows a simple mask to pick out the condition,
+# polarity, and directive type.
+
+while ((scalar @cond) & (scalar @cond)-1) {
+    push(@cond, sprintf("_COND_%d", scalar @cond));
+}
+
+@cptok = ();
+foreach $ct (@cctok) {
+    foreach $cc (@cond) {
+	push(@cptok, $ct.$cc);
+    }
+    foreach $cc (@cond) {
+	push(@cptok, $ct.'n'.$cc);
+    }
+}
+$first_uncond = scalar @cptok;
+@pptok = (@cptok, @pptok);
+
+# Generate the list of case-specific tokens; these are in pairs
+# with the -i- variant following the plain variant
+if (scalar(@pptok) & 1) {
+    push(@pptok, 'CASE_PAD');
+}
+
+$first_itoken = scalar @pptok;
+foreach $it (@ppitok) {
+    (my $at = $it) =~ s/\!//;
+    (my $bt = $it) =~ s/\!/i/;
+
+    push(@pptok, $at, $bt);
+}
+
+open(OUT, '>', $out) or die "$0: cannot open: $out\n";
+
+#
+# Output pptok.h
+#
+if ($what eq 'h') {
+    print OUT "/* Automatically generated from $in by $0 */\n";
+    print OUT "/* Do not edit */\n";
+    print OUT "\n";
+
+    print OUT "enum preproc_token {\n";
+    $n = 0;
+    my $maxlen = 0;
+    foreach $pt (@pptok) {
+	if (defined($pt)) {
+	    printf OUT "    %-24s = %3d,\n", "PP_\U$pt\E", $n;
+	    $maxlen = length($pt) if (length($pt) > $maxlen);
+	}
+	$n++;
+    }
+    printf OUT "    %-24s = %3d,\n", 'PP_count', $n;
+    printf OUT "    %-24s = %3d\n", 'PP_invalid', -1;
+    print OUT "};\n";
+    print OUT "\n";
+
+    printf OUT "#define PP_COND(x)     ((x) & 0x%x)\n",
+	(scalar(@cond)-1);
+    printf OUT "#define PP_IS_COND(x)  ((unsigned int)(x) < PP_%s)\n",
+	uc($pptok[$first_uncond]);
+    printf OUT "#define PP_COND_NEGATIVE(x) (!!((x) & 0x%x))\n", scalar(@cond);
+    print  OUT "\n";
+    printf OUT "#define PP_HAS_CASE(x) ((x) >= PP_%s)\n",
+	uc($pptok[$first_itoken]);
+    print  OUT "#define PP_INSENSITIVE(x) ((x) & 1)\n";
+    # The +1 here is for the initial % sign
+    printf OUT "#define PP_TOKLEN_MAX %d\n", $maxlen+1;
+    print  OUT "\n";
+
+    foreach $ct (@cctok) {
+	print OUT "#define CASE_PP_\U$ct\E";
+	$pref = " \\\n";
+	foreach $cc (@cond) {
+	    print OUT "$pref\tcase PP_\U${ct}${cc}\E";
+	    $pref = ":\\\n";
+	}
+	foreach $cc (@cond) {
+	    print OUT "$pref\tcase PP_\U${ct}N${cc}\E";
+	    $pref = ":\\\n";
+	}
+	print OUT "\n";		# No colon or newline on the last one
+    }
+}
+
+#
+# Output pptok.c
+#
+if ($what eq 'c') {
+    print OUT "/* Automatically generated from $in by $0 */\n";
+    print OUT "/* Do not edit */\n";
+    print OUT "\n";
+
+    print OUT "#include \"compiler.h\"\n";
+    print OUT "#include \"nctype.h\"\n";
+    print OUT "#include \"nasmlib.h\"\n";
+    print OUT "#include \"hashtbl.h\"\n";
+    print OUT "#include \"preproc.h\"\n";
+    print OUT "\n";
+
+    # Note that this is global.
+    printf OUT "const char * const pp_directives[%d] = {\n", scalar(@pptok);
+    foreach $d (@pptok) {
+	if (defined($d) && $d !~ /[A-Z]/) {
+	    print OUT "    \"%$d\",\n";
+	} else {
+	    print OUT "    NULL,\n";
+	}
+    }
+    print OUT  "};\n";
+
+    printf OUT "const uint8_t pp_directives_len[%d] = {\n", scalar(@pptok);
+    foreach $d (@pptok) {
+	printf OUT "    %d,\n", defined($d) ? length($d)+1 : 0;
+    }
+    print OUT  "};\n";
+
+    # Put a large value in unused hash slots.  This makes it extremely
+    # unlikely that any combination that involves unused slot will
+    # pass the range test.  This speeds up rejection of unrecognized
+    # tokens, i.e. identifiers.
+    print OUT "\n#define INVALID_HASH_ENTRY (65535/3)\n";
+
+    my %tokens = ();
+    my @tokendata = ();
+
+    my $n = 0;
+    foreach $pt (@pptok) {
+	# Upper case characters signify internal use tokens only
+	if (defined($pt) && $pt !~ /[A-Z]/) {
+	    $tokens{'%'.$pt} = $n;
+	    if ($pt =~ /[\@\[\]\\_]/) {
+		# Fail on characters which look like upper-case letters
+		# to the quick-and-dirty downcasing in the prehash
+		# (see below)
+		die "$in: invalid character in token: $pt";
+	    }
+	}
+	$n++;
+    }
+
+    my @hashinfo = gen_perfect_hash(\%tokens);
+    if (!@hashinfo) {
+	die "$0: no hash found\n";
+    }
+
+    # Paranoia...
+    verify_hash_table(\%tokens, \@hashinfo);
+
+    ($n, $sv, $g) = @hashinfo;
+    die if ($n & ($n-1));
+    $n <<= 1;
+
+
+    print OUT "\n\n/* Primary preprocessor token hash */\n\n";
+
+    print OUT "enum preproc_token pp_token_hash(const char *token)\n";
+    print OUT "{\n";
+    print OUT "    static const int16_t hashdata[$n] = {\n";
+    for ($i = 0; $i < $n; $i++) {
+	my $h = ${$g}[$i];
+	print OUT "        ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n";
+    }
+    print OUT "    };\n";
+    print OUT  "    uint32_t k1, k2;\n";
+    print OUT  "    uint64_t crc;\n";
+    # For correct overflow behavior, "ix" should be unsigned of the same
+    # width as the hash arrays.
+    print OUT  "    uint16_t ix;\n";
+    print OUT  "\n";
+
+    printf OUT "    crc = crc64i(UINT64_C(0x%08x%08x), token);\n",
+	$$sv[0], $$sv[1];
+    printf OUT "    k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2;
+    printf OUT "    k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2;
+    print  OUT "\n";
+    print  OUT "    ix = hashdata[k1] + hashdata[k2];\n";
+    printf OUT "    if (ix >= %d)\n", scalar(@pptok);
+    print OUT  "        return PP_invalid;\n";
+    print OUT  "\n";
+
+    print OUT  "    if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix], token))\n";
+    print OUT  "        return PP_invalid;\n";
+    print OUT  "\n";
+    print OUT  "    return ix;\n";
+    print OUT  "}\n";
+
+    my %tasmtokens = ();
+    foreach $pt (@tasm) {
+	# TASM compatibility token
+	$nasmt = '%'.$pt;
+	if (!defined($tokens{$nasmt})) {
+	    die "$in: TASM compat token $pt does not have a ".
+		"corresponding $nasmt\n";
+	}
+	$tasmtokens{$pt} = $tokens{$nasmt};
+    }
+
+    @hashinfo = gen_perfect_hash(\%tasmtokens);
+    if (!@hashinfo) {
+	die "$0: no hash found\n";
+    }
+
+    # Paranoia...
+    verify_hash_table(\%tasmtokens, \@hashinfo);
+
+    ($n, $sv, $g) = @hashinfo;
+    die if ($n & ($n-1));
+    $n <<= 1;
+
+    print OUT "\n\n/* TASM compatibility preprocessor token hash */\n";
+
+    print OUT "enum preproc_token pp_tasm_token_hash(const char *token)\n";
+    print OUT "{\n";
+    print OUT "    static const int16_t hashdata[$n] = {\n";
+    for ($i = 0; $i < $n; $i++) {
+	my $h = ${$g}[$i];
+	print OUT "        ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n";
+    }
+    print OUT "    };\n";
+    print OUT  "    uint32_t k1, k2;\n";
+    print OUT  "    uint64_t crc;\n";
+    # For correct overflow behavior, "ix" should be unsigned of the same
+    # width as the hash arrays.
+    print OUT  "    uint16_t ix;\n";
+    print OUT  "\n";
+
+    printf OUT "    crc = crc64i(UINT64_C(0x%08x%08x), token);\n",
+	$$sv[0], $$sv[1];
+    printf OUT "    k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2;
+    printf OUT "    k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2;
+    print  OUT "\n";
+    printf OUT "    ix = hashdata[k1] + hashdata[k2];\n", $n-1, $n-1;
+    # Comparing to pptok here is correct, because this hash produces
+    # an enum preproc_token value directly.
+    printf OUT "    if (ix >= %d)\n", scalar(@pptok);
+    print OUT  "        return PP_invalid;\n";
+    print OUT  "\n";
+
+    print OUT  "    if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix]+1, token))\n";
+    print OUT  "        return PP_invalid;\n";
+    print OUT  "\n";
+    print OUT  "    return ix;\n";
+    print OUT  "}\n";
+}
+
+#
+# Output pptok.ph
+#
+if ($what eq 'ph') {
+    print OUT "# Automatically generated from $in by $0\n";
+    print OUT "# Do not edit\n";
+
+    print OUT "\n\%pptok_hash = (\n";
+    $n = 0;
+    foreach $tok (@pptok) {
+	if (defined($tok)) {
+	    printf OUT "    '%%%s' => %d,\n", $tok, $n;
+	}
+	$n++;
+    }
+    print OUT ");\n";
+
+    print OUT "\n\@pptok_list = (\n";
+    foreach $tok (@pptok) {
+	print OUT "    ", (defined($tok) ? "'\%$tok'" : 'undef'), ",\n";
+    }
+    print OUT ");\n";
+
+    print OUT "\n1;\n";
+}
diff --git a/vere/ext/nasm/asm/pragma.c b/vere/ext/nasm/asm/pragma.c
new file mode 100644
index 0000000..0049c06
--- /dev/null
+++ b/vere/ext/nasm/asm/pragma.c
@@ -0,0 +1,369 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2019 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Parse and handle [pragma] directives.  The preprocessor handles
+ * %pragma preproc directives separately, all other namespaces are
+ * simply converted to [pragma].
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "assemble.h"
+#include "error.h"
+#include "listing.h"
+
+static enum directive_result ignore_pragma(const struct pragma *pragma);
+static enum directive_result output_pragma(const struct pragma *pragma);
+static enum directive_result debug_pragma(const struct pragma *pragma);
+static enum directive_result limit_pragma(const struct pragma *pragma);
+
+/*
+ * Handle [pragma] directives.  [pragma] is generally produced by
+ * the %pragma preprocessor directive, which simply passes on any
+ * string that it finds *except* %pragma preproc.  The idea is
+ * that pragmas are of the form:
+ *
+ * %pragma <facility> <opname> [<options>...]
+ *
+ * ... where "facility" can be either a generic facility or a backend
+ * name.
+ *
+ * The following names are currently reserved for global facilities;
+ * so far none of these have any defined pragmas at all:
+ *
+ * preproc	- preprocessor
+ * limit	- limit setting
+ * asm		- assembler
+ * list		- listing generator
+ * file		- generic file handling
+ * input	- input file handling
+ * output	- backend-independent output handling
+ * debug	- backend-independent debug handling
+ * ignore	- dummy pragma (can be used to "comment out")
+ *
+ * This function should generally not error out if it doesn't understand
+ * what a pragma is for, for unknown arguments, etc; the whole point of
+ * a pragma is that future releases might add new ones that should be
+ * ignored rather than be an error.  Erroring out is acceptable for
+ * known pragmas suffering from parsing errors and so on.
+ *
+ * Adding default-suppressed warnings would, however, be a good idea
+ * at some point.
+ */
+static struct pragma_facility global_pragmas[] =
+{
+    { "asm",		NULL },
+    { "limit",          limit_pragma },
+    { "list",		list_pragma },
+    { "file",		NULL },
+    { "input",		NULL },
+    { "output",		output_pragma },
+    { "debug",	        debug_pragma },
+    { "ignore",		ignore_pragma },
+
+    /* This will never actually get this far... */
+    { "preproc",	NULL }, /* Handled in the preprocessor by necessity */
+    { NULL, NULL }
+};
+
+/*
+ * Invoke a pragma handler
+ */
+static enum directive_result
+call_pragma(const struct pragma_facility *pf, struct pragma *pragma)
+{
+    if (!pf || !pf->handler)
+        return DIRR_UNKNOWN;
+
+    pragma->facility = pf;
+    return pf->handler(pragma);
+}
+
+/*
+ * Search a pragma list for a known pragma facility and if so, invoke
+ * the handler.  Return true if processing is complete.  The "default
+ * name", *or def->name*, if set, matches the final NULL entry (used
+ * for backends, so multiple backends can share the same list under
+ * some circumstances, and the backends can implement common operations.)
+ */
+static enum directive_result
+search_pragma_list(const struct pragma_facility *list,
+                   const char *defaultname,
+                   const struct pragma_facility *def,
+                   const struct pragma *cpragma)
+{
+    const struct pragma_facility *pf = NULL;
+    enum directive_result rv;
+    bool facility_match, is_default;
+    struct pragma pragma = *cpragma;
+    const char *facname = pragma.facility_name;
+
+    /* Is there a default facility and we match its name? */
+    is_default = def && def->name && !nasm_stricmp(facname, def->name);
+    facility_match = is_default;
+
+    /*
+     * Promote def->name to defaultname if both are set. This handles
+     * e.g. output -> elf32 so that we can handle elf32-specific
+     * directives in that handler.
+     */
+    if (defaultname) {
+        if (is_default)
+            facname = defaultname;
+        else
+            facility_match = !nasm_stricmp(facname, defaultname);
+    }
+
+    if (facname && list) {
+        for (pf = list; pf->name; pf++) {
+            if (!nasm_stricmp(facname, pf->name)) {
+                facility_match = true;
+                rv = call_pragma(pf, &pragma);
+                if (rv != DIRR_UNKNOWN)
+                    goto found_it;
+            }
+        }
+
+        if (facility_match) {
+            /*
+             * Facility name match but no matching directive; handler in NULL
+             * entry at end of list?
+             */
+            rv = call_pragma(pf, &pragma);
+            if (rv != DIRR_UNKNOWN)
+                goto found_it;
+        }
+    }
+
+    if (facility_match) {
+        /*
+         * Facility match but still nothing: def->handler if it exists
+         */
+        rv = call_pragma(def, &pragma);
+    } else {
+        /*
+         * No facility matched
+         */
+        return DIRR_UNKNOWN;
+    }
+
+    /*
+     * Otherwise we found the facility but not any supported directive,
+     * fall through...
+     */
+
+found_it:
+    switch (rv) {
+    case DIRR_UNKNOWN:
+        switch (pragma.opcode) {
+        case D_none:
+            /*!
+             *!pragma-bad [off] malformed %pragma
+             *!=bad-pragma
+             *!  warns about a malformed or otherwise unparsable
+             *!  \c{%pragma} directive.
+             */
+            nasm_warn(ERR_PASS2|WARN_PRAGMA_BAD,
+                       "empty %%pragma %s", pragma.facility_name);
+            break;
+        default:
+            /*!
+             *!pragma-unknown [off] unknown %pragma facility or directive
+             *!=unknown-pragma
+             *!  warns about an unknown \c{%pragma} directive.
+             *!  This is not yet implemented for most cases.
+             */
+            nasm_warn(ERR_PASS2|WARN_PRAGMA_UNKNOWN,
+                       "unknown %%pragma %s %s",
+                       pragma.facility_name, pragma.opname);
+            break;
+        }
+        rv = DIRR_ERROR;        /* Already printed an error message */
+        break;
+
+    case DIRR_OK:
+    case DIRR_ERROR:
+        break;                  /* Nothing to do */
+
+    case DIRR_BADPARAM:
+        /*
+         * This one is an error.  Don't use it if forward compatibility
+         * would be compromised, as opposed to an inherent error.
+         */
+        nasm_error(ERR_NONFATAL, "bad argument to %%pragma %s %s",
+                   pragma.facility_name, pragma.opname);
+        break;
+
+    default:
+        panic();
+    }
+    return rv;
+}
+
+/* This warning message is intended for future use */
+/*!
+ *!pragma-na [off] %pragma not applicable to this compilation
+ *!=not-my-pragma
+ *!  warns about a \c{%pragma} directive which is not applicable to
+ *!  this particular assembly session.  This is not yet implemented.
+ */
+
+/* Naked %pragma */
+/*!
+ *!pragma-empty [off] empty %pragma directive
+ *!  warns about a \c{%pragma} directive containing nothing.
+ *!  This is treated identically to \c{%pragma ignore} except
+ *!  for this optional warning.
+ */
+void process_pragma(char *str)
+{
+    const struct pragma_facility *pf;
+    struct pragma pragma;
+    char *p;
+
+    nasm_zero(pragma);
+
+    pragma.facility_name = nasm_get_word(str, &p);
+    if (!pragma.facility_name) {
+        /* Empty %pragma */
+	nasm_warn(ERR_PASS2|WARN_PRAGMA_EMPTY,
+		   "empty %%pragma directive, ignored");
+        return;
+    }
+
+    pragma.opname = nasm_get_word(p, &p);
+    if (!pragma.opname)
+        pragma.opcode = D_none;
+    else
+        pragma.opcode = directive_find(pragma.opname);
+
+    pragma.tail = nasm_trim_spaces(p);
+
+    /*
+     * Search the global pragma namespaces. This is done
+     * as a loop rather than letting search_pragma_list()
+     * just run, because we don't want to keep searching if
+     * we have a facility match, thus we want to call
+     * search_pragma_list() individually for each namespace.
+     */
+    for (pf = global_pragmas; pf->name; pf++) {
+        if (search_pragma_list(NULL, NULL, pf, &pragma) != DIRR_UNKNOWN)
+            return;
+    }
+
+    /* Is it an output pragma? */
+    if (output_pragma(&pragma) != DIRR_UNKNOWN)
+        return;
+
+    /* Is it a debug pragma */
+    if (debug_pragma(&pragma) != DIRR_UNKNOWN)
+        return;
+
+    /*
+     * Note: it would be nice to warn for an unknown namespace,
+     * but in order to do so we need to walk *ALL* the backends
+     * in order to make sure we aren't dealing with a pragma that
+     * is for another backend.  On the other hand, that could
+     * also be a warning with a separate warning flag.
+     *
+     * Leave this for the future, however, the warning classes are
+     * already defined for future compatibility.
+     */
+}
+
+/* %pragma ignore */
+static enum directive_result ignore_pragma(const struct pragma *pragma)
+{
+    (void)pragma;
+    return DIRR_OK;             /* Even for D_none! */
+}
+
+/*
+ * Process output and debug pragmas, by either list name or generic
+ * name. Note that the output/debug format list can hook the default
+ * names if they so choose.
+ */
+static enum directive_result output_pragma_common(const struct pragma *);
+static enum directive_result output_pragma(const struct pragma *pragma)
+{
+    static const struct pragma_facility
+        output_pragma_def = { "output", output_pragma_common };
+
+    return search_pragma_list(ofmt->pragmas, ofmt->shortname,
+                              &output_pragma_def, pragma);
+}
+
+/* Generic pragmas that apply to all output backends */
+static enum directive_result output_pragma_common(const struct pragma *pragma)
+{
+    switch (pragma->opcode) {
+    case D_PREFIX:
+    case D_GPREFIX:
+        set_label_mangle(LM_GPREFIX, pragma->tail);
+        return DIRR_OK;
+    case D_SUFFIX:
+    case D_GSUFFIX:
+        set_label_mangle(LM_GSUFFIX, pragma->tail);
+        return DIRR_OK;
+    case D_LPREFIX:
+        set_label_mangle(LM_LPREFIX, pragma->tail);
+        return DIRR_OK;
+    case D_LSUFFIX:
+        set_label_mangle(LM_LSUFFIX, pragma->tail);
+        return DIRR_OK;
+    default:
+        return DIRR_UNKNOWN;
+    }
+}
+
+static enum directive_result debug_pragma(const struct pragma *pragma)
+{
+    static const struct pragma_facility
+        debug_pragma_def = { "debug", NULL };
+
+    return search_pragma_list(dfmt->pragmas, dfmt->shortname,
+                              &debug_pragma_def, pragma);
+}
+
+/*
+ * %pragma limit to set resource limits
+ */
+static enum directive_result limit_pragma(const struct pragma *pragma)
+{
+    return nasm_set_limit(pragma->opname, pragma->tail);
+}
diff --git a/vere/ext/nasm/asm/preproc.c b/vere/ext/nasm/asm/preproc.c
new file mode 100644
index 0000000..ac42131
--- /dev/null
+++ b/vere/ext/nasm/asm/preproc.c
@@ -0,0 +1,8070 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * preproc.c   macro preprocessor for the Netwide Assembler
+ */
+
+/* Typical flow of text through preproc
+ *
+ * pp_getline gets tokenized lines, either
+ *
+ *   from a macro expansion
+ *
+ * or
+ *   {
+ *   read_line  gets raw text from stdmacpos, or predef, or current input file
+ *   tokenize   converts to tokens
+ *   }
+ *
+ * expand_mmac_params is used to expand %1 etc., unless a macro is being
+ * defined or a false conditional is being processed
+ * (%0, %1, %+1, %-1, %%foo
+ *
+ * do_directive checks for directives
+ *
+ * expand_smacro is used to expand single line macros
+ *
+ * expand_mmacro is used to expand multi-line macros
+ *
+ * detoken is used to convert the line back to text
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "preproc.h"
+#include "hashtbl.h"
+#include "quote.h"
+#include "stdscan.h"
+#include "eval.h"
+#include "tokens.h"
+#include "tables.h"
+#include "listing.h"
+#include "dbginfo.h"
+
+/*
+ * Preprocessor execution options that can be controlled by %pragma or
+ * other directives.  This structure is initialized to zero on each
+ * pass; this *must* reflect the default initial state.
+ */
+static struct pp_config {
+    bool noaliases;
+    bool sane_empty_expansion;
+} ppconf;
+
+/*
+ * Preprocessor debug-related flags
+ */
+static enum pp_debug_flags {
+    PDBG_MMACROS      = 1,      /* Collect mmacro information */
+    PDBG_SMACROS      = 2,      /* Collect smacro information */
+    PDBG_LIST_SMACROS = 4,      /* Smacros to list file (list option 's') */
+    PDBG_INCLUDE      = 8       /* Collect %include information */
+} ppdbg;
+
+/*
+ * Preprocessor options configured on the command line
+ */
+static enum preproc_opt ppopt;
+
+typedef struct SMacro SMacro;
+typedef struct MMacro MMacro;
+typedef struct Context Context;
+typedef struct Token Token;
+typedef struct Line Line;
+typedef struct Include Include;
+typedef struct Cond Cond;
+
+/*
+ * Map of preprocessor directives that are also preprocessor functions;
+ * if they are at the beginning of a line they are a function if and
+ * only if they are followed by a (
+ */
+static bool pp_op_may_be_function[PP_count];
+
+/*
+ * This is the internal form which we break input lines up into.
+ * Typically stored in linked lists.
+ *
+ * Note that `type' serves a double meaning: TOKEN_SMAC_START_PARAMS is
+ * not necessarily used as-is, but is also used to encode the number
+ * and expansion type of substituted parameter. So in the definition
+ *
+ *     %define a(x,=y) ( (x) & ~(y) )
+ *
+ * the token representing `x' will have its type changed to
+ * tok_smac_param(0) but the one representing `y' will be
+ * tok_smac_param(1); see the accessor functions below.
+ *
+ * TOKEN_INTERNAL_STR is a string which has been unquoted, but should
+ * be treated as if it was a quoted string. The code is free to change
+ * one into the other at will. TOKEN_NAKED_STR is a text token which
+ * should be treated as a string, but which MUST NOT be turned into a
+ * quoted string. TOKEN_INTERNAL_STRs can contain any character,
+ * including NUL, but TOKEN_NAKED_STR must be a valid C string.
+ */
+
+static inline enum token_type tok_smac_param(int param)
+{
+    return TOKEN_SMAC_START_PARAMS + param;
+}
+static int smac_nparam(enum token_type toktype)
+{
+    return toktype - TOKEN_SMAC_START_PARAMS;
+}
+static bool is_smac_param(enum token_type toktype)
+{
+    return toktype >= TOKEN_SMAC_START_PARAMS;
+}
+
+/*
+ * This is tuned so struct Token should be 64 bytes on 64-bit
+ * systems and 32 bytes on 32-bit systems. It enables them
+ * to be nicely cache aligned, and the text to still be kept
+ * inline for nearly all tokens.
+ *
+ * We prohibit tokens of length > MAX_TEXT even though
+ * length here is an unsigned int; this avoids problems
+ * if the length is passed through an interface with type "int",
+ * and is absurdly large anyway.
+ *
+ * Earlier versions of the source code incorrectly stated that
+ * examining the text string alone can be unconditionally valid. This
+ * is incorrect, as some token types strip parts of the string,
+ * e.g. indirect tokens.
+ */
+#define INLINE_TEXT (7*sizeof(char *)-sizeof(enum token_type)-sizeof(unsigned int)-1)
+#define MAX_TEXT (INT_MAX-2)
+
+struct Token {
+    Token *next;
+    enum token_type type;
+    unsigned int len;
+    union {
+        char a[INLINE_TEXT+1];
+        struct {
+            char pad[INLINE_TEXT+1 - sizeof(char *)];
+            char *ptr;
+        } p;
+    } text;
+};
+
+/*
+ * Note on the storage of both SMacro and MMacros: the hash table
+ * indexes them case-insensitively, and we then have to go through a
+ * linked list of potential case aliases (and, for MMacros, parameter
+ * ranges); this is to preserve the matching semantics of the earlier
+ * code.  If the number of case aliases for a specific macro is a
+ * performance issue, you may want to reconsider your coding style.
+ */
+
+/*
+ * Function call tp obtain the expansion of an smacro
+ */
+typedef Token *(*ExpandSMacro)(const SMacro *s, Token **params, int nparams);
+
+/*
+ * Store the definition of a single-line macro.
+ *
+ * Note: for user-defined macros, SPARM_VARADIC and SPARM_DEFAULT are
+ * currently never set, and SPARM_OPTIONAL is set if and only
+ * if SPARM_GREEDY is set.
+ */
+enum sparmflags {
+    SPARM_PLAIN     =  0,
+    SPARM_EVAL      =  1,   /* Evaluate as a numeric expression (=) */
+    SPARM_STR       =  2,   /* Convert to quoted string ($) */
+    SPARM_NOSTRIP   =  4,   /* Don't strip braces (!) */
+    SPARM_GREEDY    =  8,   /* Greedy final parameter (+) */
+    SPARM_VARADIC   = 16,   /* Any number of separate arguments */
+    SPARM_OPTIONAL  = 32,   /* Optional argument */
+    SPARM_CONDQUOTE = 64    /* With SPARM_STR, don't re-quote a string */
+};
+
+struct smac_param {
+    Token name;
+    enum sparmflags flags;
+    const Token *def;           /* Default, if any */
+};
+
+struct SMacro {
+    SMacro *next;               /* MUST BE FIRST - see free_smacro() */
+    char *name;
+    Token *expansion;
+    ExpandSMacro expand;
+    intorptr expandpvt;
+    struct smac_param *params;
+    int nparam;                 /* length of the params structure */
+    int nparam_min;             /* allows < nparam arguments */
+    int in_progress;
+    bool recursive;
+    bool varadic;               /* greedy or supports > nparam arguments */
+    bool casesense;
+    bool alias;                 /* This is an alias macro */
+};
+
+/*
+ * "No listing" flags. Inside a loop (%rep..%endrep) we may have
+ * macro listing suppressed with .nolist, but we still need to
+ * update line numbers for error messages and debug information...
+ * unless we are nested inside an actual .nolist macro.
+ */
+enum nolist_flags {
+    NL_LIST   = 1,              /* Suppress list output */
+    NL_LINE   = 2               /* Don't update line information */
+};
+
+/*
+ * Store the definition of a multi-line macro. This is also used to
+ * store the interiors of `%rep...%endrep' blocks, which are
+ * effectively self-re-invoking multi-line macros which simply
+ * don't have a name or bother to appear in the hash tables. %rep
+ * blocks are signified by having a NULL `name' field.
+ *
+ * In a MMacro describing a `%rep' block, the `in_progress' field
+ * isn't merely boolean, but gives the number of repeats left to
+ * run.
+ *
+ * The `next' field is used for storing MMacros in hash tables; the
+ * `next_active' field is for stacking them on istk entries.
+ *
+ * When a MMacro is being expanded, `params', `iline', `nparam',
+ * `paramlen', `rotate' and `unique' are local to the invocation.
+ */
+
+/*
+ * Expansion stack. Note that .mmac can point back to the macro itself,
+ * whereas .mstk cannot.
+ */
+struct mstk {
+    MMacro *mstk;               /* Any expansion, real macro or not */
+    MMacro *mmac;               /* Highest level actual mmacro */
+};
+
+struct MMacro {
+    MMacro *next;
+#if 0
+    MMacroInvocation *prev;     /* previous invocation */
+#endif
+    char *name;
+    int nparam_min, nparam_max;
+    enum nolist_flags nolist;   /* is this macro listing-inhibited? */
+    bool casesense;
+    bool plus;                  /* is the last parameter greedy? */
+    bool capture_label;         /* macro definition has %00; capture label */
+    int32_t in_progress;        /* is this macro currently being expanded? */
+    int32_t max_depth;          /* maximum number of recursive expansions allowed */
+    Token *dlist;               /* All defaults as one list */
+    Token **defaults;           /* Parameter default pointers */
+    int ndefs;                  /* number of default parameters */
+    Line *expansion;
+
+    struct mstk mstk;           /* Macro expansion stack */
+    struct mstk dstk;           /* Macro definitions stack */
+    Token **params;             /* actual parameters */
+    Token *iline;               /* invocation line */
+    struct src_location where;  /* location of definition */
+    unsigned int nparam, rotate;
+    char *iname;                /* name invoked as */
+    int *paramlen;
+    uint64_t unique;
+    uint64_t condcnt;           /* number of if blocks... */
+    struct {                    /* Debug information */
+        struct debug_macro_def *def; /* Definition */
+        struct debug_macro_inv *inv; /* Current invocation (if any) */
+    } dbg;
+};
+
+
+/* Store the definition of a multi-line macro, as defined in a
+ * previous recursive macro expansion.
+ */
+#if 0
+
+struct MMacroInvocation {
+    MMacroInvocation *prev;     /* previous invocation */
+    Token **params;             /* actual parameters */
+    Token *iline;               /* invocation line */
+    unsigned int nparam, rotate;
+    int *paramlen;
+    uint64_t unique;
+    uint64_t condcnt;
+};
+
+#endif
+
+/*
+ * The context stack is composed of a linked list of these.
+ */
+struct Context {
+    Context *next;
+    const char *name;
+    struct hash_table localmac;
+    uint64_t number;
+    unsigned int depth;
+};
+
+
+static inline const char *tok_text(const struct Token *t)
+{
+    return (t->len <= INLINE_TEXT) ? t->text.a : t->text.p.ptr;
+}
+
+/*
+ * Returns a mutable pointer to the text buffer. The text can be changed,
+ * but the length MUST NOT CHANGE, in either direction; nor is it permitted
+ * to pad with null characters to create an artificially shorter string.
+ */
+static inline char *tok_text_buf(struct Token *t)
+{
+    return (t->len <= INLINE_TEXT) ? t->text.a : t->text.p.ptr;
+}
+
+static inline unsigned int tok_check_len(size_t len)
+{
+    if (unlikely(len > MAX_TEXT))
+	nasm_fatal("impossibly large token");
+
+    return len;
+}
+
+static inline bool tok_text_match(const struct Token *a, const struct Token *b)
+{
+    return a->len == b->len && !memcmp(tok_text(a), tok_text(b), a->len);
+}
+
+static inline unused_func bool
+tok_match(const struct Token *a, const struct Token *b)
+{
+    return a->type == b->type && tok_text_match(a, b);
+}
+
+/* strlen() variant useful for set_text() and its variants */
+static size_t tok_strlen(const char *str)
+{
+    return strnlen(str, MAX_TEXT+1);
+}
+
+/*
+ * Set the text field to a copy of the given string; the length if
+ * not given should be obtained with tok_strlen().
+ */
+static Token *set_text(struct Token *t, const char *text, size_t len)
+{
+    char *textp;
+
+    if (t->len > INLINE_TEXT)
+	nasm_free(t->text.p.ptr);
+
+    nasm_zero(t->text);
+
+    t->len = len = tok_check_len(len);
+    textp = (len > INLINE_TEXT)
+	? (t->text.p.ptr = nasm_malloc(len+1)) : t->text.a;
+    memcpy(textp, text, len);
+    textp[len] = '\0';
+    return t;
+}
+
+/*
+ * Set the text field to the existing pre-allocated string, either
+ * taking over or freeing the allocation in the process.
+ */
+static Token *set_text_free(struct Token *t, char *text, unsigned int len)
+{
+    char *textp;
+
+    if (t->len > INLINE_TEXT)
+	nasm_free(t->text.p.ptr);
+
+    nasm_zero(t->text);
+
+    t->len = len = tok_check_len(len);
+    if (len > INLINE_TEXT) {
+	textp = t->text.p.ptr = text;
+    } else {
+	textp = memcpy(t->text.a, text, len);
+	nasm_free(text);
+    }
+    textp[len] = '\0';
+
+    return t;
+}
+
+/*
+ * Allocate a new buffer containing a copy of the text field
+ * of the token.
+ */
+static char *dup_text(const struct Token *t)
+{
+    size_t size = t->len + 1;
+    char *p = nasm_malloc(size);
+
+    return memcpy(p, tok_text(t), size);
+}
+
+/*
+ * Multi-line macro definitions are stored as a linked list of
+ * these, which is essentially a container to allow several linked
+ * lists of Tokens.
+ *
+ * Note that in this module, linked lists are treated as stacks
+ * wherever possible. For this reason, Lines are _pushed_ on to the
+ * `expansion' field in MMacro structures, so that the linked list,
+ * if walked, would give the macro lines in reverse order; this
+ * means that we can walk the list when expanding a macro, and thus
+ * push the lines on to the `expansion' field in _istk_ in reverse
+ * order (so that when popped back off they are in the right
+ * order). It may seem cockeyed, and it relies on my design having
+ * an even number of steps in, but it works...
+ *
+ * Some of these structures, rather than being actual lines, are
+ * markers delimiting the end of the expansion of a given macro.
+ * This is for use in the cycle-tracking and %rep-handling code.
+ * Such structures have `finishes' non-NULL, and `first' NULL. All
+ * others have `finishes' NULL, but `first' may still be NULL if
+ * the line is blank.
+ */
+struct Line {
+    Line *next;
+    MMacro *finishes;
+    Token *first;
+    struct src_location where;      /* Where defined */
+};
+
+/*
+ * To handle an arbitrary level of file inclusion, we maintain a
+ * stack (ie linked list) of these things.
+ *
+ * Note: when we issue a message for a continuation line, we want to
+ * issue it for the actual *start* of the continuation line. This means
+ * we need to remember how many lines to skip over for the next one.
+ */
+struct Include {
+    Include *next;
+    FILE *fp;
+    Cond *conds;
+    Line *expansion;
+    uint64_t nolist;            /* Listing inhibit counter */
+    uint64_t noline;            /* Line number update inhibit counter */
+    struct mstk mstk;
+    struct src_location where;  /* Filename and current line number */
+    int32_t lineinc;            /* Increment given by %line */
+    int32_t lineskip;           /* Accounting for passed continuation lines */
+};
+
+/*
+ * File real name hash, so we don't have to re-search the include
+ * path for every pass (and potentially more than that if a file
+ * is used more than once.)
+ */
+struct hash_table FileHash;
+
+/*
+ * Counters to trap on insane macro recursion or processing.
+ * Note: for smacros these count *down*, for mmacros they count *up*.
+ */
+struct deadman {
+    int64_t total;              /* Total number of macros/tokens */
+    int64_t levels;             /* Descent depth across all macros */
+    bool triggered;             /* Already triggered, no need for error msg */
+};
+
+static struct deadman smacro_deadman, mmacro_deadman;
+
+/*
+ * Conditional assembly: we maintain a separate stack of these for
+ * each level of file inclusion. (The only reason we keep the
+ * stacks separate is to ensure that a stray `%endif' in a file
+ * included from within the true branch of a `%if' won't terminate
+ * it and cause confusion: instead, rightly, it'll cause an error.)
+ */
+enum cond_state {
+    /*
+     * These states are for use just after %if or %elif: IF_TRUE
+     * means the condition has evaluated to truth so we are
+     * currently emitting, whereas IF_FALSE means we are not
+     * currently emitting but will start doing so if a %else comes
+     * up. In these states, all directives are admissible: %elif,
+     * %else and %endif. (And of course %if.)
+     */
+    COND_IF_TRUE, COND_IF_FALSE,
+    /*
+     * These states come up after a %else: ELSE_TRUE means we're
+     * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
+     * any %elif or %else will cause an error.
+     */
+    COND_ELSE_TRUE, COND_ELSE_FALSE,
+    /*
+     * These states mean that we're not emitting now, and also that
+     * nothing until %endif will be emitted at all. COND_DONE is
+     * used when we've had our moment of emission
+     * and have now started seeing %elifs. COND_NEVER is used when
+     * the condition construct in question is contained within a
+     * non-emitting branch of a larger condition construct,
+     * or if there is an error.
+     */
+    COND_DONE, COND_NEVER
+};
+struct Cond {
+    Cond *next;
+    enum cond_state state;
+};
+#define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
+
+/*
+ * These defines are used as the possible return values for do_directive
+ */
+#define NO_DIRECTIVE_FOUND  0
+#define DIRECTIVE_FOUND     1
+
+/*
+ * Condition codes. Note that we use c_ prefix not C_ because C_ is
+ * used in nasm.h for the "real" condition codes. At _this_ level,
+ * we treat CXZ and ECXZ as condition codes, albeit non-invertible
+ * ones, so we need a different enum...
+ */
+static const char * const conditions[] = {
+    "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
+    "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
+    "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
+};
+enum pp_conds {
+    c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
+    c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
+    c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_RCXZ, c_S, c_Z,
+    c_none = -1
+};
+static const enum pp_conds inverse_ccs[] = {
+    c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
+    c_A, c_AE, c_B, c_BE, c_C, c_E, c_G, c_GE, c_L, c_LE, c_O, c_P, c_S,
+    c_Z, c_NO, c_NP, c_PO, c_PE, -1, c_NS, c_NZ
+};
+
+/*
+ * Directive names.
+ */
+/* If this is a an IF, ELIF, ELSE or ENDIF keyword */
+static int is_condition(enum preproc_token arg)
+{
+    return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF);
+}
+
+static int StackSize = 4;
+static const char *StackPointer = "ebp";
+static int ArgOffset = 8;
+static int LocalOffset = 0;
+
+static Context *cstk;
+static Include *istk;
+static const struct strlist *ipath_list;
+
+static struct strlist *deplist;
+
+static uint64_t unique;     /* unique identifier numbers */
+
+static Line *predef = NULL;
+static bool do_predef;
+static enum preproc_mode pp_mode;
+
+/*
+ * The current set of multi-line macros we have defined.
+ */
+static struct hash_table mmacros;
+
+/*
+ * The current set of single-line macros we have defined.
+ */
+static struct hash_table smacros;
+
+/*
+ * The multi-line macro we are currently defining, or the %rep
+ * block we are currently reading, if any.
+ */
+static MMacro *defining;
+
+static uint64_t nested_mac_count;
+static uint64_t nested_rep_count;
+
+/*
+ * The number of macro parameters to allocate space for at a time.
+ */
+#define PARAM_DELTA 16
+
+/*
+ * The standard macro set: defined in macros.c in a set of arrays.
+ * This gives our position in any macro set, while we are processing it.
+ * The stdmacset is an array of such macro sets.
+ */
+static macros_t *stdmacpos;
+static macros_t **stdmacnext;
+static macros_t *stdmacros[8];
+static macros_t *extrastdmac;
+
+/*
+ * Map of which %use packages have been loaded
+ */
+static bool *use_loaded;
+
+/*
+ * Forward declarations.
+ */
+static void pp_add_stdmac(macros_t *macros);
+static Token *expand_mmac_params(Token * tline);
+static Token *expand_smacro(Token * tline);
+static Token *expand_id(Token * tline);
+static Context *get_ctx(const char *name, const char **namep);
+static Token *make_tok_num(Token *next, int64_t val);
+static int64_t get_tok_num(const Token *t, bool *err);
+static Token *make_tok_qstr(Token *next, const char *str);
+static Token *make_tok_qstr_len(Token *next, const char *str, size_t len);
+static Token *make_tok_char(Token *next, char op);
+static Token *new_Token(Token * next, enum token_type type,
+                        const char *text, size_t txtlen);
+static Token *new_Token_free(Token * next, enum token_type type,
+                             char *text, size_t txtlen);
+static Token *dup_Token(Token *next, const Token *src);
+static Token *new_White(Token *next);
+static Token *delete_Token(Token *t);
+static Token *steal_Token(Token *dst, Token *src);
+static const struct use_package *
+get_use_pkg(Token *t, const char *dname, const char **name);
+static void mark_smac_params(Token *tline, const SMacro *tmpl,
+                             enum token_type type);
+
+/* Safe extraction of token type */
+static inline enum token_type tok_type(const Token *x)
+{
+    return x ? x->type : TOKEN_EOS;
+}
+
+/* Safe test for token type, false on x == NULL */
+static inline bool tok_is(const Token *x, enum token_type t)
+{
+    return tok_type(x) == t;
+}
+/* True if token is any other kind other that "c", but not NULL */
+static inline bool tok_isnt(const Token *x, enum token_type t)
+{
+    return x && x->type != t;
+}
+
+/* Whitespace token? */
+static inline bool tok_white(const Token *x)
+{
+    return tok_is(x, TOKEN_WHITESPACE);
+}
+
+/* Skip past any whitespace */
+static inline Token *skip_white(Token *x)
+{
+    while (tok_white(x))
+        x = x->next;
+
+    return x;
+}
+
+/* Delete any whitespace */
+static Token *zap_white(Token *x)
+{
+    while (tok_white(x))
+        x = delete_Token(x);
+
+    return x;
+}
+
+/*
+ * Unquote a token if it is a string, and set its type to
+ * TOKEN_INTERNAL_STR.
+ */
+
+/*
+ * Common version for any kind of quoted string; see asm/quote.c for
+ * information about the arguments.
+ */
+static const char *unquote_token_anystr(Token *t, uint32_t badctl, char qstart)
+{
+    size_t nlen, olen;
+    char *p;
+
+    if (t->type != TOKEN_STR)
+	return tok_text(t);
+
+    olen = t->len;
+    p = (olen > INLINE_TEXT) ? t->text.p.ptr : t->text.a;
+    t->len = nlen = nasm_unquote_anystr(p, NULL, badctl, qstart);
+    t->type = TOKEN_INTERNAL_STR;
+
+    if (olen <= INLINE_TEXT || nlen > INLINE_TEXT)
+        return p;
+
+    nasm_zero(t->text.a);
+    memcpy(t->text.a, p, nlen);
+    nasm_free(p);
+    return t->text.a;
+}
+
+/* Unquote any string, can produce any arbitrary binary output */
+static const char *unquote_token(Token *t)
+{
+    return unquote_token_anystr(t, 0, STR_NASM);
+}
+
+/*
+ * Same as unquote_token(), but error out if the resulting string
+ * contains unacceptable control characters.
+ */
+static const char *unquote_token_cstr(Token *t)
+{
+    return unquote_token_anystr(t, BADCTL, STR_NASM);
+}
+
+/*
+ * Convert a TOKEN_INTERNAL_STR token to a quoted
+ * TOKEN_STR tokens.
+ */
+static Token *quote_any_token(Token *t);
+static inline unused_func
+Token *quote_token(Token *t)
+{
+    if (likely(!tok_is(t, TOKEN_INTERNAL_STR)))
+	return t;
+
+    return quote_any_token(t);
+}
+
+/*
+ * Convert *any* kind of token to a quoted
+ * TOKEN_STR token.
+ */
+static Token *quote_any_token(Token *t)
+{
+    size_t len = t->len;
+    char *p;
+
+    p = nasm_quote(tok_text(t), &len);
+    t->type = TOKEN_STR;
+    return set_text_free(t, p, len);
+}
+
+/*
+ * In-place reverse a list of tokens.
+ */
+static Token *reverse_tokens(Token *t)
+{
+    Token *prev = NULL;
+    Token *next;
+
+    while (t) {
+        next = t->next;
+        t->next = prev;
+        prev = t;
+        t = next;
+    }
+
+    return prev;
+}
+
+/*
+ * getenv() variant operating on an input token
+ */
+static const char *pp_getenv(const Token *t, bool warn)
+{
+    const char *txt = tok_text(t);
+    const char *v;
+    char *buf = NULL;
+    bool is_string = false;
+
+    if (!t)
+	return NULL;
+
+    switch (t->type) {
+    case TOKEN_ENVIRON:
+	txt += 2;		/* Skip leading %! */
+	is_string = nasm_isquote(*txt);
+	break;
+
+    case TOKEN_STR:
+	is_string = true;
+	break;
+
+    case TOKEN_INTERNAL_STR:
+    case TOKEN_NAKED_STR:
+    case TOKEN_ID:
+	is_string = false;
+	break;
+
+    default:
+	return NULL;
+    }
+
+    if (is_string) {
+	buf = nasm_strdup(txt);
+	nasm_unquote_cstr(buf, NULL);
+	txt = buf;
+    }
+
+    v = getenv(txt);
+    if (warn && !v) {
+	/*!
+	 *!pp-environment [on] nonexistent environment variable
+         *!=environment
+	 *!  warns if a nonexistent environment variable
+	 *!  is accessed using the \c{%!} preprocessor
+	 *!  construct (see \k{getenv}.)  Such environment
+	 *!  variables are treated as empty (with this
+	 *!  warning issued) starting in NASM 2.15;
+	 *!  earlier versions of NASM would treat this as
+	 *!  an error.
+	 */
+	nasm_warn(WARN_PP_ENVIRONMENT,
+                  "nonexistent environment variable `%s'", txt);
+	v = "";
+    }
+
+    if (buf)
+	nasm_free(buf);
+
+    return v;
+}
+
+/*
+ * Free a linked list of tokens.
+ */
+static void free_tlist(Token * list)
+{
+    while (list)
+        list = delete_Token(list);
+}
+
+/*
+ * Free a linked list of lines.
+ */
+static void free_llist(Line * list)
+{
+    Line *l, *tmp;
+    list_for_each_safe(l, tmp, list) {
+        free_tlist(l->first);
+        nasm_free(l);
+    }
+}
+
+/*
+ * Free an array of linked lists of tokens
+ */
+static void free_tlist_array(Token **array, size_t nlists)
+{
+    Token **listp = array;
+
+    if (!array)
+        return;
+
+    while (nlists--)
+        free_tlist(*listp++);
+
+    nasm_free(array);
+}
+
+/*
+ * Duplicate a linked list of tokens.
+ */
+static Token *dup_tlist(const Token *list, Token ***tailp)
+{
+    Token *newlist = NULL;
+    Token **tailpp = &newlist;
+    const Token *t;
+
+    list_for_each(t, list) {
+        Token *nt;
+        *tailpp = nt = dup_Token(NULL, t);
+        tailpp = &nt->next;
+    }
+
+    if (tailp) {
+        **tailp = newlist;
+        *tailp = tailpp;
+    }
+
+    return newlist;
+}
+
+/*
+ * Duplicate a linked list of tokens with a maximum count
+ */
+static Token *dup_tlistn(const Token *list, size_t cnt, Token ***tailp)
+{
+    Token *newlist = NULL;
+    Token **tailpp = &newlist;
+    const Token *t;
+
+    list_for_each(t, list) {
+        Token *nt;
+        if (!cnt--)
+            break;
+        *tailpp = nt = dup_Token(NULL, t);
+        tailpp = &nt->next;
+    }
+
+    if (tailp) {
+        **tailp = newlist;
+        if (newlist)
+            *tailp = tailpp;
+    }
+
+    return newlist;
+}
+
+/*
+ * Duplicate a linked list of tokens in reverse order
+ */
+static Token *dup_tlist_reverse(const Token *list, Token *tail)
+{
+    const Token *t;
+
+    list_for_each(t, list)
+        tail = dup_Token(tail, t);
+
+    return tail;
+}
+
+/*
+ * Append an existing tlist to a tail pointer and returns the
+ * updated tail pointer.
+ */
+static Token **steal_tlist(Token *tlist, Token **tailp)
+{
+    *tailp = tlist;
+
+    if (!tlist)
+        return tailp;
+
+    list_last(tlist, tlist);
+    return &tlist->next;
+}
+
+/*
+ * Free an MMacro
+ */
+static void free_mmacro(MMacro * m)
+{
+    nasm_free(m->name);
+    free_tlist(m->dlist);
+    nasm_free(m->defaults);
+    free_llist(m->expansion);
+    nasm_free(m);
+}
+
+/*
+ * Clear or free an SMacro
+ */
+static void free_smacro_members(SMacro *s)
+{
+    if (s->params) {
+        int i;
+        for (i = 0; i < s->nparam; i++) {
+	    if (s->params[i].name.len > INLINE_TEXT)
+		nasm_free(s->params[i].name.text.p.ptr);
+            if (s->params[i].def)
+                free_tlist((Token *)s->params[i].def);
+	}
+        nasm_free(s->params);
+    }
+    nasm_free(s->name);
+    free_tlist(s->expansion);
+}
+
+static void clear_smacro(SMacro *s)
+{
+    free_smacro_members(s);
+    /* Wipe everything except the next pointer */
+    memset(&s->name, 0, sizeof(*s) - offsetof(SMacro, name));
+}
+
+/*
+ * Free an SMacro
+ */
+static void free_smacro(SMacro *s)
+{
+    free_smacro_members(s);
+    nasm_free(s);
+}
+
+/*
+ * Free all currently defined macros, and free the hash tables if empty
+ */
+enum clear_what {
+    CLEAR_NONE      = 0,
+    CLEAR_DEFINE    = 1,         /* Clear smacros */
+    CLEAR_DEFALIAS  = 2,         /* Clear smacro aliases */
+    CLEAR_ALLDEFINE = CLEAR_DEFINE|CLEAR_DEFALIAS,
+    CLEAR_MMACRO    = 4,
+    CLEAR_ALL       = CLEAR_ALLDEFINE|CLEAR_MMACRO
+};
+
+static void clear_smacro_table(struct hash_table *smt, enum clear_what what)
+{
+    struct hash_iterator it;
+    const struct hash_node *np;
+    bool empty = true;
+
+    /*
+     * Walk the hash table and clear out anything we don't want
+     */
+    hash_for_each(smt, it, np) {
+        SMacro *tmp;
+        SMacro *s = np->data;
+        SMacro **head = (SMacro **)&np->data;
+
+        list_for_each_safe(s, tmp, s) {
+            if (what & ((enum clear_what)s->alias + 1)) {
+                *head = s->next;
+                free_smacro(s);
+            } else {
+                empty = false;
+            }
+        }
+    }
+
+    /*
+     * Free the hash table and keys if and only if it is now empty.
+     * Note: we cannot free keys even for an empty list above, as that
+     * mucks up the hash algorithm.
+     */
+    if (empty)
+        hash_free_all(smt, true);
+}
+
+static void free_smacro_table(struct hash_table *smt)
+{
+    clear_smacro_table(smt, CLEAR_ALLDEFINE);
+}
+
+static void free_mmacro_table(struct hash_table *mmt)
+{
+    struct hash_iterator it;
+    const struct hash_node *np;
+
+    hash_for_each(mmt, it, np) {
+        MMacro *tmp;
+        MMacro *m = np->data;
+        nasm_free((void *)np->key);
+        list_for_each_safe(m, tmp, m)
+            free_mmacro(m);
+    }
+    hash_free(mmt);
+}
+
+static void free_macros(void)
+{
+    free_smacro_table(&smacros);
+    free_mmacro_table(&mmacros);
+}
+
+/*
+ * Initialize the hash tables
+ */
+static void init_macros(void)
+{
+}
+
+/*
+ * Pop the context stack.
+ */
+static void ctx_pop(void)
+{
+    Context *c = cstk;
+
+    cstk = cstk->next;
+    free_smacro_table(&c->localmac);
+    nasm_free((char *)c->name);
+    nasm_free(c);
+}
+
+/*
+ * Search for a key in the hash index; adding it if necessary
+ * (in which case we initialize the data pointer to NULL.)
+ */
+static void **
+hash_findi_add(struct hash_table *hash, const char *str)
+{
+    struct hash_insert hi;
+    void **r;
+    char *strx;
+    size_t l = strlen(str) + 1;
+
+    r = hash_findib(hash, str, l, &hi);
+    if (r)
+        return r;
+
+    strx = nasm_malloc(l);  /* Use a more efficient allocator here? */
+    memcpy(strx, str, l);
+    return hash_add(&hi, strx, NULL);
+}
+
+/*
+ * Like hash_findi, but returns the data element rather than a pointer
+ * to it.  Used only when not adding a new element, hence no third
+ * argument.
+ */
+static void *
+hash_findix(struct hash_table *hash, const char *str)
+{
+    void **p;
+
+    p = hash_findi(hash, str, NULL);
+    return p ? *p : NULL;
+}
+
+/*
+ * read line from standard macros set,
+ * if there no more left -- return NULL
+ */
+static char *line_from_stdmac(void)
+{
+    unsigned char c;
+    const unsigned char *p = stdmacpos;
+    char *line, *q;
+    size_t len = 0;
+
+    if (!stdmacpos)
+        return NULL;
+
+    /*
+     * 32-126 is ASCII, 127 is end of line, 128-31 are directives
+     * (allowed to wrap around) corresponding to PP_* tokens 0-159.
+     */
+    while ((c = *p++) != 127) {
+        uint8_t ndir = c - 128;
+        if (ndir < 256-96)
+            len += pp_directives_len[ndir] + 1;
+        else
+            len++;
+    }
+
+    line = nasm_malloc(len + 1);
+    q = line;
+
+    while ((c = *stdmacpos++) != 127) {
+        uint8_t ndir = c - 128;
+        if (ndir < 256-96) {
+            memcpy(q, pp_directives[ndir], pp_directives_len[ndir]);
+            q += pp_directives_len[ndir];
+            *q++ = ' ';
+        } else {
+            *q++ = c;
+        }
+    }
+    stdmacpos = p;
+    *q = '\0';
+
+    if (*stdmacpos == 127) {
+        /* This was the last of this particular macro set */
+        stdmacpos = NULL;
+        if (*stdmacnext) {
+            stdmacpos = *stdmacnext++;
+        } else if (do_predef) {
+            Line *pd, *l;
+
+            /*
+             * Nasty hack: here we push the contents of
+             * `predef' on to the top-level expansion stack,
+             * since this is the most convenient way to
+             * implement the pre-include and pre-define
+             * features.
+             */
+            list_for_each(pd, predef) {
+                nasm_new(l);
+                l->next     = istk->expansion;
+                l->first    = dup_tlist(pd->first, NULL);
+                l->finishes = NULL;
+
+                istk->expansion = l;
+            }
+            do_predef = false;
+        }
+    }
+
+    return line;
+}
+
+/*
+ * Read a line from a file. Return NULL on end of file.
+ */
+static char *line_from_file(FILE *f)
+{
+    int c;
+    unsigned int size, next;
+    const unsigned int delta = 512;
+    const unsigned int pad = 8;
+    bool cont = false;
+    char *buffer, *p;
+
+    istk->where.lineno += istk->lineskip + istk->lineinc;
+    src_set_linnum(istk->where.lineno);
+    istk->lineskip = 0;
+
+    size = delta;
+    p = buffer = nasm_malloc(size);
+
+    do {
+        c = fgetc(f);
+
+        switch (c) {
+        case EOF:
+            if (p == buffer) {
+                nasm_free(buffer);
+                return NULL;
+            }
+            c = 0;
+            break;
+
+        case '\r':
+            next = fgetc(f);
+            if (next != '\n')
+                ungetc(next, f);
+            if (cont) {
+                cont = false;
+                continue;
+            }
+            c = 0;
+            break;
+
+        case '\n':
+            if (cont) {
+                cont = false;
+                continue;
+            }
+            c = 0;
+            break;
+
+        case 032:               /* ^Z = legacy MS-DOS end of file mark */
+            c = 0;
+            break;
+
+        case '\\':
+            next = fgetc(f);
+            ungetc(next, f);
+            if (next == '\r' || next == '\n') {
+                cont = true;
+                istk->lineskip += istk->lineinc;
+                continue;
+            }
+            break;
+        }
+
+        if (p >= (buffer + size - pad)) {
+            buffer = nasm_realloc(buffer, size + delta);
+            p = buffer + size - pad;
+            size += delta;
+        }
+
+        *p++ = c;
+    } while (c);
+
+    return buffer;
+}
+
+/*
+ * Common read routine regardless of source
+ */
+static char *read_line(void)
+{
+    char *line;
+    FILE *f = istk->fp;
+
+    if (f)
+        line = line_from_file(f);
+    else
+        line = line_from_stdmac();
+
+    if (!line)
+        return NULL;
+
+    if (!istk->nolist)
+        lfmt->line(LIST_READ, istk->where.lineno, line);
+
+    return line;
+}
+
+/*
+ * Tokenize a line of text. This is a very simple process since we
+ * don't need to parse the value out of e.g. numeric tokens: we
+ * simply split one string into many.
+ */
+static Token *tokenize(const char *line)
+{
+    enum token_type type;
+    Token *list = NULL;
+    Token *t, **tail = &list;
+
+    while (*line) {
+        const char *p = line;
+        const char *ep = NULL;  /* End of token, for trimming the end */
+        size_t toklen;
+        char firstchar = *p;    /* Can be used to override the first char */
+
+        if (*p == '%') {
+            /*
+             * Preprocessor construct; find the end of the token.
+             * Classification is handled later, because %{...} can be
+             * used to create any preprocessor token.
+             */
+            p++;
+            if (*p == '+' && !nasm_isdigit(p[1])) {
+                /* Paste token */
+                p++;
+            } else if (nasm_isdigit(*p) ||
+                       ((*p == '-' || *p == '+') && nasm_isdigit(p[1]))) {
+                do {
+                    p++;
+                }
+                while (nasm_isdigit(*p));
+            } else if (*p == '{' || *p == '[') {
+                /* %{...} or %[...] */
+                char firstchar = *p;
+                char endchar = *p + 2; /* } or ] */
+                int lvl = 1;
+                line += (*p++ == '{'); /* Skip { but not [ (yet) */
+                while (lvl) {
+                    if (*p == firstchar) {
+                        lvl++;
+                    } else if (*p == endchar) {
+                        lvl--;
+                    } else if (nasm_isquote(*p)) {
+                        p = nasm_skip_string(p);
+                    }
+
+                    /*
+                     * *p can have been advanced to a null character by
+                     * nasm_skip_string()
+                     */
+                    if (!*p) {
+                        /*!
+                         *!pp-open-brackets [on] unterminated %[...]
+                         *!  warns that a preprocessor \c{%[...]} construct
+                         *!  lacks the terminating \c{]} character.
+                         */
+                        /*!
+                         *!pp-open-braces [on] unterminated %{...}
+                         *!  warns that a preprocessor parameter
+                         *!  enclosed in braces \c{%\{...\}} lacks the
+                         *!  terminating \c{\}} character.
+                         */
+                        nasm_warn(firstchar == '}' ?
+                                  WARN_PP_OPEN_BRACES : WARN_PP_OPEN_BRACKETS,
+                                  "unterminated %%%c...%c construct (missing `%c')",
+                                  firstchar, endchar, endchar);
+                        break;
+                    }
+                    p++;
+                }
+                ep = lvl ? p : p-1; /* Terminal character not part of token */
+            } else if (*p == '?') {
+                /* %? or %?? */
+                p++;
+                if (*p == '?')
+                    p++;
+            } else if (*p == '*' && p[1] == '?') {
+                /* %*? and %*?? */
+                p += 2;
+                if (*p == '?')
+                    p++;
+            } else if (*p == '!') {
+                /* Environment variable reference */
+                p++;
+                if (nasm_isidchar(*p)) {
+                    do {
+                        p++;
+                    }
+                    while (nasm_isidchar(*p));
+                } else if (nasm_isquote(*p)) {
+                    p = nasm_skip_string(p);
+                    if (*p)
+                        p++;
+                    else
+                        nasm_nonfatal("unterminated %%! string");
+                } else {
+                    /* %! without anything else... */
+                }
+            } else if (*p == ',') {
+                /* Conditional comma */
+                p++;
+            } else if (nasm_isidchar(*p) ||
+                       ((*p == '%' || *p == '$') && nasm_isidchar(p[1]))) {
+                /* Identifier or some sort */
+                do {
+                    p++;
+                }
+                while (nasm_isidchar(*p));
+            } else if (*p == '%') {
+                /* %% operator */
+                p++;
+            }
+
+            if (!ep)
+                ep = p;
+            toklen = ep - line;
+
+            /* Classify here, to handle %{...} correctly */
+            if (toklen < 2) {
+                type = '%';     /* % operator */
+                if (unlikely(*line == '{')) {
+                    /*!
+                     *!pp-empty-braces [on] empty %{} construct
+                     *!  warns that an empty \c{%\{\}} was encountered.
+                     *!  This expands to a single \c{%} character, which
+                     *!  is normally the \c{%} arithmetic operator.
+                     */
+                    nasm_warn(WARN_PP_EMPTY_BRACES,
+                              "empty %%{} construct expands to the %% operator");
+                }
+            } else {
+                char c0 = line[1];
+
+                switch (c0) {
+                case '+':
+                    type = (toklen == 2) ? TOKEN_PASTE : TOKEN_MMACRO_PARAM;
+                    break;
+
+                case '-':
+                    type = TOKEN_MMACRO_PARAM;
+                    break;
+
+                case '?':
+                    if (toklen == 2)
+                        type = TOKEN_PREPROC_Q;
+                    else if (toklen == 3 && line[2] == '?')
+                        type = TOKEN_PREPROC_QQ;
+                    else
+                        type = TOKEN_PREPROC_ID;
+                    break;
+
+                case '*':
+                    type = TOKEN_OTHER;
+                    if (line[2] == '?') {
+                        if (toklen == 3)
+                            type = TOKEN_PREPROC_SQ;
+                        else if (toklen == 4 && line[3] == '?')
+                            type = TOKEN_PREPROC_SQQ;
+                    }
+                    break;
+
+                case '!':
+                    type = (toklen == 2) ? TOKEN_OTHER : TOKEN_ENVIRON;
+                    break;
+
+                case '%':
+                    type = (toklen == 2) ? TOKEN_SMOD : TOKEN_LOCAL_SYMBOL;
+                    break;
+
+                case '$':
+                    type = (toklen == 2) ? TOKEN_OTHER : TOKEN_LOCAL_MACRO;
+                    break;
+
+                case '[':
+                    line += 2;  /* Skip %[ */
+                    firstchar = *line; /* Don't clobber */
+                    toklen -= 2;
+                    type = TOKEN_INDIRECT;
+                    break;
+
+                case ',':
+                    type = (toklen == 2) ? TOKEN_COND_COMMA : TOKEN_PREPROC_ID;
+                    break;
+
+                case '\'':
+                case '\"':
+                case '`':
+                    /* %{'string'} */
+                    type = TOKEN_PREPROC_ID;
+                    break;
+
+                case ':':
+                    type = TOKEN_MMACRO_PARAM; /* %{:..} */
+                    break;
+
+                default:
+                    if (nasm_isdigit(c0))
+                        type = TOKEN_MMACRO_PARAM;
+                    else if (nasm_isidchar(c0) || toklen > 2)
+                        type = TOKEN_PREPROC_ID;
+                    else
+                        type = TOKEN_OTHER;
+                    break;
+                }
+            }
+        } else if (*p == '?' && !nasm_isidchar(p[1])) {
+            /* ? operator */
+            type = TOKEN_QMARK;
+            p++;
+        } else if (nasm_isidstart(*p) || (*p == '$' && nasm_isidstart(p[1]))) {
+            /*
+             * A regular identifier. This includes keywords which are not
+             * special to the preprocessor.
+             */
+            type = TOKEN_ID;
+            while (nasm_isidchar(*++p))
+                ;
+         } else if (nasm_isquote(*p)) {
+            /*
+             * A string token.
+             */
+            char quote = *p;
+
+            type = TOKEN_STR;
+            p = nasm_skip_string(p);
+
+            if (*p) {
+                p++;
+            } else {
+                /*!
+                 *!pp-open-string [on] unterminated string
+                 *!  warns that a quoted string without a closing quotation
+                 *!  mark was encountered during preprocessing.
+                 */
+                nasm_warn(WARN_PP_OPEN_STRING,
+                          "unterminated string (missing `%c')", quote);
+                type = TOKEN_ERRSTR;
+            }
+        } else if (p[0] == '$' && p[1] == '$') {
+            type = TOKEN_BASE;
+            p += 2;
+        } else if (nasm_isnumstart(*p)) {
+            bool is_hex = false;
+            bool is_float = false;
+            bool has_e = false;
+            char c;
+
+            /*
+             * A numeric token.
+             */
+
+            if (*p == '$') {
+                p++;
+                is_hex = true;
+            }
+
+            for (;;) {
+                c = *p++;
+
+                if (!is_hex && (c == 'e' || c == 'E')) {
+                    has_e = true;
+                    if (*p == '+' || *p == '-') {
+                        /*
+                         * e can only be followed by +/- if it is either a
+                         * prefixed hex number or a floating-point number
+                         */
+                        p++;
+                        is_float = true;
+                    }
+                } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') {
+                    is_hex = true;
+                } else if (c == 'P' || c == 'p') {
+                    is_float = true;
+                    if (*p == '+' || *p == '-')
+                        p++;
+                } else if (nasm_isnumchar(c))
+                    ; /* just advance */
+                else if (c == '.') {
+                    /*
+                     * we need to deal with consequences of the legacy
+                     * parser, like "1.nolist" being two tokens
+                     * (TOKEN_NUM, TOKEN_ID) here; at least give it
+                     * a shot for now.  In the future, we probably need
+                     * a flex-based scanner with proper pattern matching
+                     * to do it as well as it can be done.  Nothing in
+                     * the world is going to help the person who wants
+                     * 0x123.p16 interpreted as two tokens, though.
+                     */
+                    const char *r = p;
+                    while (*r == '_')
+                        r++;
+
+                    if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) ||
+                        (!is_hex && (*r == 'e' || *r == 'E')) ||
+                        (*r == 'p' || *r == 'P')) {
+                        p = r;
+                        is_float = true;
+                    } else
+                        break;  /* Terminate the token */
+                } else
+                    break;
+            }
+            p--;        /* Point to first character beyond number */
+
+            if (p == line+1 && *line == '$') {
+                type = TOKEN_HERE;
+            } else {
+                if (has_e && !is_hex) {
+                    /* 1e13 is floating-point, but 1e13h is not */
+                    is_float = true;
+                }
+
+                type = is_float ? TOKEN_FLOAT : TOKEN_NUM;
+            }
+        } else if (nasm_isspace(*p)) {
+            firstchar = ' ';    /* Always a single space */
+            type = TOKEN_WHITESPACE;
+            p = nasm_skip_spaces(p);
+            /*
+             * Whitespace just before end-of-line is discarded by
+             * pretending it's a comment; whitespace just before a
+             * comment gets lumped into the comment.
+             */
+            if (!*p || *p == ';')
+                type = TOKEN_EOS;
+        } else if (*p == ';') {
+            type = TOKEN_EOS;
+        } else {
+            /*
+             * Anything else is an operator of some kind. We check
+             * for all the double-character operators (>>, <<, //,
+             * %%, <=, >=, ==, !=, <>, &&, ||, ^^) and the triple-
+	     * character operators (<<<, >>>, <=>) but anything
+             * else is a single-character operator.
+             */
+            type = (unsigned char)*p;
+	    switch (*p++) {
+	    case '>':
+		if (*p == '>') {
+		    p++;
+                    type = TOKEN_SHR;
+		    if (*p == '>') {
+                        type = TOKEN_SAR;
+			p++;
+                    }
+		} else if (*p == '=') {
+                    type = TOKEN_GE;
+                    p++;
+                }
+		break;
+
+	    case '<':
+		if (*p == '<') {
+		    p++;
+                    type = TOKEN_SHL;
+		    if (*p == '<')
+			p++;
+		} else if (*p == '=') {
+		    p++;
+                    type = TOKEN_LE;
+		    if (*p == '>') {
+			p++;
+                        type = TOKEN_LEG;
+                    }
+		} else if (*p == '>') {
+		    p++;
+                    type = TOKEN_NE;
+		}
+		break;
+
+	    case '!':
+		if (*p == '=') {
+		    p++;
+                    type = TOKEN_NE;
+                }
+		break;
+
+	    case '/':
+                if (*p == '/') {
+                    p++;
+                    type = TOKEN_SDIV;
+                }
+                break;
+	    case '=':
+                if (*p == '=')
+                    p++;        /* Still TOKEN_EQ == '=' though */
+                break;
+	    case '&':
+                if (*p == '&') {
+                    p++;
+                    type = TOKEN_DBL_AND;
+                }
+                break;
+
+	    case '|':
+                if (*p == '|') {
+                    p++;
+                    type = TOKEN_DBL_OR;
+                }
+                break;
+
+	    case '^':
+                if (*p == '^') {
+                    p++;
+                    type = TOKEN_DBL_XOR;
+                }
+		break;
+
+	    default:
+		break;
+	    }
+        }
+
+        if (type == TOKEN_EOS)
+            break;              /* done with the string... */
+
+        if (!ep)
+            ep = p;
+        toklen = ep - line;
+
+        if (toklen) {
+            *tail = t = new_Token(NULL, type, line, toklen);
+            *tok_text_buf(t) = firstchar; /* E.g. %{foo} -> {foo -> %foo */
+            tail = &t->next;
+        }
+
+        line = p;
+    }
+    return list;
+}
+
+/*
+ * Tokens are allocated in blocks to improve speed. Set the blocksize
+ * to 0 to use regular nasm_malloc(); this is useful for debugging.
+ *
+ * alloc_Token() returns a zero-initialized token structure.
+ */
+#define TOKEN_BLOCKSIZE 4096
+
+#if TOKEN_BLOCKSIZE
+
+static Token *freeTokens  = NULL;
+static Token *tokenblocks = NULL;
+
+static Token *alloc_Token(void)
+{
+    Token *t = freeTokens;
+
+    if (unlikely(!t)) {
+        Token *block;
+        size_t i;
+
+        nasm_newn(block, TOKEN_BLOCKSIZE);
+
+        /*
+         * The first entry in each array are a linked list of
+         * block allocations and is not used for data.
+         */
+        block[0].next = tokenblocks;
+	block[0].type = TOKEN_BLOCK;
+        tokenblocks = block;
+
+        /*
+         * Add the rest to the free list
+         */
+        for (i = 2; i < TOKEN_BLOCKSIZE - 1; i++)
+            block[i].next = &block[i+1];
+
+        freeTokens = &block[2];
+
+        /*
+         * Return the topmost usable token
+         */
+        return &block[1];
+    }
+
+    freeTokens = t->next;
+    t->next = NULL;
+    return t;
+}
+
+static Token *delete_Token(Token *t)
+{
+    Token *next;
+
+    nasm_assert(t && t->type != TOKEN_FREE);
+
+    next = t->next;
+    nasm_zero(*t);
+    t->type = TOKEN_FREE;
+    t->next = freeTokens;
+    freeTokens = t;
+
+    return next;
+}
+
+static void delete_Blocks(void)
+{
+    Token *block, *blocktmp;
+
+    list_for_each_safe(block, blocktmp, tokenblocks)
+        nasm_free(block);
+
+    freeTokens = tokenblocks = NULL;
+}
+
+#else
+
+static inline Token *alloc_Token(void)
+{
+    Token *t;
+    nasm_new(t);
+    return t;
+}
+
+static Token *delete_Token(Token *t)
+{
+    Token *next = t->next;
+    nasm_free(t);
+    return next;
+}
+
+static inline void delete_Blocks(void)
+{
+    /* Nothing to do */
+}
+
+#endif
+
+/*
+ *  this function creates a new Token and passes a pointer to it
+ *  back to the caller.  It sets the type, text, and next pointer elements.
+ */
+static Token *new_Token(Token * next, enum token_type type,
+                        const char *text, size_t txtlen)
+{
+    Token *t = alloc_Token();
+    char *textp;
+
+    t->next = next;
+    t->type = type;
+    if (type == TOKEN_WHITESPACE) {
+        t->len = 1;
+        t->text.a[0] = ' ';
+    } else {
+        if (text && text[0] && !txtlen)
+            txtlen = tok_strlen(text);
+
+        t->len = tok_check_len(txtlen);
+
+        if (text) {
+            textp = (txtlen > INLINE_TEXT)
+                ? (t->text.p.ptr = nasm_malloc(txtlen+1)) : t->text.a;
+            memcpy(textp, text, txtlen);
+            textp[txtlen] = '\0';   /* In case we needed malloc() */
+        } else {
+            /*
+             * Allocate a buffer but do not fill it. The caller
+             * can fill in text, but must not change the length.
+             * The filled in text must be exactly txtlen once
+             * the buffer is filled and before the token is added
+             * to any line lists.
+             */
+            if (txtlen > INLINE_TEXT)
+                t->text.p.ptr = nasm_zalloc(txtlen+1);
+        }
+    }
+    return t;
+}
+
+/*
+ * Same as new_Token(), but text belongs to the new token and is
+ * either taken over or freed.  This function MUST be called
+ * with valid txt and txtlen, unlike new_Token().
+ */
+static Token *new_Token_free(Token * next, enum token_type type,
+                             char *text, size_t txtlen)
+{
+    Token *t = alloc_Token();
+
+    t->next = next;
+    t->type = type;
+    t->len = tok_check_len(txtlen);
+
+    if (txtlen <= INLINE_TEXT) {
+        memcpy(t->text.a, text, txtlen);
+        nasm_free(text);
+    } else {
+        t->text.p.ptr = text;
+    }
+
+    return t;
+}
+
+static Token *dup_Token(Token *next, const Token *src)
+{
+    Token *t = alloc_Token();
+
+    memcpy(t, src, sizeof *src);
+    t->next = next;
+
+    if (t->len > INLINE_TEXT) {
+        t->text.p.ptr = nasm_malloc(t->len + 1);
+        memcpy(t->text.p.ptr, src->text.p.ptr, t->len+1);
+    }
+
+    return t;
+}
+
+static Token *new_White(Token *next)
+{
+    Token *t = alloc_Token();
+
+    t->next = next;
+    t->type = TOKEN_WHITESPACE;
+    t->len  = 1;
+    t->text.a[0] = ' ';
+
+    return t;
+}
+
+/*
+ * This *transfers* the content from one token to another, leaving the
+ * next pointer of the latter intact. Unlike dup_Token(), the old
+ * token is destroyed, except for its next pointer, and the text
+ * pointer allocation, if any, is simply transferred.
+ */
+static Token *steal_Token(Token *dst, Token *src)
+{
+    /* Overwrite everything except the next pointers */
+    memcpy((char *)dst + sizeof(Token *), (char *)src + sizeof(Token *),
+	   sizeof(Token) - sizeof(Token *));
+
+    /* Clear the donor token */
+    memset((char *)src + sizeof(Token *), 0, sizeof(Token) - sizeof(Token *));
+
+    return dst;
+}
+
+/*
+ * Convert a line of tokens back into text. This modifies the list
+ * by expanding environment variables.
+ *
+ * If expand_locals is not zero, identifiers of the form "%$*xxx"
+ * are also transformed into ..@ctxnum.xxx
+ */
+static char *detoken(Token * tlist, bool expand_locals)
+{
+    Token *t;
+    char *line, *p;
+    int len = 0;
+
+    list_for_each(t, tlist) {
+	switch (t->type) {
+	case TOKEN_ENVIRON:
+	{
+	    const char *v = pp_getenv(t, true);
+	    set_text(t, v, tok_strlen(v));
+	    t->type = TOKEN_NAKED_STR;
+	    break;
+        }
+
+	case TOKEN_LOCAL_MACRO:
+        case TOKEN_LOCAL_SYMBOL:
+	    if (expand_locals) {
+		const char *q;
+		char *p;
+		Context *ctx = get_ctx(tok_text(t), &q);
+		if (ctx) {
+		    p = nasm_asprintf("..@%"PRIu64".%s", ctx->number, q);
+		    set_text_free(t, p, nasm_last_string_len());
+		    t->type = TOKEN_ID;
+		}
+	    }
+	    break;
+
+        case TOKEN_INDIRECT:
+            /*
+             * This won't happen in when emitting to the assembler,
+             * but can happen when emitting output for some of the
+             * list options. The token string doesn't actually include
+             * the brackets in this case.
+             */
+            len += 3;           /* %[] */
+            break;
+
+	default:
+	    break;		/* No modifications */
+        }
+
+        if (debug_level(2)) {
+            unsigned int t_len  = t->len;
+            unsigned int s_len = tok_strlen(tok_text(t));
+            if (t_len != s_len) {
+                nasm_panic("assertion failed: token \"%s\" type %u len %u has t->len %u\n",
+                           tok_text(t), t->type, s_len, t_len);
+                t->len = s_len;
+            }
+        }
+
+	len += t->len;
+    }
+
+    p = line = nasm_malloc(len + 1);
+
+    list_for_each(t, tlist) {
+        switch (t->type) {
+        case TOKEN_INDIRECT:
+            *p++ = '%';
+            *p++ = '[';
+            p = mempcpy(p, tok_text(t), t->len);
+            *p++ = ']';
+            break;
+
+        default:
+            p = mempcpy(p, tok_text(t), t->len);
+        }
+    }
+    *p = '\0';
+
+    return line;
+}
+
+/*
+ * A scanner, suitable for use by the expression evaluator, which
+ * operates on a line of Tokens. Expects a pointer to a pointer to
+ * the first token in the line to be passed in as its private_data
+ * field.
+ *
+ * FIX: This really needs to be unified with stdscan.
+ */
+struct ppscan {
+    Token *tptr;
+    int ntokens;
+};
+
+static int ppscan(void *private_data, struct tokenval *tokval)
+{
+    struct ppscan *pps = private_data;
+    Token *tline;
+    const char *txt;
+
+    do {
+	if (pps->ntokens && (tline = pps->tptr)) {
+	    pps->ntokens--;
+	    pps->tptr = tline->next;
+	} else {
+	    pps->tptr = NULL;
+	    pps->ntokens = 0;
+	    return tokval->t_type = TOKEN_EOS;
+	}
+    } while (tline->type == TOKEN_WHITESPACE);
+
+    txt = tok_text(tline);
+    tokval->t_charptr = (char *)txt; /* Fix this */
+
+    switch (tline->type) {
+    default:
+        return tokval->t_type = tline->type;
+
+    case TOKEN_ID:
+        /* This could be an assembler keyword */
+	return nasm_token_hash(txt, tokval);
+
+    case TOKEN_NUM:
+    {
+        bool rn_error;
+        tokval->t_integer = readnum(txt, &rn_error);
+        if (rn_error)
+            return tokval->t_type = TOKEN_ERRNUM;
+        else
+            return tokval->t_type = TOKEN_NUM;
+    }
+
+    case TOKEN_STR:
+	tokval->t_charptr = (char *)unquote_token(tline);
+        /* fall through */
+    case TOKEN_INTERNAL_STR:
+    case TOKEN_NAKED_STR:
+        tokval->t_inttwo = tline->len;
+	return tokval->t_type = TOKEN_STR;
+    }
+}
+
+/*
+ * 1. An expression (true if nonzero 0)
+ * 2. The keywords true, on, yes for true
+ * 3. The keywords false, off, no for false
+ * 4. An empty line, for true
+ *
+ * On error, return defval (usually the previous value)
+ */
+static bool pp_get_boolean_option(Token *tline, bool defval)
+{
+    static const char * const noyes[] = {
+        "no", "yes",
+        "false", "true",
+        "off", "on"
+    };
+    struct ppscan pps;
+    struct tokenval tokval;
+    expr *evalresult;
+
+    tline = skip_white(tline);
+    if (!tline)
+        return true;
+
+    if (tline->type == TOKEN_ID) {
+        size_t i;
+	const char *txt = tok_text(tline);
+
+        for (i = 0; i < ARRAY_SIZE(noyes); i++)
+            if (!nasm_stricmp(txt, noyes[i]))
+                return i & 1;
+    }
+
+    pps.tptr = NULL;
+    pps.tptr = tline;
+    pps.ntokens = -1;
+    tokval.t_type = TOKEN_INVALID;
+    evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+
+    if (!evalresult)
+        return true;
+
+    if (tokval.t_type) {
+        /*!
+         *!pp-trailing [on] trailing garbage ignored
+         *!  warns that the preprocessor encountered additional text
+         *!  where no such text was expected. This can
+         *!  sometimes be the result of an incorrectly written expression,
+         *!  or arguments that are inadvertently separated.
+         */
+        nasm_warn(WARN_PP_TRAILING,
+                  "trailing garbage after expression ignored");
+    }
+    if (!is_really_simple(evalresult)) {
+        nasm_nonfatal("boolean flag expression must be a constant");
+        return defval;
+    }
+
+    return reloc_value(evalresult) != 0;
+}
+
+/*
+ * Compare a string to the name of an existing macro; this is a
+ * simple wrapper which calls either strcmp or nasm_stricmp
+ * depending on the value of the `casesense' parameter.
+ */
+static int mstrcmp(const char *p, const char *q, bool casesense)
+{
+    return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
+}
+
+/*
+ * Compare a string to the name of an existing macro; this is a
+ * simple wrapper which calls either strcmp or nasm_stricmp
+ * depending on the value of the `casesense' parameter.
+ */
+static int mmemcmp(const char *p, const char *q, size_t l, bool casesense)
+{
+    return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l);
+}
+
+/*
+ * Return the Context structure associated with a %$ token. Return
+ * NULL, having _already_ reported an error condition, if the
+ * context stack isn't deep enough for the supplied number of $
+ * signs.
+ *
+ * If "namep" is non-NULL, set it to the pointer to the macro name
+ * tail, i.e. the part beyond %$...
+ */
+static Context *get_ctx(const char *name, const char **namep)
+{
+    Context *ctx;
+    int i;
+
+    if (namep)
+        *namep = name;
+
+    if (!name || name[0] != '%' || name[1] != '$')
+        return NULL;
+
+    if (!cstk) {
+        nasm_nonfatal("`%s': context stack is empty", name);
+        return NULL;
+    }
+
+    name += 2;
+    ctx = cstk;
+    i = 0;
+    while (ctx && *name == '$') {
+        name++;
+        i++;
+        ctx = ctx->next;
+    }
+    if (!ctx) {
+        nasm_nonfatal("`%s': context stack is only"
+                      " %d level%s deep", name, i, (i == 1 ? "" : "s"));
+        return NULL;
+    }
+
+    if (namep)
+        *namep = name;
+
+    return ctx;
+}
+
+/*
+ * Open an include file. This routine must always return a valid
+ * file pointer if it returns - it's responsible for throwing an
+ * ERR_FATAL and bombing out completely if not. It should also try
+ * the include path one by one until it finds the file or reaches
+ * the end of the path.
+ *
+ * Note: for INC_PROBE the function returns NULL at all times;
+ * instead look for a filename in *slpath.
+ */
+enum incopen_mode {
+    INC_NEEDED,                 /* File must exist */
+    INC_REQUIRED,               /* File must exist, but only open once/pass */
+    INC_OPTIONAL,               /* Missing is OK */
+    INC_PROBE                   /* Only an existence probe */
+};
+
+/* This is conducts a full pathname search */
+static FILE *inc_fopen_search(const char *file, char **slpath,
+                              enum incopen_mode omode, enum file_flags fmode)
+{
+    const struct strlist_entry *ip = strlist_head(ipath_list);
+    FILE *fp;
+    const char *prefix = "";
+    char *sp;
+    bool found;
+
+    while (1) {
+        sp = nasm_catfile(prefix, file);
+        if (omode == INC_PROBE) {
+            fp = NULL;
+            found = nasm_file_exists(sp);
+        } else {
+            fp = nasm_open_read(sp, fmode);
+            found = (fp != NULL);
+        }
+        if (found) {
+            *slpath = sp;
+            return fp;
+        }
+
+        nasm_free(sp);
+
+        if (!ip) {
+            *slpath = NULL;
+            return NULL;
+        }
+
+        prefix = ip->str;
+        ip = ip->next;
+    }
+}
+
+/*
+ * Open a file, or test for the presence of one (depending on omode),
+ * considering the include path.
+ */
+struct file_hash_entry {
+    const char *path;
+    struct file_hash_entry *full; /* Hash entry for the full path */
+    int64_t include_pass; /* Pass in which last included (for %require) */
+};
+
+static FILE *inc_fopen(const char *file,
+                       struct strlist *dhead,
+                       const char **found_path,
+                       enum incopen_mode omode,
+                       enum file_flags fmode)
+{
+    struct file_hash_entry **fhep;
+    struct file_hash_entry *fhe = NULL;
+    struct hash_insert hi;
+    const char *path = NULL;
+    FILE *fp = NULL;
+    const int64_t pass = pass_count();
+    bool skip_open = (omode == INC_PROBE);
+
+    fhep = (struct file_hash_entry **)hash_find(&FileHash, file, &hi);
+    if (fhep) {
+        fhe = *fhep;
+        if (fhe) {
+            path = fhe->path;
+            skip_open |= (omode == INC_REQUIRED) &&
+                (fhe->full->include_pass >= pass);
+        }
+    } else {
+        /* Need to do the actual path search */
+        char *pptr;
+        fp = inc_fopen_search(file, &pptr, omode, fmode);
+        path = pptr;
+
+        /* Positive or negative result */
+        if (path) {
+            nasm_new(fhe);
+            fhe->path = path;
+            fhe->full = fhe;    /* It is *possible*... */
+        }
+        hash_add(&hi, nasm_strdup(file), fhe);
+
+        /*
+         * Add a hash entry for the canonical path if there isn't one
+         * already. Try to get the unique name from the OS best we can.
+         * Note that ->path and ->full->path can be different, and that
+         * is okay (we don't want to print out a full canonical path
+         * in messages, for example.)
+         */
+        if (path) {
+            char *fullpath = nasm_realpath(path);
+
+            if (!strcmp(file, fullpath)) {
+                nasm_free(fullpath);
+            } else {
+                struct file_hash_entry **fullp, *full;
+                fullp = (struct file_hash_entry **)
+                    hash_find(&FileHash, fullpath, &hi);
+
+                if (fullp) {
+                    full = *fullp;
+                    nasm_free(fullpath);
+                } else {
+                    nasm_new(full);
+                    full->path = fullpath;
+                    full->full = full;
+                    hash_add(&hi, path, full);
+                }
+                fhe->full = full;
+            }
+        }
+
+        /*
+         * Add file to dependency path.
+         */
+        strlist_add(dhead, path ? path : file);
+    }
+
+    if (path && !fp && omode != INC_PROBE)
+        fp = nasm_open_read(path, fmode);
+
+    if (omode < INC_OPTIONAL && !fp) {
+        if (!path)
+            errno = ENOENT;
+
+        nasm_nonfatal("unable to open include file `%s': %s",
+                      file, strerror(errno));
+    }
+
+    if (fp)
+        fhe->full->include_pass = pass;
+
+    if (found_path)
+        *found_path = path;
+
+    return fp;
+}
+
+/*
+ * Opens an include or input file. Public version, for use by modules
+ * that get a file:lineno pair and need to look at the file again
+ * (e.g. the CodeView debug backend). Returns NULL on failure.
+ */
+FILE *pp_input_fopen(const char *filename, enum file_flags mode)
+{
+    return inc_fopen(filename, NULL, NULL, INC_OPTIONAL, mode);
+}
+
+/*
+ * Determine if we should warn on defining a single-line macro of
+ * name `name', with `nparam' parameters. If nparam is 0 or -1, will
+ * return true if _any_ single-line macro of that name is defined.
+ * Otherwise, will return true if a single-line macro with either
+ * `nparam' or no parameters is defined.
+ *
+ * If a macro with precisely the right number of parameters is
+ * defined, or nparam is -1, the address of the definition structure
+ * will be returned in `defn'; otherwise NULL will be returned. If `defn'
+ * is NULL, no action will be taken regarding its contents, and no
+ * error will occur.
+ *
+ * Note that this is also called with nparam zero to resolve
+ * `ifdef'.
+ */
+static bool
+smacro_defined(Context *ctx, const char *name, int nparam, SMacro **defn,
+               bool nocase, bool find_alias)
+{
+    struct hash_table *smtbl;
+    SMacro *m;
+
+    smtbl = ctx ? &ctx->localmac : &smacros;
+
+restart:
+    m = (SMacro *) hash_findix(smtbl, name);
+
+    while (m) {
+        if (!mstrcmp(m->name, name, m->casesense && nocase) &&
+            (nparam <= 0 || m->nparam == 0 ||
+             (nparam >= m->nparam_min &&
+              (m->varadic || nparam <= m->nparam)))) {
+            if (m->alias && !find_alias) {
+                if (!ppconf.noaliases) {
+                    name = tok_text(m->expansion);
+                    goto restart;
+                } else {
+                    continue;
+                }
+            }
+            if (defn)
+                *defn = m;
+            return true;
+        }
+        m = m->next;
+    }
+
+    return false;
+}
+
+/* param should be a natural number [0; INT_MAX] */
+static int read_param_count(const char *str)
+{
+    int result;
+    bool err;
+
+    result = readnum(str, &err);
+    if (result < 0 || result > INT_MAX) {
+        result = 0;
+        nasm_nonfatal("parameter count `%s' is out of bounds [%d; %d]",
+                      str, 0, INT_MAX);
+    } else if (err)
+        nasm_nonfatal("unable to parse parameter count `%s'", str);
+    return result;
+}
+
+/*
+ * Count and mark off the parameters in a multi-line macro call.
+ * This is called both from within the multi-line macro expansion
+ * code, and also to mark off the default parameters when provided
+ * in a %macro definition line.
+ *
+ * Note that we need space in the params array for parameter 0 being
+ * a possible captured label as well as the final NULL.
+ *
+ * Returns a pointer to the pointer to a terminal comma if present;
+ * used to drop an empty terminal argument for legacy reasons.
+ */
+static Token **count_mmac_params(Token *tline, int *nparamp, Token ***paramsp)
+{
+    int paramsize;
+    int nparam = 0;
+    Token *t;
+    Token **comma = NULL, **maybe_comma = NULL;
+    Token **params;
+
+    paramsize = PARAM_DELTA;
+    nasm_newn(params, paramsize);
+
+    t = skip_white(tline);
+    if (t) {
+        while (true) {
+            /* Need two slots for captured label and NULL */
+            if (unlikely(nparam+2 >= paramsize)) {
+                paramsize += PARAM_DELTA;
+                params = nasm_realloc(params, sizeof(*params) * paramsize);
+            }
+            params[++nparam] = t;
+            if (tok_is(t, '{')) {
+                int brace = 1;
+
+                comma = NULL;   /* Non-empty parameter */
+
+                while (brace && (t = t->next)) {
+                    brace += tok_is(t, '{');
+                    brace -= tok_is(t, '}');
+                }
+
+                if (t) {
+                    /*
+                     * Now we've found the closing brace, look further
+                     * for the comma.
+                     */
+                    t = skip_white(t->next);
+                    if (tok_isnt(t, ','))
+                        nasm_nonfatal("braces do not enclose all of macro parameter");
+                } else {
+                    nasm_nonfatal("expecting closing brace in macro parameter");
+                }
+            }
+
+            /* Advance to the next comma */
+            maybe_comma = &t->next;
+            while (tok_isnt(t, ',')) {
+                if (!tok_white(t))
+                    comma = NULL; /* Non-empty parameter */
+                maybe_comma = &t->next;
+                t = t->next;
+            }
+
+            if (!t)
+                break;              /* End of string, no comma */
+
+            comma = maybe_comma;     /* Point to comma pointer */
+            t = skip_white(t->next); /* Eat the comma and whitespace */
+        }
+    }
+
+    params[nparam+1] = NULL;
+    *paramsp = params;
+    *nparamp = nparam;
+
+    return comma;
+}
+
+/*
+ * Determine whether one of the various `if' conditions is true or
+ * not.
+ *
+ * We must free the tline we get passed.
+ */
+static enum cond_state if_condition(Token * tline, enum preproc_token ct)
+{
+    bool j;
+    Token *t, *tt, *origline;
+    struct ppscan pps;
+    struct tokenval tokval;
+    expr *evalresult;
+    enum token_type needtype;
+    const char *dname = pp_directives[ct];
+    bool casesense = true;
+    enum preproc_token cond = PP_COND(ct);
+
+    origline = tline;
+
+    switch (cond) {
+    case PP_IFCTX:
+        j = false;              /* have we matched yet? */
+        while (true) {
+            tline = skip_white(tline);
+            if (!tline)
+                break;
+            if (tline->type != TOKEN_ID) {
+                nasm_nonfatal("`%s' expects context identifiers",
+                              dname);
+                goto fail;
+            }
+            if (cstk && cstk->name && !nasm_stricmp(tok_text(tline), cstk->name))
+                j = true;
+            tline = tline->next;
+        }
+        break;
+
+    case PP_IFDEF:
+    case PP_IFDEFALIAS:
+    {
+        bool alias = cond == PP_IFDEFALIAS;
+        SMacro *smac;
+        Context *ctx;
+        const char *mname;
+
+        j = false;              /* have we matched yet? */
+        while (tline) {
+            tline = skip_white(tline);
+            if (!tline || (tline->type != TOKEN_ID &&
+			   tline->type != TOKEN_LOCAL_MACRO)) {
+                nasm_nonfatal("`%s' expects macro identifiers",
+                              dname);
+                goto fail;
+            }
+
+            mname = tok_text(tline);
+            ctx = get_ctx(mname, &mname);
+            if (smacro_defined(ctx, mname, -1, &smac, true, alias) && smac
+                && smac->alias == alias) {
+                j = true;
+                break;
+            }
+            tline = tline->next;
+        }
+        break;
+    }
+
+    case PP_IFDIFI:
+        /*
+         * %ifdifi doesn't actually exist; it ignores its argument and is
+         * always false. This exists solely to stub out the corresponding
+         * TASM directive.
+         */
+        j = false;
+        goto fail;
+
+    case PP_IFENV:
+        tline = expand_smacro(tline);
+        j = false;              /* have we matched yet? */
+        while (tline) {
+            tline = skip_white(tline);
+            if (!tline || (tline->type != TOKEN_ID &&
+                           tline->type != TOKEN_STR &&
+			   tline->type != TOKEN_INTERNAL_STR &&
+                           tline->type != TOKEN_ENVIRON)) {
+                nasm_nonfatal("`%s' expects environment variable names",
+                              dname);
+                goto fail;
+            }
+
+	    j |= !!pp_getenv(tline, false);
+            tline = tline->next;
+	}
+	break;
+
+    case PP_IFIDNI:
+        casesense = false;
+        /* fall through */
+    case PP_IFIDN:
+        tline = expand_smacro(tline);
+        t = tt = tline;
+        while (tok_isnt(tt, ','))
+            tt = tt->next;
+        if (!tt) {
+            nasm_nonfatal("`%s' expects two comma-separated arguments",
+                          dname);
+            goto fail;
+        }
+        tt = tt->next;
+        j = true;               /* assume equality unless proved not */
+        while (tok_isnt(t, ',') && tt) {
+	    unsigned int l1, l2;
+	    const char *t1, *t2;
+
+            if (tok_is(tt, ',')) {
+                nasm_nonfatal("`%s': more than one comma on line",
+                              dname);
+                goto fail;
+            }
+            if (t->type == TOKEN_WHITESPACE) {
+                t = t->next;
+                continue;
+            }
+            if (tt->type == TOKEN_WHITESPACE) {
+                tt = tt->next;
+                continue;
+            }
+            if (tt->type != t->type) {
+                j = false;      /* found mismatching tokens */
+                break;
+            }
+
+	    t1 = unquote_token(t);
+	    t2 = unquote_token(tt);
+	    l1 = t->len;
+	    l2 = tt->len;
+
+	    if (l1 != l2 || mmemcmp(t1, t2, l1, casesense)) {
+		j = false;
+		break;
+	    }
+
+            t = t->next;
+            tt = tt->next;
+        }
+        if (!tok_is(t, ',') || tt)
+            j = false;          /* trailing gunk on one end or other */
+        break;
+
+    case PP_IFMACRO:
+    {
+        bool found = false;
+        MMacro searching, *mmac;
+
+        tline = skip_white(tline);
+        tline = expand_id(tline);
+        if (!tok_is(tline, TOKEN_ID)) {
+            nasm_nonfatal("`%s' expects a macro name", dname);
+            goto fail;
+        }
+        nasm_zero(searching);
+        searching.name = dup_text(tline);
+        searching.casesense = true;
+        searching.nparam_min = 0;
+        searching.nparam_max = INT_MAX;
+        tline = expand_smacro(tline->next);
+        tline = skip_white(tline);
+        if (!tline) {
+        } else if (!tok_is(tline, TOKEN_NUM)) {
+            nasm_nonfatal("`%s' expects a parameter count or nothing",
+                          dname);
+        } else {
+            searching.nparam_min = searching.nparam_max =
+                read_param_count(tok_text(tline));
+        }
+        if (tline && tok_is(tline->next, '-')) {
+            tline = tline->next->next;
+            if (tok_is(tline, '*'))
+                searching.nparam_max = INT_MAX;
+            else if (!tok_is(tline, TOKEN_NUM))
+                nasm_nonfatal("`%s' expects a parameter count after `-'",
+                              dname);
+            else {
+                searching.nparam_max = read_param_count(tok_text(tline));
+                if (searching.nparam_min > searching.nparam_max) {
+                    nasm_nonfatal("minimum parameter count exceeds maximum");
+                    searching.nparam_max = searching.nparam_min;
+                }
+            }
+        }
+        if (tline && tok_is(tline->next, '+')) {
+            tline = tline->next;
+            searching.plus = true;
+        }
+        mmac = (MMacro *) hash_findix(&mmacros, searching.name);
+        while (mmac) {
+            if (!strcmp(mmac->name, searching.name) &&
+                (mmac->nparam_min <= searching.nparam_max
+                 || searching.plus)
+                && (searching.nparam_min <= mmac->nparam_max
+                    || mmac->plus)) {
+                found = true;
+                break;
+            }
+            mmac = mmac->next;
+        }
+        if (tline && tline->next) {
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after `%s' ignored", dname);
+        }
+        nasm_free(searching.name);
+        j = found;
+        break;
+    }
+
+    case PP_IFID:
+        needtype = TOKEN_ID;
+        goto iftype;
+    case PP_IFNUM:
+        needtype = TOKEN_NUM;
+        goto iftype;
+    case PP_IFSTR:
+        needtype = TOKEN_STR;
+        goto iftype;
+
+iftype:
+        t = tline = expand_smacro(tline);
+
+        while (tok_white(t) ||
+               (needtype == TOKEN_NUM && (tok_is(t, '-') | tok_is(t, '+'))))
+            t = t->next;
+
+        j = tok_is(t, needtype);
+        break;
+
+    case PP_IFTOKEN:
+        tline = expand_smacro(tline);
+        t = skip_white(tline);
+
+        j = false;
+        if (t) {
+            t = skip_white(t->next); /* Skip the actual token + whitespace */
+            j = !t;
+        }
+        break;
+
+    case PP_IFEMPTY:
+        tline = expand_smacro(tline);
+        t = skip_white(tline);
+        j = !t;                 /* Should be empty */
+        break;
+
+    case PP_IF:
+        pps.tptr = tline = expand_smacro(tline);
+	pps.ntokens = -1;
+        tokval.t_type = TOKEN_INVALID;
+        evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+        if (!evalresult)
+            return -1;
+        if (tokval.t_type) {
+            nasm_warn(WARN_PP_TRAILING, "trailing garbage after expression ignored");
+        }
+        if (!is_simple(evalresult)) {
+            nasm_nonfatal("non-constant value given to `%s'",
+                          dname);
+            goto fail;
+        }
+        j = reloc_value(evalresult) != 0;
+        break;
+
+    case PP_IFUSING:
+    case PP_IFUSABLE:
+    {
+        const struct use_package *pkg;
+        const char *name;
+
+        pkg = get_use_pkg(tline, dname, &name);
+        if (!name)
+            goto fail;
+
+        j = pkg && ((cond == PP_IFUSABLE) | use_loaded[pkg->index]);
+        break;
+    }
+
+    default:
+        nasm_nonfatal("unknown preprocessor directive `%s'", dname);
+        goto fail;
+    }
+
+    free_tlist(origline);
+    return (j ^ PP_COND_NEGATIVE(ct)) ? COND_IF_TRUE : COND_IF_FALSE;
+
+fail:
+    free_tlist(origline);
+    return COND_NEVER;
+}
+
+/*
+ * Default smacro expansion routine: just returns a copy of the
+ * expansion list.
+ */
+static Token *
+smacro_expand_default(const SMacro *s, Token **params, int nparams)
+{
+    (void)params;
+    (void)nparams;
+
+    return dup_tlist(s->expansion, NULL);
+}
+
+/*
+ * Emit a macro definition or undef to the listing file or debug format
+ * if desired. This is similar to detoken(), but it handles the
+ * reverse expansion list, does not expand %! or local variable
+ * tokens, and does some special handling for macro parameters.
+ */
+static void
+list_smacro_def(enum preproc_token op, const Context *ctx, const SMacro *m)
+{
+    Token *t;
+    size_t namelen, size;
+    char *def, *p, *end_spec;
+    char *context_prefix = NULL;
+    size_t context_len;
+
+    namelen = strlen(m->name);
+    size = namelen + 2;  /* Include room for space after name + NUL */
+
+    if (ctx) {
+        int context_depth = cstk->depth - ctx->depth + 1;
+        context_prefix =
+            nasm_asprintf("[%s::%"PRIu64"] %%%-*s",
+                          ctx->name ? ctx->name : "",
+                          ctx->number, context_depth, "");
+
+        context_len = nasm_last_string_len();
+        memset(context_prefix + context_len - context_depth,
+               '$', context_depth);
+        size += context_len;
+    }
+
+    list_for_each(t, m->expansion)
+        size += t->len;
+
+    if (m->nparam) {
+        /*
+         * Space for ( and either , or ) around each
+         * parameter, plus up to 5 flags.
+         */
+        int i;
+
+        size += 1 + 5 * m->nparam;
+        for (i = 0; i < m->nparam; i++)
+            size += m->params[i].name.len;
+    }
+
+    def = nasm_malloc(size);
+    p = def+size;
+    *--p = '\0';
+
+    list_for_each(t, m->expansion) {
+	p -= t->len;
+	memcpy(p, tok_text(t), t->len);
+    }
+
+    *--p = ' ';
+    end_spec = p;               /* Truncate here for macro def only */
+
+    if (m->nparam) {
+        int i;
+
+        *--p = ')';
+
+        for (i = m->nparam-1; i >= 0; i--) {
+            enum sparmflags flags = m->params[i].flags;
+            if (flags & (SPARM_GREEDY|SPARM_VARADIC))
+                *--p = '+';
+	    p -= m->params[i].name.len;
+	    memcpy(p, tok_text(&m->params[i].name), m->params[i].name.len);
+
+            if (flags & SPARM_NOSTRIP)
+                *--p = '!';
+            if (flags & SPARM_STR) {
+                *--p = '&';
+                if (flags & SPARM_CONDQUOTE)
+                    *--p = '&';
+            }
+            if (flags & SPARM_EVAL)
+                *--p = '=';
+            *--p = ',';
+        }
+        *p = '(';               /* First parameter starts with ( not , */
+    }
+
+    p -= namelen;
+    memcpy(p, m->name, namelen);
+
+    if (context_prefix) {
+        p -= context_len;
+        memcpy(p, context_prefix, context_len);
+        nasm_free(context_prefix);
+    }
+
+    if (ppdbg & PDBG_LIST_SMACROS)
+        nasm_listmsg("%s %s", pp_directives[op], p);
+    if (ppdbg & PDBG_SMACROS) {
+        bool define = !(op == PP_UNDEF || op == PP_UNDEFALIAS);
+        if (!define)
+            *end_spec = '\0';   /* Remove the expansion (for list file only) */
+        dfmt->debug_smacros(define, p);
+    }
+    nasm_free(def);
+}
+
+/*
+ * Parse smacro arguments, return argument count. If the tmpl argument
+ * is set, set the nparam, varadic and params field in the template.
+ * The varadic field is not used by define_smacro(), but is provided
+ * in case the caller wants it for other purposes.
+ *
+ * *tpp is updated to point to the pointer to the first token after the
+ * prototype.
+ *
+ * The text values from any argument tokens are "stolen" and the
+ * corresponding text fields set to NULL.
+ *
+ * Note that the user can't define a true varadic macro; doing so
+ * would be meaningless. The true varadic macros are only used for
+ * internal "magic macro" functions.
+ */
+static int parse_smacro_template(Token ***tpp, SMacro *tmpl)
+{
+    int nparam = 0;
+    enum sparmflags flags;
+    struct smac_param *params = NULL;
+    bool err, done;
+    bool greedy = false;
+    Token **tn = *tpp;
+    Token *t = *tn;
+    Token *name;
+
+    /*
+     * DO NOT skip whitespace here, or we won't be able to distinguish:
+     *
+     * %define foo (a,b)		; no arguments, (a,b) is the expansion
+     * %define bar(a,b)			; two arguments, empty expansion
+     *
+     * This ambiguity was inherited from C.
+     */
+
+    if (!tok_is(t, '('))
+        goto finish;
+
+    if (tmpl) {
+        Token *tx = t;
+        Token **txpp = &tx;
+        int sparam;
+
+        /* Count parameters first */
+        sparam = parse_smacro_template(&txpp, NULL);
+        if (!sparam)
+            goto finish;        /* No parameters, we're done */
+        nasm_newn(params, sparam);
+    }
+
+    /* Skip leading paren */
+    tn = &t->next;
+    t = *tn;
+
+    name = NULL;
+    flags = 0;
+    err = done = false;
+
+    while (!done) {
+        if (!t) {
+            if (name || flags)
+                nasm_nonfatal("`)' expected to terminate macro template");
+            else
+                nasm_nonfatal("parameter identifier expected");
+            break;
+        }
+
+        switch (t->type) {
+        case TOKEN_ID:
+            if (name)
+                goto bad;
+            name = t;
+            break;
+        case '=':
+            flags |= SPARM_EVAL;
+            break;
+        case '&':
+            flags |= SPARM_STR;
+            break;
+        case TOKEN_DBL_AND:
+            flags |= SPARM_STR|SPARM_CONDQUOTE;
+            break;
+        case '!':
+            flags |= SPARM_NOSTRIP;
+            break;
+        case '+':
+            flags |= SPARM_GREEDY|SPARM_OPTIONAL;
+            greedy = true;
+            break;
+        case ',':
+            if (greedy)
+                nasm_nonfatal("greedy parameter must be last");
+            goto end_param;
+        case ')':
+            done = true;
+            goto end_param;
+        end_param:
+            if (params) {
+                if (name)
+                    steal_Token(&params[nparam].name, name);
+                params[nparam].flags = flags;
+            }
+            nparam++;
+            name = NULL;
+            flags = 0;
+            break;
+        case TOKEN_WHITESPACE:
+            break;
+        default:
+        bad:
+            if (!err) {
+                nasm_nonfatal("garbage `%s' in macro parameter list",
+                              tok_text(t));
+                err = true;
+            }
+            break;
+        }
+
+        tn = &t->next;
+        t = *tn;
+    }
+
+finish:
+    while (t && t->type == TOKEN_WHITESPACE) {
+        tn = &t->next;
+        t = t->next;
+    }
+    *tpp = tn;
+    if (tmpl) {
+        tmpl->nparam     = nparam;
+        tmpl->varadic    = greedy;
+        tmpl->params     = params;
+    }
+    return nparam;
+}
+
+/*
+ * Common code for defining an smacro. The tmpl argument, if not NULL,
+ * contains any macro parameters that aren't explicit arguments;
+ * those are the more uncommon macro variants.
+ */
+static SMacro *define_smacro(const char *mname, bool casesense,
+                             Token *expansion, SMacro *tmpl)
+{
+    SMacro *smac, **smhead;
+    struct hash_table *smtbl;
+    Context *ctx;
+    bool defining_alias = false;
+    int nparam = 0;
+    bool defined;
+
+    if (tmpl) {
+        defining_alias = tmpl->alias;
+        nparam = tmpl->nparam;
+        if (nparam && !defining_alias)
+            mark_smac_params(expansion, tmpl, 0);
+    }
+
+    ctx = get_ctx(mname, &mname);
+
+    defined = smacro_defined(ctx, mname, nparam, &smac, casesense, true);
+
+    if (defined) {
+        if (smac->alias) {
+            if (smac->in_progress) {
+                nasm_nonfatal("macro alias loop");
+                goto fail;
+            }
+
+            if (!defining_alias && !ppconf.noaliases) {
+                /* It is an alias macro; follow the alias link */
+                SMacro *s;
+
+                smac->in_progress++;
+                s = define_smacro(tok_text(smac->expansion), casesense,
+                                  expansion, tmpl);
+                smac->in_progress--;
+                return s;
+            }
+        }
+
+        if (casesense ^ smac->casesense) {
+            /*
+             *!pp-macro-def-case-single [on] single-line macro defined both case sensitive and insensitive
+             *!=macro-def-case-single
+             *!  warns when a single-line macro is defined both case
+             *!  sensitive and case insensitive.
+             *!  The new macro
+             *!  definition will override (shadow) the original one,
+             *!  although the original macro is not deleted, and will
+             *!  be re-exposed if the new macro is deleted with
+             *!  \c{%undef}, or, if the original macro is the case
+             *!  insensitive one, the macro call is done with a
+             *!  different case.
+             */
+            nasm_warn(WARN_PP_MACRO_DEF_CASE_SINGLE, "case %ssensitive definition of macro `%s' will shadow %ssensitive macro `%s'",
+                      casesense ? "" : "in",
+                      mname,
+                      smac->casesense ? "" : "in",
+                      smac->name);
+            defined = false;
+        } else if ((!!nparam) ^ (!!smac->nparam)) {
+            /*
+             * Most recent versions of NASM considered this an error,
+             * so promote this warning to error by default.
+             *
+             *!pp-macro-def-param-single [err] single-line macro defined with and without parameters
+             *!=macro-def-param-single
+             *!  warns if the same single-line macro is defined with and
+             *!  without parameters.
+             *!  The new macro
+             *!  definition will override (shadow) the original one,
+             *!  although the original macro is not deleted, and will
+             *!  be re-exposed if the new macro is deleted with
+             *!  \c{%undef}.
+             */
+            nasm_warn(WARN_PP_MACRO_DEF_PARAM_SINGLE,
+                      "macro `%s' defined both with and without parameters",
+                      mname);
+            defined = false;
+        } else if (smac->nparam < nparam) {
+            /*
+             *!pp-macro-def-greedy-single [on] single-line macro
+             *!=macro-def-greedy-single
+             *!  definition shadows greedy macro warns when a
+             *!  single-line macro is defined which would match a
+             *!  previously existing greedy definition.  The new macro
+             *!  definition will override (shadow) the original one,
+             *!  although the original macro is not deleted, and will
+             *!  be re-exposed if the new macro is deleted with
+             *!  \c{%undef}, and will be invoked if called with a
+             *!  parameter count that does not match the new definition.
+             */
+            nasm_warn(WARN_PP_MACRO_DEF_GREEDY_SINGLE,
+                      "defining macro `%s' shadows previous greedy definition",
+                      mname);
+            defined = false;
+        }
+    }
+
+    if (defined) {
+        /*
+         * We're redefinining, so we have to take over an
+         * existing SMacro structure. This means freeing
+         * what was already in it, but not the structure itself.
+         */
+        clear_smacro(smac);
+    } else {
+        /* Create a new macro */
+        smtbl  = ctx ? &ctx->localmac : &smacros;
+        smhead = (SMacro **) hash_findi_add(smtbl, mname);
+        nasm_new(smac);
+        smac->next = *smhead;
+        *smhead = smac;
+    }
+
+    smac->name       = nasm_strdup(mname);
+    smac->casesense  = casesense;
+    smac->expansion  = reverse_tokens(expansion);
+    smac->expand     = smacro_expand_default;
+    smac->nparam     = nparam;
+    smac->nparam_min = nparam;
+    if (tmpl) {
+        smac->params     = tmpl->params;
+        smac->alias      = tmpl->alias;
+        smac->recursive  = tmpl->recursive;
+        if (tmpl->expand) {
+            smac->expand    = tmpl->expand;
+            smac->expandpvt = tmpl->expandpvt;
+        }
+        if (nparam) {
+            int nparam_min = nparam;
+
+            smac->varadic =
+                !!(tmpl->params[nparam-1].flags &
+                   (SPARM_GREEDY|SPARM_VARADIC));
+
+            while (nparam_min > 1) {
+                if (!(tmpl->params[nparam_min-1].flags & SPARM_OPTIONAL))
+                    break;
+                nparam_min--;
+            }
+
+            smac->nparam_min = nparam_min;
+        }
+    }
+    if (ppdbg & (PDBG_SMACROS|PDBG_LIST_SMACROS)) {
+        list_smacro_def((smac->alias ? PP_DEFALIAS : PP_DEFINE)
+                        + !casesense, ctx, smac);
+    }
+    return smac;
+
+fail:
+    free_tlist(expansion);
+    if (tmpl)
+        free_smacro_members(tmpl);
+    return NULL;
+}
+
+/*
+ * Undefine an smacro
+ */
+static void undef_smacro(const char *mname, bool undefalias)
+{
+    SMacro **smhead, *s, **sp;
+    struct hash_table *smtbl;
+    Context *ctx;
+
+    ctx = get_ctx(mname, &mname);
+    smtbl = ctx ? &ctx->localmac : &smacros;
+    smhead = (SMacro **)hash_findi(smtbl, mname, NULL);
+
+    if (smhead) {
+        /*
+         * We now have a macro name... go hunt for it.
+         */
+        sp = smhead;
+        while ((s = *sp) != NULL) {
+            if (!mstrcmp(s->name, mname, s->casesense)) {
+                if (s->alias && !undefalias) {
+                    if (!ppconf.noaliases) {
+                        if (s->in_progress) {
+                            nasm_nonfatal("macro alias loop");
+                        } else {
+                            s->in_progress = true;
+                            undef_smacro(tok_text(s->expansion), false);
+                            s->in_progress = false;
+                        }
+                    }
+                } else {
+                    if (list_option('d'))
+                        list_smacro_def(s->alias ? PP_UNDEFALIAS : PP_UNDEF,
+                                        ctx, s);
+                    *sp = s->next;
+                    free_smacro(s);
+                    continue;
+                }
+            }
+            sp = &s->next;
+        }
+    }
+}
+
+/*
+ * Parse a mmacro specification.
+ */
+static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive)
+{
+    tline = tline->next;
+    tline = skip_white(tline);
+    tline = expand_id(tline);
+    if (!tok_is(tline, TOKEN_ID)) {
+        nasm_nonfatal("`%s' expects a macro name", directive);
+        return false;
+    }
+
+#if 0
+    def->prev = NULL;
+#endif
+    def->name = dup_text(tline);
+    def->plus = false;
+    def->nolist = 0;
+    def->nparam_min = 0;
+    def->nparam_max = 0;
+
+    tline = expand_smacro(tline->next);
+    tline = skip_white(tline);
+    if (!tok_is(tline, TOKEN_NUM))
+        nasm_nonfatal("`%s' expects a parameter count", directive);
+    else
+        def->nparam_min = def->nparam_max = read_param_count(tok_text(tline));
+    if (tline && tok_is(tline->next, '-')) {
+        tline = tline->next->next;
+        if (tok_is(tline, '*')) {
+            def->nparam_max = INT_MAX;
+        } else if (!tok_is(tline, TOKEN_NUM)) {
+            nasm_nonfatal("`%s' expects a parameter count after `-'", directive);
+        } else {
+            def->nparam_max = read_param_count(tok_text(tline));
+            if (def->nparam_min > def->nparam_max) {
+                nasm_nonfatal("minimum parameter count exceeds maximum");
+                def->nparam_max = def->nparam_min;
+            }
+        }
+    }
+    if (tline && tok_is(tline->next, '+')) {
+        tline = tline->next;
+        def->plus = true;
+    }
+    if (tline && tok_is(tline->next, TOKEN_ID) &&
+	tline->next->len == 7 &&
+        !nasm_stricmp(tline->next->text.a, ".nolist")) {
+        tline = tline->next;
+        if (!list_option('f'))
+            def->nolist |= NL_LIST|NL_LINE;
+    }
+
+    /*
+     * Handle default parameters.
+     */
+    def->ndefs = 0;
+    if (tline && tline->next) {
+        Token **comma;
+        def->dlist = tline->next;
+        tline->next = NULL;
+        comma = count_mmac_params(def->dlist, &def->ndefs, &def->defaults);
+        if (!ppconf.sane_empty_expansion && comma) {
+            *comma = NULL;
+            def->ndefs--;
+            nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY,
+                      "dropping trailing empty default parameter in definition of multi-line macro `%s'",
+                      def->name);
+        }
+    } else {
+        def->dlist = NULL;
+        def->defaults = NULL;
+    }
+    def->expansion = NULL;
+
+    if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min &&
+        !def->plus) {
+        /*
+         *!pp-macro-defaults [on] macros with more default than optional parameters
+         *!=macro-defaults
+         *!  warns when a macro has more default parameters than optional parameters.
+         *!  See \k{mlmacdef} for why might want to disable this warning.
+         */
+        nasm_warn(WARN_PP_MACRO_DEFAULTS,
+                   "too many default macro parameters in macro `%s'", def->name);
+    }
+
+    return true;
+}
+
+
+/*
+ * Decode a size directive
+ */
+static int parse_size(const char *str) {
+    static const char *size_names[] =
+        { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
+    static const int sizes[] =
+        { 0, 1, 4, 16, 8, 10, 2, 32 };
+    return str ? sizes[bsii(str, size_names, ARRAY_SIZE(size_names))+1] : 0;
+}
+
+/*
+ * Process a preprocessor %pragma directive.  Currently there are none.
+ * Gets passed the token list starting with the "preproc" token from
+ * "%pragma preproc".
+ */
+static void do_pragma_preproc(Token *tline)
+{
+    const char *txt;
+
+    /* Skip to the real stuff */
+    tline = tline->next;
+    tline = skip_white(tline);
+
+    if (!tok_is(tline, TOKEN_ID))
+        return;
+
+    txt = tok_text(tline);
+    if (!nasm_stricmp(txt, "sane_empty_expansion")) {
+        tline = skip_white(tline->next);
+        ppconf.sane_empty_expansion =
+            pp_get_boolean_option(tline, ppconf.sane_empty_expansion);
+    } else {
+        /* Unknown pragma, ignore for now */
+    }
+}
+
+static bool is_macro_id(const Token *t)
+{
+    return tok_is(t, TOKEN_ID) || tok_is(t, TOKEN_LOCAL_MACRO);
+}
+
+static const char *get_id(Token **tp, const char *dname)
+{
+    const char *id;
+    Token *t = *tp;
+
+    t = t->next;                /* Skip directive */
+    t = skip_white(t);
+    t = expand_id(t);
+
+    if (!is_macro_id(t)) {
+        nasm_nonfatal("`%s' expects a macro identifier", dname);
+        return NULL;
+    }
+
+    id = tok_text(t);
+    t = skip_white(t);
+    *tp = t;
+    return id;
+}
+
+/* Parse a %use package name and find the package. Set *err on syntax error. */
+static const struct use_package *
+get_use_pkg(Token *t, const char *dname, const char **name)
+{
+    const char *id;
+
+    t = skip_white(t);
+    t = expand_smacro(t);
+
+    *name = NULL;
+
+    if (!t) {
+        nasm_nonfatal("`%s' expects a package name, got end of line", dname);
+        return NULL;
+    } else if (t->type != TOKEN_ID && t->type != TOKEN_STR) {
+        nasm_nonfatal("`%s' expects a package name, got `%s'",
+                      dname, tok_text(t));
+        return NULL;
+    }
+
+    *name = id = unquote_token(t);
+
+    t = t->next;
+    t = skip_white(t);
+    if (t) {
+        nasm_warn(WARN_PP_TRAILING,
+                  "trailing garbage after `%s' ignored", dname);
+    }
+
+    return nasm_find_use_package(id);
+}
+
+/*
+ * Mark parameter tokens in an smacro definition. If the type argument
+ * is 0, create smac param tokens, otherwise use the type specified;
+ * normally this is used for TOKEN_XDEF_PARAM, which is used to protect
+ * parameter tokens during expansion during %xdefine.
+ *
+ * tmpl may not be NULL here.
+ */
+static void mark_smac_params(Token *tline, const SMacro *tmpl,
+                             enum token_type type)
+{
+    const struct smac_param *params = tmpl->params;
+    int nparam = tmpl->nparam;
+    Token *t;
+    int i;
+
+    list_for_each(t, tline) {
+        if (t->type != TOKEN_ID && t->type != TOKEN_XDEF_PARAM)
+            continue;
+
+        for (i = 0; i < nparam; i++) {
+            if (tok_text_match(t, &params[i].name))
+                t->type = type ? type : tok_smac_param(i);
+        }
+    }
+}
+
+/**
+ * %clear selected macro sets either globally or in contexts
+ */
+static void do_clear(enum clear_what what, bool context)
+{
+    if (context) {
+        if (what & CLEAR_ALLDEFINE) {
+            Context *ctx;
+            list_for_each(ctx, cstk)
+                clear_smacro_table(&ctx->localmac, what);
+        }
+        /* Nothing else can be context-local */
+    } else {
+        if (what & CLEAR_ALLDEFINE)
+            clear_smacro_table(&smacros, what);
+        if (what & CLEAR_MMACRO)
+            free_mmacro_table(&mmacros);
+    }
+}
+
+/*
+ * Process a %line directive, including the gcc/cpp compatibility
+ * form with a # at the front.
+ */
+static int line_directive(Token *origline, Token *tline)
+{
+    int k, m;
+    bool err;
+    const char *dname;
+
+    /*
+     * Valid syntaxes:
+     * %line nnn[+mmm] [filename]
+     * %line nnn[+mmm] "filename" flags...
+     *
+     * "flags" are for gcc compatibility and are currently ignored.
+     *
+     * '#' at the beginning of the line is also treated as a %line
+     * directive, again for compatibility with gcc.
+     */
+    if ((ppopt & PP_NOLINE) || istk->mstk.mstk)
+        goto done;
+
+    dname = tok_text(tline);
+    tline = tline->next;
+    tline = skip_white(tline);
+    if (!tok_is(tline, TOKEN_NUM)) {
+        nasm_nonfatal("`%s' expects a line number", dname);
+        goto done;
+    }
+    k = readnum(tok_text(tline), &err);
+    m = 1;
+    tline = tline->next;
+    if (tok_is(tline, '+') || tok_is(tline, '-')) {
+        bool minus = tok_is(tline, '-');
+        tline = tline->next;
+        if (!tok_is(tline, TOKEN_NUM)) {
+            nasm_nonfatal("`%s' expects a line increment", dname);
+            goto done;
+        }
+        m = readnum(tok_text(tline), &err);
+        if (minus)
+            m = -m;
+        tline = tline->next;
+    }
+    tline = skip_white(tline);
+    if (tline) {
+        if (tline->type == TOKEN_STR) {
+            const char *fname;
+            /*
+             * If this is a quoted string, ignore anything after
+             * it; this allows for compatibility with gcc's
+             * additional flags options.
+             */
+
+            fname = unquote_token_anystr(tline, BADCTL,
+                                          dname[0] == '#' ? STR_C : STR_NASM);
+            src_set_fname(fname);
+        } else {
+            char *fname;
+            fname = detoken(tline, false);
+            src_set_fname(fname);
+            nasm_free(fname);
+        }
+    }
+    src_set_linnum(k);
+
+    istk->where = src_where();
+    istk->lineinc = m;
+    goto done;
+
+done:
+    free_tlist(origline);
+    return DIRECTIVE_FOUND;
+}
+
+/*
+ * Used for the %arg and %local directives
+ */
+static void define_stack_smacro(const char *name, int offset)
+{
+    Token *tt;
+
+    tt = make_tok_char(NULL, ')');
+    tt = make_tok_num(tt, offset);
+    if (!tok_is(tt, '-'))
+        tt = make_tok_char(tt, '+');
+    tt = new_Token(tt, TOKEN_ID, StackPointer, 0);
+    tt = make_tok_char(tt, '(');
+
+    define_smacro(name, true, tt, NULL);
+}
+
+
+/*
+ * This implements the %assign directive: expand an smacro expression,
+ * then evaluate it, and assign the corresponding number to an smacro.
+ */
+static void assign_smacro(const char *mname, bool casesense,
+                          Token *tline, const char *dname)
+{
+    struct ppscan pps;
+    expr *evalresult;
+    struct tokenval tokval;
+
+    tline = expand_smacro(tline);
+
+    pps.tptr = tline;
+    pps.ntokens = -1;
+    tokval.t_type = TOKEN_INVALID;
+    evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+    free_tlist(tline);
+    if (!evalresult)
+        return;
+
+    if (tokval.t_type) {
+        nasm_warn(WARN_PP_TRAILING,
+                  "trailing garbage after expression ignored");
+    }
+    if (!is_simple(evalresult)) {
+        nasm_nonfatal("non-constant value given to `%s'", dname);
+    } else {
+	tline = make_tok_num(NULL, reloc_value(evalresult));
+
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a numeric token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        define_smacro(mname, casesense, tline, NULL);
+    }
+}
+
+/*
+ * Implement string concatenation as used by the %strcat directive
+ * and function.
+ */
+static Token *pp_strcat(Token *tline, const char *dname)
+{
+
+    size_t len;
+    Token *t;
+    Token *res = NULL;
+    char *q, *qbuf;
+
+    len = 0;
+    list_for_each(t, tline) {
+        switch (t->type) {
+        case TOKEN_WHITESPACE:
+        case TOKEN_COMMA:
+            break;
+        case TOKEN_STR:
+            unquote_token(t);
+            /* fall through */
+        case TOKEN_INTERNAL_STR:
+            len += t->len;
+            break;
+        default:
+            nasm_nonfatal("non-string passed to `%s': %s", dname,
+                          tok_text(t));
+            goto err;
+        }
+    }
+
+    q = qbuf = nasm_malloc(len+1);
+    list_for_each(t, tline) {
+        if (t->type == TOKEN_INTERNAL_STR)
+            q = mempcpy(q, tok_text(t), t->len);
+    }
+    *q = '\0';
+
+    res = make_tok_qstr_len(NULL, qbuf, len);
+    nasm_free(qbuf);
+err:
+    free_tlist(tline);
+    return res;
+}
+
+
+/*
+ * Implement substring extraction as used by the %substr directive
+ * and function.
+ */
+static Token *pp_substr_common(Token *t, int64_t start, int64_t count);
+
+static Token *pp_substr(Token *tline, const char *dname)
+{
+    int64_t start, count;
+    struct ppscan pps;
+    Token *t;
+    Token *res = NULL;
+    expr *evalresult;
+    struct tokenval tokval;
+
+    t = skip_white(tline);
+
+    if (!tok_is(t, TOKEN_STR)) {
+        nasm_nonfatal("`%s' requires a string as parameter", dname);
+        goto err;
+    }
+
+    pps.tptr = skip_white(t->next);
+    if (tok_is(pps.tptr, TOKEN_COMMA))
+        pps.tptr = skip_white(pps.tptr->next);
+    if (!pps.tptr) {
+        nasm_nonfatal("`%s' requires a starting index", dname);
+        goto err;
+    }
+
+    pps.ntokens = -1;
+    tokval.t_type = TOKEN_INVALID;
+    evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+    if (!evalresult) {
+        goto err;
+    } else if (!is_simple(evalresult)) {
+        nasm_nonfatal("non-constant value given to `%s'", dname);
+        goto err;
+    }
+    start = evalresult->value;
+
+    pps.tptr = skip_white(pps.tptr);
+    if (!pps.tptr) {
+        count = 1;  /* Backwards compatibility: one character */
+    } else {
+        tokval.t_type = TOKEN_INVALID;
+        evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+        if (!evalresult) {
+            goto err;
+        } else if (!is_simple(evalresult)) {
+            nasm_nonfatal("non-constant value given to `%s'", dname);
+            goto err;
+        }
+        count = evalresult->value;
+    }
+
+    res = pp_substr_common(t, start, count);
+
+err:
+    free_tlist(tline);
+    return res;
+}
+
+static Token *pp_substr_common(Token *t, int64_t start, int64_t count)
+{
+    size_t len;
+    const char *txt;
+
+    unquote_token(t);
+    len = t->len;
+
+    /* make start and count being in range */
+    start -= 1;                 /* First character is 1 */
+
+    if (start < 0)
+        start = 0;
+    if (count < 0)
+        count = len + count + 1 - start;
+    if (start + count > (int64_t)len)
+        count = len - start;
+    if (!len || count < 0 || start >=(int64_t)len)
+        start = -1, count = 0; /* empty string */
+
+    txt = (start < 0) ? "" : tok_text(t) + start;
+    return make_tok_qstr_len(NULL, txt, count);
+}
+
+/**
+ * find and process preprocessor directive in passed line
+ * Find out if a line contains a preprocessor directive, and deal
+ * with it if so.
+ *
+ * If a directive _is_ found, it is the responsibility of this routine
+ * (and not the caller) to free_tlist() the line.
+ *
+ * @param tline a pointer to the current tokeninzed line linked list
+ * @param output if this directive generated output
+ * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
+ *
+ */
+static int do_directive(Token *tline, Token **output)
+{
+    enum preproc_token op;
+    int j;
+    enum nolist_flags nolist;
+    bool casesense;
+    int offset;
+    const char *p;
+    char *q;
+    const char *found_path;
+    const char *mname;
+    struct ppscan pps;
+    Include *inc;
+    Context *ctx;
+    Cond *cond;
+    MMacro *mmac, **mmhead;
+    Token *t = NULL, *tt, *macro_start, *last, *origline;
+    Line *l;
+    struct tokenval tokval;
+    expr *evalresult;
+    int64_t count;
+    errflags severity;
+    const char *dname;          /* Name of directive, for messages */
+
+    *output = NULL;             /* No output generated */
+    origline = tline;
+
+    /* cpp-like line directive, must not be preceded by whitespace */
+    if (tok_is(tline, '#'))
+        return line_directive(origline, tline);
+
+    tline = skip_white(tline);
+    if (!tline)
+        return NO_DIRECTIVE_FOUND;
+
+    switch (tline->type) {
+    case TOKEN_PREPROC_ID:
+        dname = tok_text(tline);
+        /*
+         * For it to be a directive, the second character has to be an
+         * ASCII letter; this is a very quick and dirty test for that;
+         * all other cases will get rejected by the token hash.
+         */
+        if ((uint8_t)(dname[1] - 'A') > (uint8_t)('z' - 'A'))
+            return NO_DIRECTIVE_FOUND;
+
+        op = pp_token_hash(dname);
+        break;
+
+    case TOKEN_ID:
+        if (likely(!(ppopt & PP_TASM)))
+            return NO_DIRECTIVE_FOUND;
+
+        dname = tok_text(tline);
+        op = pp_tasm_token_hash(dname);
+        break;
+
+    default:
+        return NO_DIRECTIVE_FOUND;
+    }
+
+    switch (op) {
+    case PP_invalid:
+        return NO_DIRECTIVE_FOUND;
+
+    case PP_LINE:
+        /*
+         * %line directives are always processed immediately and
+         * unconditionally, as they are intended to reflect position
+         * in externally preprocessed sources.
+         */
+        return line_directive(origline, tline);
+
+    default:
+        break;
+    }
+
+    if (unlikely(ppopt & PP_TRIVIAL))
+        goto done;
+
+    casesense = true;
+    if (PP_HAS_CASE(op) & PP_INSENSITIVE(op)) {
+        casesense = false;
+        op--;
+    }
+
+    /*
+     * If we're in a non-emitting branch of a condition construct,
+     * or walking to the end of an already terminated %rep block,
+     * we should ignore all directives except for condition
+     * directives.
+     */
+    if (((istk->conds && !emitting(istk->conds->state)) ||
+         (istk->mstk.mstk && !istk->mstk.mstk->in_progress)) &&
+        !is_condition(op)) {
+        return NO_DIRECTIVE_FOUND;
+    }
+
+    /*
+     * If we're defining a macro or reading a %rep block, we should
+     * ignore all directives except for %macro/%imacro (which nest),
+     * %endm/%endmacro, %line and (only if we're in a %rep block) %endrep.
+     * If we're in a %rep block, another %rep nests, so should be let through.
+     */
+    if (defining && op != PP_MACRO && op != PP_RMACRO &&
+        op != PP_ENDMACRO && op != PP_ENDM &&
+        (defining->name || (op != PP_ENDREP && op != PP_REP))) {
+        return NO_DIRECTIVE_FOUND;
+    }
+
+    if (defining) {
+        if (op == PP_MACRO || op == PP_RMACRO) {
+            nested_mac_count++;
+            return NO_DIRECTIVE_FOUND;
+        } else if (nested_mac_count > 0) {
+            if (op == PP_ENDMACRO) {
+                nested_mac_count--;
+                return NO_DIRECTIVE_FOUND;
+            }
+        }
+        if (!defining->name) {
+            if (op == PP_REP) {
+                nested_rep_count++;
+                return NO_DIRECTIVE_FOUND;
+            } else if (nested_rep_count > 0) {
+                if (op == PP_ENDREP) {
+                    nested_rep_count--;
+                    return NO_DIRECTIVE_FOUND;
+                }
+            }
+        }
+    }
+
+    if (pp_op_may_be_function[op]) {
+        if (tok_is(skip_white(tline->next), '('))
+            return NO_DIRECTIVE_FOUND; /* Expand as a preprocessor function */
+    }
+
+    switch (op) {
+    default:
+        nasm_nonfatal("unknown preprocessor directive `%s'", dname);
+        return NO_DIRECTIVE_FOUND;      /* didn't get it */
+
+    case PP_PRAGMA:
+        /*
+         * %pragma namespace options...
+         *
+         * The namespace "preproc" is reserved for the preprocessor;
+         * all other namespaces generate a [pragma] assembly directive.
+         *
+         * Invalid %pragmas are ignored and may have different
+         * meaning in future versions of NASM.
+         */
+        t = tline;
+        tline = tline->next;
+        t->next = NULL;
+        tline = zap_white(expand_smacro(tline));
+        if (tok_is(tline, TOKEN_ID)) {
+            if (!nasm_stricmp(tok_text(tline), "preproc")) {
+                /* Preprocessor pragma */
+                do_pragma_preproc(tline);
+                free_tlist(tline);
+            } else {
+                /* Build the assembler directive */
+
+                /* Append bracket to the end of the output */
+                for (t = tline; t->next; t = t->next)
+                    ;
+                t->next = make_tok_char(NULL, ']');
+
+                /* Prepend "[pragma " */
+                t = new_White(tline);
+                t = new_Token(t, TOKEN_ID, "pragma", 6);
+                t = make_tok_char(t, '[');
+                tline = t;
+                *output = tline;
+            }
+        }
+        break;
+
+    case PP_STACKSIZE:
+    {
+        const char *arg;
+
+        /* Directive to tell NASM what the default stack size is. The
+         * default is for a 16-bit stack, and this can be overridden with
+         * %stacksize large.
+         */
+        tline = skip_white(tline->next);
+        if (!tline || tline->type != TOKEN_ID) {
+            nasm_nonfatal("`%s' missing size parameter", dname);
+            break;
+        }
+
+        arg = tok_text(tline);
+
+        if (nasm_stricmp(arg, "flat") == 0) {
+            /* All subsequent ARG directives are for a 32-bit stack */
+            StackSize = 4;
+            StackPointer = "ebp";
+            ArgOffset = 8;
+            LocalOffset = 0;
+        } else if (nasm_stricmp(arg, "flat64") == 0) {
+            /* All subsequent ARG directives are for a 64-bit stack */
+            StackSize = 8;
+            StackPointer = "rbp";
+            ArgOffset = 16;
+            LocalOffset = 0;
+        } else if (nasm_stricmp(arg, "large") == 0) {
+            /* All subsequent ARG directives are for a 16-bit stack,
+             * far function call.
+             */
+            StackSize = 2;
+            StackPointer = "bp";
+            ArgOffset = 4;
+            LocalOffset = 0;
+        } else if (nasm_stricmp(arg, "small") == 0) {
+            /* All subsequent ARG directives are for a 16-bit stack,
+             * far function call. We don't support near functions.
+             */
+            StackSize = 2;
+            StackPointer = "bp";
+            ArgOffset = 6;
+            LocalOffset = 0;
+        } else {
+            nasm_nonfatal("`%s' invalid size type", dname);
+        }
+        break;
+    }
+
+    case PP_ARG:
+        /* TASM like ARG directive to define arguments to functions, in
+         * the following form:
+         *
+         *      ARG arg1:WORD, arg2:DWORD, arg4:QWORD
+         */
+        offset = ArgOffset;
+        do {
+            const char *arg;
+            int size = StackSize;
+
+            /* Find the argument name */
+            tline = skip_white(tline->next);
+            if (!tline || tline->type != TOKEN_ID) {
+                nasm_nonfatal("`%s' missing argument parameter", dname);
+                goto done;
+            }
+            arg = tok_text(tline);
+
+            /* Find the argument size type */
+            tline = tline->next;
+            if (!tok_is(tline, ':')) {
+                nasm_nonfatal("syntax error processing `%s' directive", dname);
+                goto done;
+            }
+            tline = tline->next;
+            if (!tok_is(tline, TOKEN_ID)) {
+                nasm_nonfatal("`%s' missing size type parameter", dname);
+                goto done;
+            }
+
+            /* Allow macro expansion of type parameter */
+            tt = tokenize(tok_text(tline));
+            tt = expand_smacro(tt);
+            size = parse_size(tok_text(tt));
+            if (!size) {
+                nasm_nonfatal("invalid size type for `%s' missing directive", dname);
+                free_tlist(tt);
+                goto done;
+            }
+            free_tlist(tt);
+
+            /* Round up to even stack slots */
+            size = ALIGN(size, StackSize);
+
+            /* Now define the macro for the argument */
+            define_stack_smacro(arg, offset);
+            offset += size;
+
+            /* Move to the next argument in the list */
+            tline = skip_white(tline->next);
+        } while (tok_is(tline, ','));
+        ArgOffset = offset;
+        break;
+
+    case PP_LOCAL:
+    {
+        int total_size = 0;
+
+        /* TASM like LOCAL directive to define local variables for a
+         * function, in the following form:
+         *
+         *      LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
+         *
+         * The '= LocalSize' at the end is ignored by NASM, but is
+         * required by TASM to define the local parameter size (and used
+         * by the TASM macro package).
+         */
+        offset = LocalOffset;
+        do {
+            const char *local;
+            int size = StackSize;
+
+            /* Find the argument name */
+            tline = skip_white(tline->next);
+            if (!tline || tline->type != TOKEN_ID) {
+                nasm_nonfatal("`%s' missing argument parameter", dname);
+                goto done;
+            }
+            local = tok_text(tline);
+
+            /* Find the argument size type */
+            tline = tline->next;
+            if (!tok_is(tline, ':')) {
+                nasm_nonfatal("syntax error processing `%s' directive", dname);
+                goto done;
+            }
+            tline = tline->next;
+            if (!tok_is(tline, TOKEN_ID)) {
+                nasm_nonfatal("`%s' missing size type parameter", dname);
+                goto done;
+            }
+
+            /* Allow macro expansion of type parameter */
+            tt = tokenize(tok_text(tline));
+            tt = expand_smacro(tt);
+            size = parse_size(tok_text(tt));
+            if (!size) {
+                nasm_nonfatal("invalid size type for `%s' missing directive", dname);
+                free_tlist(tt);
+                goto done;
+            }
+            free_tlist(tt);
+
+            /* Round up to even stack slots */
+            size = ALIGN(size, StackSize);
+
+            offset += size;     /* Negative offset, increment before */
+
+            /* Now define the macro for the argument */
+            define_stack_smacro(local, -offset);
+
+            /* How is this different from offset? */
+            total_size += size;
+
+            /* Move to the next argument in the list */
+            tline = skip_white(tline->next);
+        } while (tok_is(tline, ','));
+
+        /* Now define the assign to setup the enter_c macro correctly */
+        tt = make_tok_num(NULL, total_size);
+        tt = make_tok_char(tt, '+');
+        tt = new_Token(tt, TOKEN_LOCAL_MACRO, "%$localsize", 11);
+        assign_smacro("%$localsize", true, tt, dname);
+
+        LocalOffset = offset;
+        break;
+    }
+    case PP_CLEAR:
+    {
+        bool context = false;
+
+        t = tline->next = expand_smacro(tline->next);
+        t = skip_white(t);
+        if (!t) {
+            /* Emulate legacy behavior */
+            do_clear(CLEAR_DEFINE|CLEAR_MMACRO, false);
+        } else {
+            while ((t = skip_white(t)) && t->type == TOKEN_ID) {
+                const char *txt = tok_text(t);
+                if (!nasm_stricmp(txt, "all")) {
+                    do_clear(CLEAR_ALL, context);
+                } else if (!nasm_stricmp(txt, "define") ||
+                           !nasm_stricmp(txt, "def") ||
+                           !nasm_stricmp(txt, "smacro")) {
+                    do_clear(CLEAR_DEFINE, context);
+                } else if (!nasm_stricmp(txt, "defalias") ||
+                           !nasm_stricmp(txt, "alias") ||
+                           !nasm_stricmp(txt, "salias")) {
+                    do_clear(CLEAR_DEFALIAS, context);
+                } else if (!nasm_stricmp(txt, "alldef") ||
+                           !nasm_stricmp(txt, "alldefine")) {
+                    do_clear(CLEAR_ALLDEFINE, context);
+                } else if (!nasm_stricmp(txt, "macro") ||
+                           !nasm_stricmp(txt, "mmacro")) {
+                    do_clear(CLEAR_MMACRO, context);
+                } else if (!nasm_stricmp(txt, "context") ||
+                           !nasm_stricmp(txt, "ctx")) {
+                    context = true;
+                } else if (!nasm_stricmp(txt, "global")) {
+                    context = false;
+                } else if (!nasm_stricmp(txt, "nothing") ||
+                         !nasm_stricmp(txt, "none") ||
+                         !nasm_stricmp(txt, "ignore") ||
+                         !nasm_stricmp(txt, "-") ||
+                         !nasm_stricmp(txt, "--")) {
+                    /* Do nothing */
+                } else {
+                    nasm_nonfatal("invalid option to %s: %s", dname, txt);
+                    t = NULL;
+                }
+            }
+        }
+
+        t = skip_white(t);
+        if (t) {
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after `%s' ignored", dname);
+        }
+        break;
+    }
+
+    case PP_DEPEND:
+        t = tline->next = expand_smacro(tline->next);
+        t = skip_white(t);
+        if (!t || (t->type != TOKEN_STR &&
+                   t->type != TOKEN_INTERNAL_STR)) {
+            nasm_nonfatal("`%s' expects a file name", dname);
+            goto done;
+        }
+        if (skip_white(t->next)) {
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after `%s' ignored", dname);
+        }
+
+        strlist_add(deplist, unquote_token_cstr(t));
+        goto done;
+
+    case PP_INCLUDE:
+    case PP_REQUIRE:
+        t = tline->next = expand_smacro(tline->next);
+        t = skip_white(t);
+
+        if (!t || (t->type != TOKEN_STR &&
+                   t->type != TOKEN_INTERNAL_STR)) {
+            nasm_nonfatal("`%s' expects a file name", dname);
+            goto done;
+        }
+        if (skip_white(t->next)) {
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after `%s' ignored", dname);
+        }
+        p = unquote_token_cstr(t);
+        nasm_new(inc);
+        inc->next = istk;
+        found_path = NULL;
+        inc->fp = inc_fopen(p, deplist, &found_path,
+                            (pp_mode == PP_DEPS) ? INC_OPTIONAL :
+                            (op == PP_REQUIRE) ? INC_REQUIRED :
+                            INC_NEEDED, NF_TEXT);
+        if (!inc->fp) {
+            /* -MG given but file not found, or repeated %require */
+            nasm_free(inc);
+        } else {
+            inc->nolist  = istk->nolist;
+            inc->noline  = istk->noline;
+            inc->where   = istk->where;
+            inc->lineinc = 0;
+            istk = inc;
+            if (!istk->noline) {
+                src_set(0, found_path ? found_path : p);
+                istk->where = src_where();
+                istk->lineinc = 1;
+                if (ppdbg & PDBG_INCLUDE)
+                    dfmt->debug_include(true, istk->next->where, istk->where);
+            }
+            if (!istk->nolist)
+                lfmt->uplevel(LIST_INCLUDE, 0);
+        }
+        break;
+
+    case PP_USE:
+    {
+        const struct use_package *pkg;
+        const char *name;
+
+        pkg = get_use_pkg(tline->next, dname, &name);
+        if (!name)
+            goto done;
+        if (!pkg) {
+            nasm_nonfatal("unknown `%s' package: `%s'", dname, name);
+        } else if (!use_loaded[pkg->index]) {
+            /*
+             * Not already included, go ahead and include it.
+             * Treat it as an include file for the purpose of
+             * producing a listing.
+             */
+            use_loaded[pkg->index] = true;
+            stdmacpos = pkg->macros;
+            nasm_new(inc);
+            inc->next = istk;
+            if (!list_option('b')) {
+                inc->nolist++;
+                inc->noline++;
+            }
+            istk = inc;
+            if (!istk->nolist)
+                lfmt->uplevel(LIST_INCLUDE, 0);
+            if (!inc->noline)
+                src_set(0, NULL);
+        }
+        break;
+    }
+    case PP_PUSH:
+    case PP_REPL:
+    case PP_POP:
+        tline = tline->next;
+        tline = skip_white(tline);
+        tline = expand_id(tline);
+        if (tline) {
+            if (!tok_is(tline, TOKEN_ID)) {
+                nasm_nonfatal("`%s' expects a context identifier", dname);
+                goto done;
+            }
+            if (skip_white(tline->next)) {
+                nasm_warn(WARN_PP_TRAILING, "trailing garbage after `%s' ignored",
+                           dname);
+            }
+            p = tok_text(tline);
+        } else {
+            p = NULL; /* Anonymous */
+        }
+
+        if (op == PP_PUSH) {
+            nasm_new(ctx);
+            ctx->depth = cstk ? cstk->depth + 1 : 1;
+            ctx->next = cstk;
+            ctx->name = p ? nasm_strdup(p) : NULL;
+            ctx->number = unique++;
+            cstk = ctx;
+        } else {
+            /* %pop or %repl */
+            if (!cstk) {
+                nasm_nonfatal("`%s': context stack is empty", dname);
+            } else if (op == PP_POP) {
+                if (p && (!cstk->name || nasm_stricmp(p, cstk->name)))
+                    nasm_nonfatal("`%s' in wrong context: %s, "
+                               "expected %s",
+                               dname, cstk->name ? cstk->name : "anonymous", p);
+                else
+                    ctx_pop();
+            } else {
+                /* op == PP_REPL */
+                nasm_free((char *)cstk->name);
+                cstk->name = p ? nasm_strdup(p) : NULL;
+                p = NULL;
+            }
+        }
+        break;
+    case PP_FATAL:
+        severity = ERR_FATAL;
+        goto issue_error;
+    case PP_ERROR:
+        severity = ERR_NONFATAL|ERR_PASS2;
+        goto issue_error;
+    case PP_WARNING:
+        /*!
+         *!user [on] %warning directives
+         *!  controls output of \c{%warning} directives (see \k{pperror}).
+         */
+        severity = ERR_WARNING|WARN_USER|ERR_PASS2;
+        goto issue_error;
+
+issue_error:
+    {
+        /* Only error out if this is the final pass */
+        tline->next = expand_smacro(tline->next);
+        tline = tline->next;
+        tline = skip_white(tline);
+        t = tline ? tline->next : NULL;
+        t = skip_white(t);
+        if (tok_is(tline, TOKEN_STR) && !t) {
+            /* The line contains only a quoted string */
+            p = unquote_token(tline); /* Ignore NUL character truncation */
+            nasm_error(severity, "%s",  p);
+        } else {
+            /* Not a quoted string, or more than a quoted string */
+            q = detoken(tline, false);
+            nasm_error(severity, "%s",  q);
+            nasm_free(q);
+        }
+        break;
+    }
+
+    CASE_PP_IF:
+        if (istk->conds && !emitting(istk->conds->state))
+            j = COND_NEVER;
+        else {
+            j = if_condition(tline->next, op);
+            tline->next = NULL; /* it got freed */
+        }
+        cond = nasm_malloc(sizeof(Cond));
+        cond->next = istk->conds;
+        cond->state = j;
+        istk->conds = cond;
+        if(istk->mstk.mstk)
+            istk->mstk.mstk->condcnt++;
+        break;
+
+    CASE_PP_ELIF:
+        if (!istk->conds) {
+            nasm_nonfatal("`%s': no matching `%%if'", dname);
+            break;
+        }
+        switch(istk->conds->state) {
+        case COND_IF_TRUE:
+            istk->conds->state = COND_DONE;
+            break;
+
+        case COND_DONE:
+        case COND_NEVER:
+            break;
+
+        case COND_ELSE_TRUE:
+        case COND_ELSE_FALSE:
+            /*!
+             *!pp-else-elif [on] %elif after %else
+             *!  warns that an \c{%%elif}-type directive was encountered
+             *!  after \c[%%else} has already been encounted. As a result, the
+             *!  content of the \c{%%elif} will never be expanded.
+             */
+            nasm_warn(WARN_PP_ELSE_ELIF|ERR_PP_PRECOND,
+                       "`%s' after `%%else', ignoring content", dname);
+            istk->conds->state = COND_NEVER;
+            break;
+
+        case COND_IF_FALSE:
+            /*
+             * IMPORTANT: In the case of %if, we will already have
+             * called expand_mmac_params(); however, if we're
+             * processing an %elif we must have been in a
+             * non-emitting mode, which would have inhibited
+             * the normal invocation of expand_mmac_params().
+             * Therefore, we have to do it explicitly here.
+             */
+            j = if_condition(expand_mmac_params(tline->next), op);
+            tline->next = NULL; /* it got freed */
+            istk->conds->state = j;
+            break;
+        }
+        break;
+
+    case PP_ELSE:
+        if (tline->next)
+            nasm_warn(WARN_PP_TRAILING|ERR_PP_PRECOND,
+                      "trailing garbage after `%s' ignored", dname);
+        if (!istk->conds) {
+	    nasm_nonfatal("`%s': no matching `%%if'", dname);
+            break;
+        }
+        switch(istk->conds->state) {
+        case COND_IF_TRUE:
+        case COND_DONE:
+            istk->conds->state = COND_ELSE_FALSE;
+            break;
+
+        case COND_NEVER:
+            break;
+
+        case COND_IF_FALSE:
+            istk->conds->state = COND_ELSE_TRUE;
+            break;
+
+        case COND_ELSE_TRUE:
+        case COND_ELSE_FALSE:
+            /*!
+             *!pp-else-else [on] %else after %else
+             *!  warns that a second \c{%else} clause was found for
+             *!  the same \c{%if} statement. The content of this \c{%else}
+             *!  clause will never be expanded.
+             */
+            nasm_warn(WARN_PP_ELSE_ELSE|ERR_PP_PRECOND,
+                      "`%s' after `%%else', ignoring content", dname);
+            istk->conds->state = COND_NEVER;
+            break;
+        }
+        break;
+
+    case PP_ENDIF:
+        if (tline->next) {
+            nasm_warn(WARN_PP_TRAILING|ERR_PP_PRECOND,
+                      "trailing garbage after `%s' ignored", dname);
+        }
+        if (!istk->conds) {
+            nasm_nonfatal("`%s': no matching `%%if'", dname);
+            break;
+        }
+        cond = istk->conds;
+        istk->conds = cond->next;
+        nasm_free(cond);
+        if(istk->mstk.mstk)
+            istk->mstk.mstk->condcnt--;
+        break;
+
+    case PP_RMACRO:
+    case PP_MACRO:
+    {
+        MMacro *def;
+
+        nasm_assert(!defining);
+        nasm_new(def);
+        def->casesense = casesense;
+        /*
+         * dstk.mstk points to the previous definition bracket,
+         * whereas dstk.mmac points to the topmost mmacro, which
+         * in this case is the one we are just starting to create.
+         */
+        def->dstk.mstk = defining;
+        def->dstk.mmac = def;
+        if (op == PP_RMACRO)
+            def->max_depth = nasm_limit[LIMIT_MACRO_LEVELS];
+        if (!parse_mmacro_spec(tline, def, dname)) {
+            nasm_free(def);
+            goto done;
+        }
+
+        defining = def;
+        defining->where = istk->where;
+
+        mmac = (MMacro *) hash_findix(&mmacros, defining->name);
+        while (mmac) {
+            if (!strcmp(mmac->name, defining->name) &&
+                (mmac->nparam_min <= defining->nparam_max
+                 || defining->plus)
+                && (defining->nparam_min <= mmac->nparam_max
+                    || mmac->plus)) {
+                /*!
+                 *!pp-macro-redef-multi [on] redefining multi-line macro
+                 *!  warns that a multi-line macro is being redefined,
+                 *!  without first removing the old definition with
+                 *!  \c{%unmacro}.
+                 */
+                nasm_warn(WARN_PP_MACRO_REDEF_MULTI,
+                          "redefining multi-line macro `%s'",
+                           defining->name);
+                break;
+            }
+            mmac = mmac->next;
+        }
+        break;
+    }
+
+    case PP_ENDM:
+    case PP_ENDMACRO:
+        if (!(defining && defining->name)) {
+            nasm_nonfatal("`%s': not defining a macro", tok_text(tline));
+            goto done;
+        }
+        mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name);
+        defining->next = *mmhead;
+        *mmhead = defining;
+        defining = NULL;
+        break;
+
+    case PP_EXITMACRO:
+        /*
+         * We must search along istk->expansion until we hit a
+         * macro-end marker for a macro with a name. Then we
+         * bypass all lines between exitmacro and endmacro.
+         */
+        list_for_each(l, istk->expansion)
+            if (l->finishes && l->finishes->name)
+                break;
+
+        if (l) {
+            /*
+             * Remove all conditional entries relative to this
+             * macro invocation. (safe to do in this context)
+             */
+            for ( ; l->finishes->condcnt > 0; l->finishes->condcnt --) {
+                cond = istk->conds;
+                if (!cond) {
+                    l->finishes->condcnt = 0;
+                    break;      /* Possible in case of invalid nesting */
+                }
+                istk->conds = cond->next;
+                nasm_free(cond);
+            }
+            istk->expansion = l;
+        } else {
+            nasm_nonfatal("`%%exitmacro' not within `%%macro' block");
+        }
+        break;
+
+    case PP_UNIMACRO:
+        casesense = false;
+        /* fall through */
+    case PP_UNMACRO:
+    {
+        MMacro **mmac_p;
+        MMacro spec;
+
+        nasm_zero(spec);
+        spec.casesense = casesense;
+        if (!parse_mmacro_spec(tline, &spec, dname)) {
+            goto done;
+        }
+        mmac_p = (MMacro **) hash_findi(&mmacros, spec.name, NULL);
+        if (!mmac_p) {
+            /* No such macro */
+            free_tlist(spec.dlist);
+            break;
+        }
+
+        /* Check the macro to be undefined is not being expanded */
+        list_for_each(l, istk->expansion) {
+            if (l->finishes == *mmac_p) {
+                nasm_nonfatal("`%%unmacro' can't undefine the macro being expanded");
+                /*
+                 * Do not release the macro instance to avoid using the freed
+                 * memory while proceeding the expansion.
+                 */
+                goto done;
+            }
+        }
+
+        while (mmac_p && *mmac_p) {
+            mmac = *mmac_p;
+            if (mmac->casesense == spec.casesense &&
+                !mstrcmp(mmac->name, spec.name, spec.casesense) &&
+                mmac->nparam_min == spec.nparam_min &&
+                mmac->nparam_max == spec.nparam_max &&
+                mmac->plus == spec.plus) {
+                *mmac_p = mmac->next;
+                free_mmacro(mmac);
+            } else {
+                mmac_p = &mmac->next;
+            }
+        }
+        free_tlist(spec.dlist);
+        break;
+    }
+
+    case PP_ROTATE:
+        while (tok_white(tline->next))
+            tline = tline->next;
+        if (!tline->next) {
+            free_tlist(origline);
+            nasm_nonfatal("`%s' missing rotate count", dname);
+            return DIRECTIVE_FOUND;
+        }
+        t = expand_smacro(tline->next);
+        tline->next = NULL;
+        pps.tptr = tline = t;
+	pps.ntokens = -1;
+        tokval.t_type = TOKEN_INVALID;
+        evalresult =
+            evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+        free_tlist(tline);
+        if (!evalresult)
+            return DIRECTIVE_FOUND;
+        if (tokval.t_type) {
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after expression ignored");
+        }
+        if (!is_simple(evalresult)) {
+            nasm_nonfatal("non-constant value given to `%s'", dname);
+            return DIRECTIVE_FOUND;
+        }
+        mmac = istk->mstk.mmac;
+        if (!mmac) {
+            nasm_nonfatal("`%s' invoked outside a macro call", dname);;
+        } else if (mmac->nparam == 0) {
+            nasm_nonfatal("`%s' invoked within macro without parameters", dname);
+        } else {
+            int rotate = mmac->rotate + reloc_value(evalresult);
+
+            rotate %= (int)mmac->nparam;
+            if (rotate < 0)
+                rotate += mmac->nparam;
+
+            mmac->rotate = rotate;
+        }
+        break;
+
+    case PP_REP:
+    {
+        MMacro *tmp_defining;
+
+        nolist = 0;
+        tline = skip_white(tline->next);
+        if (tok_is(tline, TOKEN_ID) && tline->len == 7 &&
+	    !nasm_memicmp(tline->text.a, ".nolist", 7)) {
+            if (!list_option('f'))
+                nolist |= NL_LIST; /* ... but update line numbers */
+            tline = skip_white(tline->next);
+        }
+
+        if (tline) {
+            pps.tptr = expand_smacro(tline);
+	    pps.ntokens = -1;
+            tokval.t_type = TOKEN_INVALID;
+            /* XXX: really critical?! */
+            evalresult =
+                evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+            if (!evalresult)
+                goto done;
+            if (tokval.t_type)
+                nasm_warn(WARN_PP_TRAILING, "trailing garbage after expression ignored");
+            if (!is_simple(evalresult)) {
+                nasm_nonfatal("non-constant value given to `%s'", dname);
+                goto done;
+            }
+            count = reloc_value(evalresult);
+            if (count > nasm_limit[LIMIT_REP]) {
+                nasm_nonfatal("`%s' count %"PRId64" exceeds limit (currently %"PRId64")",
+                              dname, count, nasm_limit[LIMIT_REP]);
+                count = 0;
+            } else if (count < 0) {
+                /*!
+                 *!pp-rep-negative [on] regative %rep count
+                 *!=negative-rep
+                 *!  warns about a negative count given to the \c{%rep}
+                 *!  preprocessor directive.
+                 */
+                nasm_warn(ERR_PASS2|WARN_PP_REP_NEGATIVE,
+                          "negative `%s' count: %"PRId64, dname, count);
+                count = 0;
+            } else {
+                count++;
+            }
+        } else {
+            nasm_nonfatal("`%s' expects a repeat count", dname);
+            count = 0;
+        }
+        tmp_defining = defining;
+        nasm_new(defining);
+        defining->nolist = nolist;
+        defining->in_progress = count;
+        defining->mstk = istk->mstk;
+        defining->dstk.mstk = tmp_defining;
+        defining->dstk.mmac = tmp_defining ? tmp_defining->dstk.mmac : NULL;
+        defining->where = istk->where;
+        break;
+    }
+
+    case PP_ENDREP:
+        if (!defining || defining->name) {
+            nasm_nonfatal("`%%endrep': no matching `%%rep'");
+            goto done;
+        }
+
+        /*
+         * Now we have a "macro" defined - although it has no name
+         * and we won't be entering it in the hash tables - we must
+         * push a macro-end marker for it on to istk->expansion.
+         * After that, it will take care of propagating itself (a
+         * macro-end marker line for a macro which is really a %rep
+         * block will cause the macro to be re-expanded, complete
+         * with another macro-end marker to ensure the process
+         * continues) until the whole expansion is forcibly removed
+         * from istk->expansion by a %exitrep.
+         */
+        nasm_new(l);
+        l->next = istk->expansion;
+        l->finishes = defining;
+        l->first = NULL;
+        l->where = src_where();
+        istk->expansion = l;
+
+        istk->mstk.mstk = defining;
+
+        /* A loop does not change istk->noline */
+        istk->nolist += !!(defining->nolist & NL_LIST);
+        if (!istk->nolist)
+            lfmt->uplevel(LIST_MACRO, 0);
+
+        defining = defining->dstk.mstk;
+        break;
+
+    case PP_EXITREP:
+        /*
+         * We must search along istk->expansion until we hit a
+         * macro-end marker for a macro with no name. Then we set
+         * its `in_progress' flag to 0.
+         */
+        list_for_each(l, istk->expansion)
+            if (l->finishes && !l->finishes->name)
+                break;
+
+        if (l)
+            l->finishes->in_progress = 0;
+        else
+            nasm_nonfatal("`%%exitrep' not within `%%rep' block");
+        break;
+
+    case PP_DEFINE:
+    case PP_XDEFINE:
+    case PP_DEFALIAS:
+    {
+        SMacro tmpl;
+        Token **lastp;
+        int nparam;
+
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        nasm_zero(tmpl);
+        lastp = &tline->next;
+        nparam = parse_smacro_template(&lastp, &tmpl);
+        tline = *lastp;
+        *lastp = NULL;
+
+        if (unlikely(op == PP_DEFALIAS)) {
+            macro_start = tline;
+            if (!is_macro_id(macro_start)) {
+                nasm_nonfatal("`%s' expects a macro identifier to alias",
+                              dname);
+                goto done;
+            }
+            tt = macro_start->next;
+            macro_start->next = NULL;
+            tline = tline->next;
+            tline = skip_white(tline);
+            if (tline && tline->type) {
+                nasm_warn(WARN_PP_TRAILING,
+                          "trailing garbage after aliasing identifier ignored");
+            }
+            free_tlist(tt);
+            tmpl.alias = true;
+        } else {
+            if (op == PP_XDEFINE) {
+                /* Protect macro parameter tokens */
+                if (nparam)
+                    mark_smac_params(tline, &tmpl, TOKEN_XDEF_PARAM);
+                tline = expand_smacro(tline);
+            }
+            macro_start = tline;
+        }
+
+        /*
+         * Good. We now have a macro name, a parameter count, and a
+         * token list (in reverse order) for an expansion. We ought
+         * to be OK just to create an SMacro, store it, and let
+         * free_tlist have the rest of the line (which we have
+         * carefully re-terminated after chopping off the expansion
+         * from the end).
+         */
+        define_smacro(mname, casesense, macro_start, &tmpl);
+        break;
+    }
+
+    case PP_UNDEF:
+    case PP_UNDEFALIAS:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+        if (tline->next)
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after macro name ignored");
+
+        undef_smacro(mname, op == PP_UNDEFALIAS);
+        break;
+
+    case PP_DEFSTR:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = expand_smacro(tline->next);
+        last->next = NULL;
+
+        tline = zap_white(tline);
+        q = detoken(tline, false);
+        macro_start = make_tok_qstr(NULL, q);
+        nasm_free(q);
+
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a string token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        define_smacro(mname, casesense, macro_start, NULL);
+        break;
+
+    case PP_DEFTOK:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = expand_smacro(tline->next);
+        last->next = NULL;
+
+        t = skip_white(tline);
+        /* t should now point to the string */
+        if (!tok_is(t, TOKEN_STR)) {
+            nasm_nonfatal("`%s' requires string as second parameter", dname);
+            free_tlist(tline);
+            goto done;
+        }
+
+        /*
+         * Convert the string to a token stream.
+         */
+        macro_start = tokenize(unquote_token_cstr(t));
+
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a numeric token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        define_smacro(mname, casesense, macro_start, NULL);
+        free_tlist(tline);
+        break;
+
+    case PP_PATHSEARCH:
+    {
+        const char *found_path;
+
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = expand_smacro(tline->next);
+        last->next = NULL;
+
+        t = skip_white(tline);
+        if (!t || (t->type != TOKEN_STR &&
+                   t->type != TOKEN_INTERNAL_STR)) {
+            nasm_nonfatal("`%s' expects a file name", dname);
+            free_tlist(tline);
+            goto done;
+        }
+        if (t->next)
+            nasm_warn(WARN_PP_TRAILING,
+                      "trailing garbage after `%s' ignored", dname);
+
+	p = unquote_token_cstr(t);
+
+        inc_fopen(p, NULL, &found_path, INC_PROBE, NF_BINARY);
+        if (!found_path)
+            found_path = p;
+	macro_start = make_tok_qstr(NULL, found_path);
+
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a string token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        define_smacro(mname, casesense, macro_start, NULL);
+        free_tlist(tline);
+        break;
+    }
+
+    case PP_STRLEN:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = expand_smacro(tline->next);
+        last->next = NULL;
+
+        t = skip_white(tline);
+        /* t should now point to the string */
+        if (!tok_is(t, TOKEN_STR)) {
+            nasm_nonfatal("`%s' requires string as second parameter", dname);
+            free_tlist(tline);
+            free_tlist(origline);
+            return DIRECTIVE_FOUND;
+        }
+
+	unquote_token(t);
+        macro_start = make_tok_num(NULL, t->len);
+
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a numeric token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        define_smacro(mname, casesense, macro_start, NULL);
+        free_tlist(tline);
+        free_tlist(origline);
+        return DIRECTIVE_FOUND;
+
+    case PP_STRCAT:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = expand_smacro(tline->next);
+        last->next = NULL;
+
+        macro_start = pp_strcat(tline, dname);
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a string token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        if (macro_start)
+            define_smacro(mname, casesense, macro_start, NULL);
+        break;
+
+    case PP_SUBSTR:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = expand_smacro(tline->next);
+        last->next = NULL;
+
+        macro_start = pp_substr(tline, dname);
+        /*
+         * We now have a macro name, an implicit parameter count of
+         * zero, and a string token to use as an expansion. Create
+         * and store an SMacro.
+         */
+        if (macro_start)
+            define_smacro(mname, casesense, macro_start, NULL);
+        break;
+
+    case PP_ASSIGN:
+        if (!(mname = get_id(&tline, dname)))
+            goto done;
+
+        last = tline;
+        tline = tline->next;
+        last->next = NULL;
+        assign_smacro(mname, casesense, tline, dname);
+        goto done;
+
+    case PP_ALIASES:
+        tline = tline->next;
+        tline = expand_smacro(tline);
+        ppconf.noaliases = !pp_get_boolean_option(tline, !ppconf.noaliases);
+        break;
+
+    case PP_LINE:
+        nasm_panic("`%s' directive not preprocessed early", dname);
+        break;
+
+    case PP_NULL:
+        /* Goes nowhere, does nothing... */
+        break;
+
+    }
+
+done:
+    free_tlist(origline);
+    return DIRECTIVE_FOUND;
+}
+
+/*
+ * Ensure that a macro parameter contains a condition code and
+ * nothing else. Return the condition code index if so, or -1
+ * otherwise.
+ */
+static int find_cc(Token * t)
+{
+    Token *tt;
+
+    if (!t)
+        return -1;              /* Probably a %+ without a space */
+
+    t = skip_white(t);
+    if (!tok_is(t, TOKEN_ID))
+        return -1;
+    tt = t->next;
+    tt = skip_white(tt);
+    if (tok_isnt(tt, ','))
+        return -1;
+
+    return bsii(tok_text(t), (const char **)conditions,
+		ARRAY_SIZE(conditions));
+}
+
+enum concat_flags {
+    CONCAT_ID             = 0x01,
+    CONCAT_LOCAL_MACRO    = 0x02,
+    CONCAT_ENVIRON        = 0x04,
+    CONCAT_PREPROC_ID     = 0x08,
+    CONCAT_NUM            = 0x10,
+    CONCAT_FLOAT          = 0x20,
+    CONCAT_OP             = 0x40  /* Operators */
+};
+
+struct concat_mask {
+    enum concat_flags mask_head;
+    enum concat_flags mask_tail;
+};
+
+
+static inline bool pp_concat_match(const Token *t, enum concat_flags mask)
+{
+    enum concat_flags ctype = 0;
+
+    if (!t)
+        return false;
+
+    switch (t->type) {
+    case TOKEN_ID:
+    case TOKEN_QMARK:           /* Keyword, treated as ID for pasting */
+        ctype = CONCAT_ID;
+        break;
+    case TOKEN_LOCAL_MACRO:
+        ctype = CONCAT_LOCAL_MACRO;
+        break;
+    case TOKEN_ENVIRON:
+        ctype = CONCAT_ENVIRON;
+        break;
+    case TOKEN_PREPROC_ID:
+        ctype = CONCAT_PREPROC_ID;
+        break;
+    case TOKEN_NUM:
+    case TOKEN_FLOAT:
+        ctype = CONCAT_NUM;
+        break;
+    case TOKEN_HERE:
+    case TOKEN_BASE:
+        /* NASM 2.15 treats these as operators, but is that sane? */
+        ctype = CONCAT_OP;
+        break;
+    case TOKEN_OTHER:
+        ctype = CONCAT_OP;      /* For historical reasons */
+        break;
+    default:
+        if (t->type > TOKEN_WHITESPACE && t->type < TOKEN_MAX_OPERATOR)
+            ctype = CONCAT_OP;
+        else
+            ctype = 0;
+    }
+
+    return !!(ctype & mask);
+}
+
+/*
+ * This routines walks over tokens stream and handles tokens
+ * pasting, if @handle_explicit passed then explicit pasting
+ * term is handled, otherwise -- implicit pastings only.
+ * The @m array can contain a series of token types which are
+ * executed as separate passes.
+ */
+static bool paste_tokens(Token **head, const struct concat_mask *m,
+                         size_t mnum, bool handle_explicit)
+{
+    Token *tok, *t, *next, **prev_next, **prev_nonspace, **nextp;
+    bool pasted = false;
+    char *buf, *p;
+    size_t len, i;
+
+    /*
+     * The last token before pasting. We need it
+     * to be able to connect new handled tokens.
+     * In other words if there were a tokens stream
+     *
+     * A -> B -> C -> D
+     *
+     * and we've joined tokens B and C, the resulting
+     * stream should be
+     *
+     * A -> BC -> D
+     */
+    tok = *head;
+    prev_next = prev_nonspace = head;
+
+    if (tok_white(tok) || tok_is(tok, TOKEN_PASTE))
+        prev_nonspace = NULL;
+
+    while (tok && (next = tok->next)) {
+        bool did_paste = false;
+
+        switch (tok->type) {
+        case TOKEN_WHITESPACE:
+            /* Zap redundant whitespaces */
+            tok->next = next = zap_white(next);
+            break;
+
+        case TOKEN_PASTE:
+            /* Explicit pasting */
+            if (!handle_explicit)
+                break;
+
+            did_paste = true;
+
+            /* Left pasting token is start of line, just drop %+ */
+            if (!prev_nonspace) {
+                prev_next = nextp = head;
+                t = NULL;
+            } else {
+                prev_next = prev_nonspace;
+                t = *prev_next;
+                nextp = &t->next;
+            }
+
+            /*
+             * Delete the %+ token itself plus any whitespace.
+             * In a sequence of %+ ... %+ ... %+ pasting sequences where
+             * some expansions in the middle have ended up empty,
+             * we can end up having multiple %+ tokens in a row;
+             * just drop whem in that case.
+             */
+            next = *nextp;
+            while (next) {
+                if (next->type == TOKEN_PASTE || next->type == TOKEN_WHITESPACE)
+                    next = delete_Token(next);
+                else
+                    break;
+            }
+            *nextp = next;
+
+            /*
+             * Nothing after? Just leave the existing token.
+             */
+            if (!next)
+                break;
+
+            if (!t) {
+                /* Nothing to actually paste, just zapping the paste */
+                *prev_next = tok = next;
+                break;
+            }
+
+            /* An actual paste */
+            p = buf = nasm_malloc(t->len + next->len + 1);
+            p = mempcpy(p, tok_text(t), t->len);
+            p = mempcpy(p, tok_text(next), next->len);
+            *p = '\0';
+            delete_Token(t);
+            t = tokenize(buf);
+            nasm_free(buf);
+
+            if (unlikely(!t)) {
+                /*
+                 * No output at all? Replace with a single whitespace.
+                 * This should never happen.
+                 */
+                tok = t = new_White(NULL);
+            } else {
+                *prev_nonspace = tok = t;
+            }
+            while (t->next)
+                t = t->next;    /* Find the last token produced */
+
+            /* Delete the second token and attach to the end of the list */
+            t->next = delete_Token(next);
+
+            /* We want to restart from the head of the pasted token */
+            *prev_next = next = tok;
+            break;
+
+        default:
+            /* implicit pasting */
+            for (i = 0; i < mnum; i++) {
+                if (pp_concat_match(tok, m[i].mask_head))
+                    break;
+            }
+
+            if (i >= mnum)
+                break;
+
+            len =  tok->len;
+            while (pp_concat_match(next, m[i].mask_tail)) {
+                len += next->len;
+                next = next->next;
+            }
+
+            /* No match or no text to process */
+            if (len == tok->len)
+                break;
+
+            p = buf = nasm_malloc(len + 1);
+            while (tok != next) {
+                p = mempcpy(p, tok_text(tok), tok->len);
+                tok = delete_Token(tok);
+            }
+            *p = '\0';
+            *prev_next = tok = t = tokenize(buf);
+            nasm_free(buf);
+
+            /*
+             * Connect pasted into original stream,
+             * ie A -> new-tokens -> B
+             */
+            while ((tok = t->next)) {
+                if (tok->type != TOKEN_WHITESPACE && tok->type != TOKEN_PASTE)
+                    prev_nonspace = &t->next;
+                t = tok;
+            }
+
+            t->next = next;
+            prev_next = &t->next;
+            did_paste = true;
+            break;
+        }
+
+        if (did_paste) {
+            pasted = true;
+        } else {
+            prev_next = &tok->next;
+            if (next && next->type != TOKEN_WHITESPACE &&
+                next->type != TOKEN_PASTE)
+                prev_nonspace = prev_next;
+        }
+        tok = next;
+    }
+
+    return pasted;
+}
+
+/*
+ * Computes the proper rotation of mmacro parameters
+ */
+static int mmac_rotate(const MMacro *mac, unsigned int n)
+{
+    if (--n < mac->nparam)
+        n = (n + mac->rotate) % mac->nparam;
+
+    return n+1;
+}
+
+/*
+ * expands to a list of tokens from %{x:y}
+ */
+static void expand_mmac_params_range(MMacro *mac, Token *tline, Token ***tail)
+{
+    Token *t;
+    const char *arg = tok_text(tline) + 1;
+    int fst, lst, incr, n;
+    int parsed;
+
+    parsed = sscanf(arg, "%d:%d", &fst, &lst);
+    nasm_assert(parsed == 2);
+
+    /*
+     * only macros params are accounted so
+     * if someone passes %0 -- we reject such
+     * value(s)
+     */
+    if (lst == 0 || fst == 0)
+        goto err;
+
+    /* the values should be sane */
+    if ((fst > (int)mac->nparam || fst < (-(int)mac->nparam)) ||
+        (lst > (int)mac->nparam || lst < (-(int)mac->nparam)))
+        goto err;
+
+    fst = fst < 0 ? fst + (int)mac->nparam + 1: fst;
+    lst = lst < 0 ? lst + (int)mac->nparam + 1: lst;
+
+    /*
+     * It will be at least one parameter, as we can loop
+     * in either direction.
+     */
+    incr = (fst < lst) ? 1 : -1;
+
+    while (true) {
+        n = mmac_rotate(mac, fst);
+        dup_tlistn(mac->params[n], mac->paramlen[n], tail);
+        if (fst == lst)
+            break;
+        t = make_tok_char(NULL, ',');
+        **tail = t;
+        *tail = &t->next;
+        fst += incr;
+    }
+
+    return;
+
+err:
+    nasm_nonfatal("`%%{%s}': macro parameters out of range", arg);
+    return;
+}
+
+/*
+ * Expand MMacro-local things: parameter references (%0, %n, %+n,
+ * %-n) and MMacro-local identifiers (%%foo) as well as
+ * macro indirection (%[...]) and range (%{..:..}).
+ */
+static Token *expand_mmac_params(Token * tline)
+{
+    Token **tail, *thead;
+    bool changed = false;
+    MMacro *mac = istk->mstk.mmac;
+
+    tail = &thead;
+    thead = NULL;
+
+    while (tline) {
+        bool change;
+        bool err_not_mac = false;
+        Token *t = tline;
+        const char *text = tok_text(t);
+        int type = t->type;
+
+        tline = tline->next;
+        t->next = NULL;
+
+        switch (type) {
+        case TOKEN_LOCAL_SYMBOL:
+            change = true;
+
+            if (!mac) {
+                err_not_mac = true;
+                break;
+            }
+
+            type = TOKEN_ID;
+            text = nasm_asprintf("..@%"PRIu64".%s", mac->unique, text+2);
+            break;
+        case TOKEN_MMACRO_PARAM:
+        {
+            Token *tt = NULL;
+
+            change = true;
+
+            if (!mac) {
+                err_not_mac = true;
+                break;
+            }
+
+            if (strchr(text, ':')) {
+                /* It is a range */
+                expand_mmac_params_range(mac, t, &tail);
+                text = NULL;
+                break;
+            }
+
+            switch (text[1]) {
+                /*
+                 * We have to make a substitution of one of the
+                 * forms %1, %-1, %+1, %%foo, %0, %00.
+                 */
+            case '0':
+                if (!text[2]) {
+                    type = TOKEN_NUM;
+                    text = nasm_asprintf("%d", mac->nparam);
+                    break;
+                }
+                if (text[2] != '0' || text[3])
+                    goto invalid;
+                /* a possible captured label == mac->params[0] */
+                /* fall through */
+            default:
+            {
+                unsigned long n;
+                char *ep;
+
+                n = strtoul(text + 1, &ep, 10);
+                if (unlikely(*ep))
+                    goto invalid;
+
+                if (n <= mac->nparam) {
+                    n = mmac_rotate(mac, n);
+                    dup_tlistn(mac->params[n], mac->paramlen[n], &tail);
+                }
+                text = NULL;
+                break;
+            }
+            case '-':
+            case '+':
+            {
+                int cc;
+                unsigned long n;
+                char *ep;
+
+                n = strtoul(tok_text(t) + 2, &ep, 10);
+                if (unlikely(*ep))
+                    goto invalid;
+
+                if (n && n <= mac->nparam) {
+                    n = mmac_rotate(mac, n);
+                    tt = mac->params[n];
+                }
+                cc = find_cc(tt);
+                if (cc == -1) {
+                    nasm_nonfatal("macro parameter `%s' is not a condition code",
+                                  tok_text(t));
+                    text = NULL;
+                    break;
+                }
+
+                type = TOKEN_ID;
+                if (text[1] == '-') {
+                    int ncc = inverse_ccs[cc];
+                    if (unlikely(ncc == -1)) {
+                        nasm_nonfatal("condition code `%s' is not invertible",
+                                      conditions[cc]);
+                        break;
+                    }
+                    cc = ncc;
+                }
+                text = nasm_strdup(conditions[cc]);
+                break;
+            }
+
+            invalid:
+                nasm_nonfatal("invalid macro parameter: `%s'", text);
+                text = NULL;
+                break;
+            }
+            break;
+        }
+
+        case TOKEN_PREPROC_Q:
+            if (mac) {
+                type = TOKEN_ID;
+                text = nasm_strdup(mac->iname);
+                change = true;
+            } else {
+                change = false;
+            }
+            break;
+
+        case TOKEN_PREPROC_QQ:
+            if (mac) {
+                type = TOKEN_ID;
+                text = nasm_strdup(mac->name);
+                change = true;
+            } else {
+                change = false;
+            }
+            break;
+
+        case TOKEN_INDIRECT:
+        {
+            Token *tt;
+
+            tt = tokenize(tok_text(t));
+            tt = expand_mmac_params(tt);
+            tt = expand_smacro(tt);
+            tail = steal_tlist(tt, tail);
+            text = NULL;
+            change = true;
+            break;
+        }
+
+        default:
+            change = false;
+            break;
+        }
+
+        if (err_not_mac) {
+            nasm_nonfatal("`%s': not in a macro call", text);
+            text = NULL;
+            change = true;
+        }
+
+        if (change) {
+            if (!text) {
+                delete_Token(t);
+            } else {
+                *tail = t;
+                tail = &t->next;
+		set_text(t, text, tok_strlen(text));
+                t->type = type;
+            }
+            changed = true;
+        } else {
+            *tail = t;
+            tail = &t->next;
+        }
+    }
+
+    *tail = NULL;
+
+    if (changed) {
+        const struct concat_mask t[] = {
+            {
+                CONCAT_ID | CONCAT_FLOAT,   /* head */
+                CONCAT_ID | CONCAT_NUM | CONCAT_FLOAT | CONCAT_OP /* tail */
+            },
+            {
+                CONCAT_NUM,     /* head */
+                CONCAT_NUM      /* tail */
+            }
+        };
+        paste_tokens(&thead, t, ARRAY_SIZE(t), false);
+    }
+
+    return thead;
+}
+
+static Token *expand_smacro_noreset(Token * tline);
+
+/*
+ * Expand *one* single-line macro instance. If the first token is not
+ * a macro at all, it is simply copied to the output and the pointer
+ * advanced.  tpp should be a pointer to a pointer (usually the next
+ * pointer of the previous token) to the first token. **tpp is updated
+ * to point to the first token of the expansion, and *tpp updated to
+ * point to the next pointer of the last token of the expansion.
+ *
+ * If the expansion is empty, *tpp will be unchanged but **tpp will
+ * be advanced past the macro call.
+ *
+ * Return the macro expanded, or NULL if no expansion took place.
+ */
+static SMacro *expand_one_smacro(Token ***tpp)
+{
+    Token **params = NULL;
+    const char *mname, *mtype;
+    Token *mstart = **tpp;
+    Token *tline  = mstart;
+    SMacro *head, *m;
+    int i;
+    Token *t, *tup, *tafter;
+    int nparam = 0;
+    bool cond_comma;
+
+    if (!tline)
+        return false;           /* Empty line, nothing to do */
+
+    mname = tok_text(mstart);
+
+    smacro_deadman.total--;
+    smacro_deadman.levels--;
+
+    if (unlikely(smacro_deadman.total < 0 || smacro_deadman.levels < 0)) {
+        if (unlikely(!smacro_deadman.triggered)) {
+            nasm_nonfatal("interminable macro recursion");
+            smacro_deadman.triggered = true;
+        }
+        goto not_a_macro;
+    } else if (tline->type == TOKEN_ID || tline->type == TOKEN_PREPROC_ID) {
+        head = (SMacro *)hash_findix(&smacros, mname);
+    } else if (tline->type == TOKEN_LOCAL_MACRO) {
+        Context *ctx = get_ctx(mname, &mname);
+        head = ctx ? (SMacro *)hash_findix(&ctx->localmac, mname) : NULL;
+    } else {
+        goto not_a_macro;
+    }
+
+    /*
+     * We've hit an identifier of some sort. First check whether the
+     * identifier is a single-line macro at all, then think about
+     * checking for parameters if necessary.
+     */
+    list_for_each(m, head) {
+        if (unlikely(m->alias && ppconf.noaliases))
+            continue;
+        if (!mstrcmp(m->name, mname, m->casesense))
+            break;
+    }
+
+    if (!m) {
+        goto not_a_macro;
+    }
+
+    /* Parse parameters, if applicable */
+
+    params = NULL;
+    nparam = 0;
+
+    if (m->nparam == 0) {
+        /*
+         * Simple case: the macro is parameterless.
+         * Nothing to parse; the expansion code will
+         * drop the macro name token.
+         */
+    } else {
+        /*
+         * Complicated case: at least one macro with this name
+         * exists and takes parameters. We must find the
+         * parameters in the call, count them, find the SMacro
+         * that corresponds to that form of the macro call, and
+         * substitute for the parameters when we expand. What a
+         * pain.
+         */
+        Token *t;
+        int paren, brackets;
+
+        tline = tline->next;
+        tline = skip_white(tline);
+        if (!tok_is(tline, '(')) {
+            /*
+             * This macro wasn't called with parameters: ignore
+             * the call. (Behaviour borrowed from gnu cpp.)
+             */
+            goto not_a_macro;
+        }
+
+        paren = 1;
+        nparam = 1;
+        brackets = 0;
+        t = tline;              /* tline points to leading ( */
+
+        while (paren) {
+            t = t->next;
+
+            if (!t) {
+                nasm_nonfatal("macro call expects terminating `)'");
+                goto not_a_macro;
+            }
+
+            switch (t->type) {
+            case ',':
+                if (!brackets && paren == 1)
+                    nparam++;
+                break;
+
+            case '{':
+                brackets++;
+                break;
+
+            case '}':
+                if (brackets > 0)
+                    brackets--;
+                break;
+
+            case '(':
+                if (!brackets)
+                    paren++;
+                break;
+
+            case ')':
+                if (!brackets)
+                    paren--;
+                break;
+
+            default:
+                break;          /* Normal token */
+            }
+        }
+
+        /*
+         * Look for a macro matching in both name and parameter count.
+         * We already know any matches cannot be anywhere before the
+         * current position of "m", so there is no reason to
+         * backtrack.
+         */
+        while (1) {
+            if (!m) {
+                /*!
+                 *!pp-macro-params-single [on] single-line macro calls with wrong parameter count
+                 *!=macro-params-single
+                 *!  warns about \i{single-line macros} being invoked
+                 *!  with the wrong number of parameters.
+                 */
+                nasm_warn(WARN_PP_MACRO_PARAMS_SINGLE|ERR_HOLD,
+                    "single-line macro `%s' exists, "
+                    "but not taking %d parameter%s",
+                    mname, nparam, (nparam == 1) ? "" : "s");
+                goto not_a_macro;
+            }
+
+            if (!mstrcmp(m->name, mname, m->casesense)) {
+                if (nparam >= m->nparam_min &&
+                    (m->varadic || nparam <= m->nparam))
+                    break;      /* It's good */
+            }
+            m = m->next;
+        }
+    }
+
+    if (m->in_progress && !m->recursive)
+        goto not_a_macro;
+
+    /* Expand the macro */
+    m->in_progress++;
+
+    /* Is it a macro or a preprocessor function? Used for diagnostics. */
+    mtype = m->name[0] == '%' ? "function" : "macro";
+
+    if (nparam) {
+        /* Extract parameters */
+        Token **phead, **pep;
+        int white = 0;
+        int brackets = 0;
+        int paren;
+        bool bracketed = false;
+        bool bad_bracket = false;
+        enum sparmflags flags;
+        const struct smac_param *mparm;
+
+        if (nparam > m->nparam) {
+            if (m->params[m->nparam-1].flags & SPARM_GREEDY)
+                nparam = m->nparam;
+        } else if (nparam < m->nparam) {
+            nparam = m->nparam; /* Missing optional arguments = empty */
+        }
+        paren = 1;
+        nasm_newn(params, nparam);
+        i = 0;
+        mparm = m->params;
+        flags = mparm->flags;
+        phead = pep = &params[i];
+        *pep = NULL;
+
+        while (paren) {
+            bool skip;
+
+            tline = tline->next;
+
+            if (!tline)
+                nasm_nonfatal("%s `%s' call expects terminating `)'",
+                              mtype, m->name);
+
+            skip = false;
+
+            switch (tline->type) {
+            case TOKEN_WHITESPACE:
+                if (!(flags & SPARM_NOSTRIP)) {
+                    if (brackets || *phead)
+                        white++;    /* Keep interior whitespace */
+                    skip = true;
+                }
+                break;
+
+            case ',':
+                if (!brackets && paren == 1 && !(flags & SPARM_GREEDY)) {
+                    i++;
+                    nasm_assert(i < nparam);
+                    phead = pep = &params[i];
+                    *pep = NULL;
+                    bracketed = false;
+                    skip = true;
+                    if (!(flags & SPARM_VARADIC)) {
+                        mparm++;
+                        flags = mparm->flags;
+                    }
+                }
+                break;
+
+            case '{':
+                if (!bracketed) {
+                    bracketed = !*phead && !(flags & SPARM_NOSTRIP);
+                    skip = bracketed;
+                }
+                brackets++;
+                break;
+
+            case '}':
+                if (brackets > 0) {
+                    if (!--brackets)
+                        skip = bracketed;
+                }
+                break;
+
+            case '(':
+                if (!brackets)
+                    paren++;
+                break;
+
+            case ')':
+                if (!brackets) {
+                    paren--;
+                    if (!paren) {
+                        skip = true;
+                        i++;    /* Found last argument */
+                    }
+                }
+                break;
+
+            default:
+                break;          /* Normal token */
+            }
+
+            if (!skip) {
+                Token *t;
+
+                bad_bracket |= bracketed && !brackets;
+
+                if (white) {
+                    *pep = t = new_White(NULL);
+                    pep = &t->next;
+                    white = 0;
+                }
+                *pep = t = dup_Token(NULL, tline);
+                pep = &t->next;
+            }
+        }
+
+        /*
+         * Possible further processing of parameters. Note that the
+         * ordering matters here.
+         *
+         * mparm points to the current parameter specification
+         * structure (struct smac_param); this may not match the index
+         * i in the case of varadic parameters.
+         */
+        for (i = 0, mparm = m->params;
+             i < nparam;
+             i++, mparm += !(flags & SPARM_VARADIC)) {
+            const enum sparmflags flags = mparm->flags;
+
+            if (flags & SPARM_EVAL) {
+                /* Evaluate this parameter as a number */
+                struct ppscan pps;
+                struct tokenval tokval;
+                expr *evalresult;
+                Token *eval_param;
+
+                eval_param = zap_white(expand_smacro_noreset(params[i]));
+                params[i] = NULL;
+
+                if (!eval_param) {
+                    /* empty argument */
+                    if (mparm->def) {
+                        params[i] = dup_tlist(mparm->def, NULL);
+                        continue;
+                    } else if (flags & SPARM_OPTIONAL) {
+                        continue;
+                    }
+                    /* otherwise, allow evaluate() to generate an error */
+                }
+
+                pps.tptr = eval_param;
+                pps.ntokens = -1;
+                tokval.t_type = TOKEN_INVALID;
+                evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
+
+                free_tlist(eval_param);
+
+                if (!evalresult) {
+                    /* Nothing meaningful to do */
+                } else if (tokval.t_type) {
+                    nasm_nonfatal("invalid expression in parameter %d of %s `%s'",
+                                  i, mtype, m->name);
+                } else if (!is_simple(evalresult)) {
+                    nasm_nonfatal("non-constant expression in parameter %d of %s `%s'",
+                                  i, mtype, m->name);
+                } else {
+                    params[i] = make_tok_num(NULL, reloc_value(evalresult));
+                }
+            }
+
+            if (flags & SPARM_STR) {
+                /* Convert expansion to a quoted string */
+                Token *qs;
+
+                qs = expand_smacro_noreset(params[i]);
+                if ((flags & SPARM_CONDQUOTE) &&
+                    tok_is(qs, TOKEN_STR) && !qs->next) {
+                    /* A single quoted string token */
+                    params[i] = qs;
+                } else {
+                    char *arg = detoken(qs, false);
+                    free_tlist(qs);
+                    params[i] = make_tok_qstr(NULL, arg);
+                    nasm_free(arg);
+                }
+            }
+        }
+    }
+
+    /* Note: we own the expansion this returns. */
+    t = m->expand(m, params, nparam);
+
+    tafter = tline->next;   /* Skip past the macro call */
+    tline->next = NULL;     /* Truncate list at the macro call end */
+    tline = tafter;
+
+    tup = NULL;
+    cond_comma = false;
+
+    while (t) {
+        enum token_type type = t->type;
+        Token *tnext = t->next;
+
+        switch (type) {
+        case TOKEN_PREPROC_Q:
+        case TOKEN_PREPROC_SQ:
+            delete_Token(t);
+            t = dup_Token(tline, mstart);
+            break;
+
+        case TOKEN_PREPROC_QQ:
+        case TOKEN_PREPROC_SQQ:
+        {
+            size_t mlen = strlen(m->name);
+	    size_t len;
+            char *p, *from;
+
+            t->type = mstart->type;
+            if (t->type == TOKEN_LOCAL_MACRO) {
+		const char *psp; /* prefix start pointer */
+                const char *pep; /* prefix end pointer */
+		size_t plen;
+
+		psp = tok_text(mstart);
+                get_ctx(psp, &pep);
+                plen = pep - psp;
+
+                len = mlen + plen;
+                from = p = nasm_malloc(len + 1);
+                p = mempcpy(p, psp, plen);
+            } else {
+                len = mlen;
+                from = p = nasm_malloc(len + 1);
+            }
+            p = mempcpy(p, m->name, mlen);
+            *p = '\0';
+	    set_text_free(t, from, len);
+
+            t->next = tline;
+            break;
+        }
+
+        case TOKEN_COND_COMMA:
+            delete_Token(t);
+            t = cond_comma ? make_tok_char(tline, ',') : NULL;
+            break;
+
+        case TOKEN_ID:
+        case TOKEN_PREPROC_ID:
+	case TOKEN_LOCAL_MACRO:
+        {
+            /*
+             * Chain this into the target line *before* expanding,
+             * that way we pick up any arguments to the new macro call,
+             * if applicable.
+             */
+            Token **tp = &t;
+            t->next = tline;
+            expand_one_smacro(&tp);
+            tline = *tp;        /* First token left after any macro call */
+            break;
+        }
+        default:
+            if (is_smac_param(t->type)) {
+                int param = smac_nparam(t->type);
+                nasm_assert(!tup && param < nparam);
+                delete_Token(t);
+                t = NULL;
+                tup = tnext;
+                tnext = dup_tlist_reverse(params[param], NULL);
+                cond_comma = false;
+            } else {
+                t->next = tline;
+            }
+        }
+
+        if (t) {
+            Token *endt = tline;
+
+            tline = t;
+            while (!cond_comma && t && t != endt) {
+                cond_comma = t->type != TOKEN_WHITESPACE;
+                t = t->next;
+            }
+        }
+
+        if (tnext) {
+            t = tnext;
+        } else {
+            t = tup;
+            tup = NULL;
+        }
+    }
+
+    **tpp = tline;
+    for (t = tline; t && t != tafter; t = t->next)
+        *tpp = &t->next;
+
+    /* Expansion complete */
+    m->in_progress--;
+
+    /* Don't do this until after expansion or we will clobber mname */
+    free_tlist(mstart);
+    goto done;
+
+    /*
+     * No macro expansion needed; roll back to mstart (if necessary)
+     * and then advance to the next input token. Note that this is
+     * by far the common case!
+     */
+not_a_macro:
+    *tpp = &mstart->next;
+    m = NULL;
+done:
+    smacro_deadman.levels++;
+    free_tlist_array(params, nparam);
+    return m;
+}
+
+/*
+ * Expand all single-line macro calls made in the given line.
+ * Return the expanded version of the line. The original is deemed
+ * to be destroyed in the process. (In reality we'll just move
+ * Tokens from input to output a lot of the time, rather than
+ * actually bothering to destroy and replicate.)
+ */
+static Token *expand_smacro(Token *tline)
+{
+    smacro_deadman.total  = nasm_limit[LIMIT_MACRO_TOKENS];
+    smacro_deadman.levels = nasm_limit[LIMIT_MACRO_LEVELS];
+    smacro_deadman.triggered = false;
+    return expand_smacro_noreset(tline);
+}
+
+static Token *expand_smacro_noreset(Token *org_tline)
+{
+    Token *tline;
+    bool expanded;
+    errhold errhold;       /* Hold warning/errors during expansion */
+
+    if (!org_tline)
+        return NULL;            /* Empty input */
+
+    /*
+     * Trick: we should avoid changing the start token pointer since it can
+     * be contained in "next" field of other token. Because of this
+     * we allocate a copy of first token and work with it; at the end of
+     * routine we copy it back
+     */
+    tline = dup_Token(org_tline->next, org_tline);
+
+    /*
+     * Pretend that we always end up doing expansion on the first pass;
+     * that way %+ get processed. However, if we process %+ before the
+     * first pass, we end up with things like MACRO %+ TAIL trying to
+     * look up the macro "MACROTAIL", which we don't want.
+     */
+    expanded = true;
+
+    while (true) {
+        static const struct concat_mask tmatch[] = {
+            {
+                CONCAT_ID | CONCAT_LOCAL_MACRO |
+                CONCAT_ENVIRON | CONCAT_PREPROC_ID, /* head */
+                CONCAT_ID | CONCAT_LOCAL_MACRO |
+                CONCAT_ENVIRON | CONCAT_PREPROC_ID |
+                CONCAT_NUM      /* tail */
+            }
+        };
+        Token **tail = &tline;
+
+        /*
+         * We hold warnings/errors until we are done in this loop. It is
+         * possible for nuisance warnings to appear that disappear on later
+         * passes.
+         */
+        errhold = nasm_error_hold_push();
+
+        while (*tail)           /* main token loop */
+            expanded |= !!expand_one_smacro(&tail);
+
+         if (!expanded)
+            break;              /* Done! */
+
+        /*
+         * Now scan the entire line and look for successive TOKEN_IDs
+         * that resulted after expansion (they can't be produced by
+         * tokenize()). The successive TOKEN_IDs should be concatenated.
+         * Also we look for %+ tokens and concatenate the tokens
+         * before and after them (without white spaces in between).
+         */
+        if (!paste_tokens(&tline, tmatch, ARRAY_SIZE(tmatch), true))
+            break;              /* Done again! */
+
+        nasm_error_hold_pop(errhold, false);
+        expanded = false;
+    }
+    nasm_error_hold_pop(errhold, true);
+
+    if (!tline) {
+        /*
+         * The expression expanded to empty line;
+         * we can't return NULL because of the "trick" above.
+         * Just set the line to a single WHITESPACE token.
+	 */
+
+	tline = new_White(NULL);
+    }
+
+    steal_Token(org_tline, tline);
+    org_tline->next = tline->next;
+    delete_Token(tline);
+
+    return org_tline;
+}
+
+/*
+ * Similar to expand_smacro but used exclusively with macro identifiers
+ * right before they are fetched in. The reason is that there can be
+ * identifiers consisting of several subparts. We consider that if there
+ * are more than one element forming the name, user wants a expansion,
+ * otherwise it will be left as-is. Example:
+ *
+ *      %define %$abc cde
+ *
+ * the identifier %$abc will be left as-is so that the handler for %define
+ * will suck it and define the corresponding value. Other case:
+ *
+ *      %define _%$abc cde
+ *
+ * In this case user wants name to be expanded *before* %define starts
+ * working, so we'll expand %$abc into something (if it has a value;
+ * otherwise it will be left as-is) then concatenate all successive
+ * PP_IDs into one.
+ */
+static Token *expand_id(Token * tline)
+{
+    Token *cur, *oldnext = NULL;
+
+    if (!tline || !tline->next)
+        return tline;
+
+    cur = tline;
+    while (cur->next &&
+           (cur->next->type == TOKEN_ID ||
+            cur->next->type == TOKEN_PREPROC_ID ||
+            cur->next->type == TOKEN_LOCAL_MACRO ||
+            cur->next->type == TOKEN_NUM))
+        cur = cur->next;
+
+    /* If identifier consists of just one token, don't expand */
+    if (cur == tline)
+        return tline;
+
+    if (cur) {
+        oldnext = cur->next;    /* Detach the tail past identifier */
+        cur->next = NULL;       /* so that expand_smacro stops here */
+    }
+
+    tline = expand_smacro(tline);
+
+    if (cur) {
+        /* expand_smacro possibly changhed tline; re-scan for EOL */
+        cur = tline;
+        while (cur && cur->next)
+            cur = cur->next;
+        if (cur)
+            cur->next = oldnext;
+    }
+
+    return tline;
+}
+
+/*
+ * This is called from find_mmacro_in_list() after finding a suitable macro.
+ */
+static MMacro *use_mmacro(MMacro *m, int *nparamp, Token ***paramsp)
+{
+    int nparam = *nparamp;
+    Token **params = *paramsp;
+
+    /*
+     * This one is right. Just check if cycle removal
+     * prohibits us using it before we actually celebrate...
+     */
+    if (m->in_progress > m->max_depth) {
+        if (m->max_depth > 0) {
+            /* Document this properly when recursive mmacros re-implemented */
+            nasm_warn(WARN_OTHER, "reached maximum recursion depth of %i",
+                      m->max_depth);
+        }
+        nasm_free(params);
+        *nparamp = 0;
+        *paramsp = NULL;
+        return NULL;
+    }
+
+    /*
+     * It's right, and we can use it. Add its default
+     * parameters to the end of our list if necessary.
+     */
+    if (m->defaults && nparam < m->nparam_min + m->ndefs) {
+        int newnparam = m->nparam_min + m->ndefs;
+        params = nasm_realloc(params, sizeof(*params) * (newnparam+2));
+        memcpy(&params[nparam+1], &m->defaults[nparam+1-m->nparam_min],
+               (newnparam - nparam) * sizeof(*params));
+        nparam = newnparam;
+    }
+    /*
+     * If we've gone over the maximum parameter count (and
+     * we're in Plus mode), ignore parameters beyond
+     * nparam_max.
+     */
+    if (m->plus && nparam > m->nparam_max)
+        nparam = m->nparam_max;
+
+    /*
+     * If nparam was adjusted above, make sure the list is still
+     * NULL-terminated.
+     */
+    params[nparam+1] = NULL;
+
+    /* Done! */
+    *paramsp = params;
+    *nparamp = nparam;
+    return m;
+}
+
+/*
+ * Search a macro list and try to find a match. If matching, call
+ * use_mmacro() to set up the macro call. m points to the list of
+ * search, which is_mmacro() sets to the first *possible* match.
+ */
+static MMacro *
+find_mmacro_in_list(MMacro *m, const char *finding,
+                    int *nparamp, Token ***paramsp)
+{
+    int nparam = *nparamp;
+
+    while (m) {
+        if (m->nparam_min <= nparam
+            && (m->plus || nparam <= m->nparam_max)) {
+            /*
+             * This one matches, use it.
+             */
+            return use_mmacro(m, nparamp, paramsp);
+        }
+
+        /*
+         * Otherwise search for the next one with a name match.
+         */
+        list_for_each(m, m->next) {
+            if (!mstrcmp(m->name, finding, m->casesense))
+                break;
+        }
+    }
+
+    return NULL;
+}
+
+/*
+ * Determine whether the given line constitutes a multi-line macro
+ * call, and return the MMacro structure called if so. Doesn't have
+ * to check for an initial label - that's taken care of in
+ * expand_mmacro - but must check numbers of parameters. Guaranteed
+ * to be called with tline->type == TOKEN_ID, so the putative macro
+ * name is easy to find.
+ */
+static MMacro *is_mmacro(Token * tline, int *nparamp, Token ***paramsp)
+{
+    MMacro *head, *m, *found;
+    Token **params, **comma;
+    int raw_nparam, nparam;
+    const char *finding = tok_text(tline);
+    bool empty_args = !tline->next;
+
+    *nparamp = 0;
+    *paramsp = NULL;
+
+    head = (MMacro *) hash_findix(&mmacros, finding);
+
+    /*
+     * Efficiency: first we see if any macro exists with the given
+     * name which isn't already excluded by macro cycle removal.
+     * (The cycle removal test here helps optimize the case of wrapping
+     * instructions, and is cheap to do here.)
+     *
+     * If not, we can return NULL immediately. _Then_ we
+     * count the parameters, and then we look further along the
+     * list if necessary to find the proper MMacro.
+     */
+    list_for_each(m, head) {
+        if (!mstrcmp(m->name, finding, m->casesense) &&
+            (m->in_progress != 1 || m->max_depth > 0))
+            break;              /* Found something that needs consideration */
+    }
+    if (!m)
+        return NULL;
+
+    /*
+     * OK, we have a potential macro. Count and demarcate the
+     * parameters.
+     */
+    comma = count_mmac_params(tline->next, nparamp, paramsp);
+    raw_nparam = *nparamp;
+
+    /*
+     * Search for an exact match. This cannot come *before* the m
+     * found in the list search before, so we can start there.
+     *
+     * If found is NULL and *paramsp has been cleared, then we
+     * encountered an error for which we have already issued a
+     * diagnostic, so we should not proceed.
+     */
+    found = find_mmacro_in_list(m, finding, nparamp, paramsp);
+    if (!*paramsp)
+        return NULL;
+
+    nparam = *nparamp;
+    params = *paramsp;
+
+    /*
+     * Special weirdness: in NASM < 2.15, an expansion of
+     * *only* whitespace, as can happen during macro expansion under
+     * certain circumstances, is counted as zero arguments for the
+     * purpose of %0, but one argument for the purpose of macro
+     * matching! In particular, this affects:
+     *
+     * foobar %1
+     *
+     * ... with %1 being empty; this would call the one-argument
+     * version of "foobar" with an empty argument, equivalent to
+     *
+     * foobar {%1}
+     *
+     * ... except that %0 would be set to 0 inside foobar, even if
+     * foobar is declared with "%macro foobar 1" or equivalent!
+     *
+     * The proper way to do that is to define "%macro foobar 0-1".
+     *
+     * To be compatible without doing something too stupid, try to
+     * match a zero-argument macro first, but if that fails, try
+     * for a one-argument macro with the above behavior.
+     *
+     * Furthermore, NASM < 2.15 will match stripping a tailing empty
+     * argument, but in that case %0 *does* reflect that this argument
+     * have been stripped; this is handled in count_mmac_params().
+     *
+     * To disable these insane legacy behaviors, use:
+     *
+     * %pragma preproc sane_empty_expansion yes
+     *
+     *!pp-macro-params-legacy [on] improperly calling multi-line macro for legacy support
+     *!=macro-params-legacy
+     *!  warns about \i{multi-line macros} being invoked
+     *!  with the wrong number of parameters, but for bug-compatibility
+     *!  with NASM versions older than 2.15, NASM tried to fix up the
+     *!  parameters to match the legacy behavior and call the macro anyway.
+     *!  This can happen in certain cases where there are empty arguments
+     *!  without braces, sometimes as a result of macro expansion.
+     *!-
+     *!  The legacy behavior is quite strange and highly context-dependent,
+     *!  and can be disabled with:
+     *!-
+     *!  \c      %pragma preproc sane_empty_expansion true
+     *!-
+     *!  It is highly recommended to use this option in new code.
+     */
+    if (!ppconf.sane_empty_expansion) {
+        if (!found) {
+            if (raw_nparam == 0 && !empty_args) {
+                /*
+                 * A single all-whitespace parameter as the only thing?
+                 * Look for a one-argument macro, but don't adjust
+                 * *nparamp.
+                 */
+                int bogus_nparam = 1;
+                params[2] = NULL;
+                found = find_mmacro_in_list(m, finding, &bogus_nparam, paramsp);
+            } else if (raw_nparam > 1 && comma) {
+                Token *comma_tail = *comma;
+
+                /*
+                 * Drop the terminal argument and try again.
+                 * If we fail, we need to restore the comma to
+                 * preserve tlist.
+                 */
+                *comma = NULL;
+                *nparamp = raw_nparam - 1;
+                found = find_mmacro_in_list(m, finding, nparamp, paramsp);
+                if (found)
+                    free_tlist(comma_tail);
+                else
+                    *comma = comma_tail;
+            }
+
+            if (!*paramsp)
+                return NULL;
+        } else if (comma) {
+            free_tlist(*comma);
+            *comma = NULL;
+            if (raw_nparam > found->nparam_min &&
+                raw_nparam <= found->nparam_min + found->ndefs) {
+                /* Replace empty argument with default parameter */
+                params[raw_nparam] =
+                    found->defaults[raw_nparam - found->nparam_min];
+            } else if (raw_nparam > found->nparam_max && found->plus) {
+                /* Just drop the comma, don't adjust argument count */
+            } else {
+                /* Drop argument. This may cause nparam < nparam_min. */
+                params[raw_nparam] = NULL;
+                *nparamp = nparam = raw_nparam - 1;
+            }
+        }
+
+        if (found) {
+            if (raw_nparam < found->nparam_min ||
+                (raw_nparam > found->nparam_max && !found->plus)) {
+                nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY,
+                          "improperly calling multi-line macro `%s' with %d parameters",
+                          found->name, raw_nparam);
+            } else if (comma) {
+                nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY,
+                          "dropping trailing empty parameter in call to multi-line macro `%s'", found->name);
+            }
+        }
+    }
+
+    /*
+     * After all that, we didn't find one with the right number of
+     * parameters. Issue a warning, and fail to expand the macro.
+     *!
+     *!pp-macro-params-multi [on] multi-line macro calls with wrong parameter count
+     *!=macro-params-multi
+     *!  warns about \i{multi-line macros} being invoked
+     *!  with the wrong number of parameters. See \k{mlmacover} for an
+     *!  example of why you might want to disable this warning.
+     */
+    if (found)
+        return found;
+
+    nasm_warn(WARN_PP_MACRO_PARAMS_MULTI,
+               "multi-line macro `%s' exists, but not taking %d parameter%s",
+              finding, nparam, (nparam == 1) ? "" : "s");
+    nasm_free(*paramsp);
+    return NULL;
+}
+
+
+#if 0
+
+/*
+ * Save MMacro invocation specific fields in
+ * preparation for a recursive macro expansion
+ */
+static void push_mmacro(MMacro *m)
+{
+    MMacroInvocation *i;
+
+    i = nasm_malloc(sizeof(MMacroInvocation));
+    i->prev = m->prev;
+    i->params = m->params;
+    i->iline = m->iline;
+    i->nparam = m->nparam;
+    i->rotate = m->rotate;
+    i->paramlen = m->paramlen;
+    i->unique = m->unique;
+    i->condcnt = m->condcnt;
+    m->prev = i;
+}
+
+
+/*
+ * Restore MMacro invocation specific fields that were
+ * saved during a previous recursive macro expansion
+ */
+static void pop_mmacro(MMacro *m)
+{
+    MMacroInvocation *i;
+
+    if (m->prev) {
+        i = m->prev;
+        m->prev = i->prev;
+        m->params = i->params;
+        m->iline = i->iline;
+        m->nparam = i->nparam;
+        m->rotate = i->rotate;
+        m->paramlen = i->paramlen;
+        m->unique = i->unique;
+        m->condcnt = i->condcnt;
+        nasm_free(i);
+    }
+}
+
+#endif
+
+/*
+ * List an mmacro call with arguments (-Lm option)
+ */
+static void list_mmacro_call(const MMacro *m)
+{
+    const char prefix[] = " ;;; [macro] ";
+    size_t namelen, size;
+    char *buf, *p;
+    unsigned int i;
+    const Token *t;
+
+    namelen = strlen(m->iname);
+    size = namelen + sizeof(prefix); /* Includes final null (from prefix) */
+
+    for (i = 1; i <= m->nparam; i++) {
+        int j = 0;
+        size += 3;              /* Braces and space/comma */
+        list_for_each(t, m->params[i]) {
+            if (j++ >= m->paramlen[i])
+                break;
+            size += (t->type == TOKEN_WHITESPACE) ? 1 : t->len;
+        }
+    }
+
+    buf = p = nasm_malloc(size);
+    p = mempcpy(p, prefix, sizeof(prefix) - 1);
+    p = mempcpy(p, m->iname, namelen);
+    *p++ = ' ';
+
+    for (i = 1; i <= m->nparam; i++) {
+        int j = 0;
+        *p++ = '{';
+        list_for_each(t, m->params[i]) {
+            if (j++ >= m->paramlen[i])
+                break;
+	    p = mempcpy(p, tok_text(t), t->len);
+        }
+        *p++ = '}';
+        *p++ = ',';
+    }
+
+    *--p = '\0';                /* Replace last delimiter with null */
+    lfmt->line(LIST_MACRO, -1, buf);
+    nasm_free(buf);
+}
+
+/*
+ * Collect information about macro invocations for the benefit of
+ * the debugger. During execution we create a reverse list; before
+ * calling the backend reverse it to definition/invocation order just
+ * to be nicer. [XXX: not implemented yet]
+ */
+struct debug_macro_inv *debug_current_macro;
+
+/* Get/create a addr structure for a seg:inv combo */
+static struct debug_macro_addr *
+debug_macro_get_addr_inv(int32_t seg, struct debug_macro_inv *inv)
+{
+    struct debug_macro_addr *addr;
+    nasm_static_assert(offsetof(struct debug_macro_addr, tree) == 0);
+
+    if (likely(seg == inv->lastseg))
+        return inv->addr.last;
+
+    inv->lastseg = seg;
+    addr = (struct debug_macro_addr *)
+        rb_search_exact(inv->addr.tree, seg);
+    if (unlikely(!addr)) {
+        nasm_new(addr);
+        addr->tree.key = seg;
+        inv->addr.tree = rb_insert(inv->addr.tree, &addr->tree);
+        inv->naddr++;
+        if (inv->up)
+            addr->up = debug_macro_get_addr_inv(seg, inv->up);
+    }
+
+    return inv->addr.last = addr;
+}
+
+/* Get/create an addr structure for a seg in debug_current_macro */
+struct debug_macro_addr *debug_macro_get_addr(int32_t seg)
+{
+    return debug_macro_get_addr_inv(seg, debug_current_macro);
+}
+
+static struct debug_macro_info dmi;
+static struct debug_macro_inv_list *current_inv_list = &dmi.inv;
+
+static void debug_macro_start(MMacro *m, struct src_location where)
+{
+    struct debug_macro_def *def = m->dbg.def;
+    struct debug_macro_inv *inv;
+
+    nasm_assert(!m->dbg.inv);
+
+    /* First invocation? Need to create a def structure */
+    if (unlikely(!def)) {
+        nasm_new(def);
+        def->name = nasm_strdup(m->name);
+        def->where = m->where;
+
+        def->next = dmi.def.l;
+        dmi.def.l = def;
+        dmi.def.n++;
+
+        m->dbg.def = def;
+    }
+
+    nasm_new(inv);
+    inv->lastseg = NO_SEG;
+    inv->where = where;
+    inv->up = debug_current_macro;
+    inv->next = current_inv_list->l;
+    inv->def = def;
+    current_inv_list->l = inv;
+    current_inv_list->n++;
+    current_inv_list = &inv->down;
+
+    def->ninv++;
+    m->dbg.inv = inv;
+    debug_current_macro = inv;
+}
+
+static void debug_macro_end(MMacro *m)
+{
+    struct debug_macro_inv *inv = m->dbg.inv;
+
+    nasm_assert(inv == debug_current_macro);
+
+    list_reverse(inv->down.l);
+
+    m->dbg.inv = NULL;
+    inv = inv->up;
+
+    m = istk->mstk.mmac;
+    if (m) {
+        nasm_assert(inv == m->dbg.inv);
+        debug_current_macro = inv;
+        current_inv_list = &inv->down;
+    } else {
+        nasm_assert(!inv);
+        debug_current_macro = NULL;
+        current_inv_list = &dmi.inv;
+    }
+}
+
+static void free_debug_macro_addr_tree(struct rbtree *tree)
+{
+    struct rbtree *left, *right;
+    nasm_static_assert(offsetof(struct debug_macro_addr,tree) == 0);
+
+    if (!tree)
+        return;
+
+    left  = rb_left(tree);
+    right = rb_right(tree);
+
+    nasm_free(tree);
+
+    free_debug_macro_addr_tree(left);
+    free_debug_macro_addr_tree(right);
+}
+
+static void free_debug_macro_inv_list(struct debug_macro_inv *inv)
+{
+    struct debug_macro_inv *itmp;
+
+    if (!inv)
+        return;
+
+    list_for_each_safe(inv, itmp, inv) {
+        free_debug_macro_inv_list(inv->down.l);
+        free_debug_macro_addr_tree(inv->addr.tree);
+        nasm_free(inv);
+    }
+}
+
+static void free_debug_macro_info(void)
+{
+    struct debug_macro_def *def, *dtmp;
+
+    list_for_each_safe(def, dtmp, dmi.def.l)
+        nasm_free(def);
+
+    free_debug_macro_inv_list(dmi.inv.l);
+
+    nasm_zero(dmi);
+}
+
+static void debug_macro_output(void)
+{
+    list_reverse(dmi.inv.l);
+    dfmt->debug_mmacros(&dmi);
+    free_debug_macro_info();
+}
+
+/*
+ * Expand the multi-line macro call made by the given line, if
+ * there is one to be expanded. If there is, push the expansion on
+ * istk->expansion and return 1. Otherwise return 0.
+ */
+static int expand_mmacro(Token * tline)
+{
+    Token *startline = tline;
+    Token *label = NULL;
+    bool dont_prepend = false;
+    Token **params, *t, *tt;
+    MMacro *m;
+    Line *l, *ll;
+    int i, *paramlen;
+    const char *mname;
+    int nparam = 0;
+
+    t = tline;
+    t = skip_white(t);
+    if (!tok_is(t, TOKEN_ID) && !tok_is(t, TOKEN_LOCAL_MACRO))
+        return 0;
+    m = is_mmacro(t, &nparam, &params);
+    if (m) {
+        mname = tok_text(t);
+    } else {
+        Token *last;
+        /*
+         * We have an id which isn't a macro call. We'll assume
+         * it might be a label; we'll also check to see if a
+         * colon follows it. Then, if there's another id after
+         * that lot, we'll check it again for macro-hood.
+         */
+        label = last = t;
+        t = t->next;
+        if (tok_white(t))
+            last = t, t = t->next;
+        if (tok_is(t, ':')) {
+            dont_prepend = true;
+            last = t, t = t->next;
+            if (tok_white(t))
+                last = t, t = t->next;
+        }
+        if (!tok_is(t, TOKEN_ID) || !(m = is_mmacro(t, &nparam, &params)))
+            return 0;
+        last->next = NULL;
+        mname = tok_text(t);
+        tline = t;
+    }
+
+    if (unlikely(mmacro_deadman.total >= nasm_limit[LIMIT_MMACROS] ||
+                 mmacro_deadman.levels >= nasm_limit[LIMIT_MACRO_LEVELS])) {
+        if (!mmacro_deadman.triggered) {
+            nasm_nonfatal("interminable multiline macro recursion");
+            mmacro_deadman.triggered = true;
+        }
+        return 0;
+    }
+
+    mmacro_deadman.total++;
+    mmacro_deadman.levels++;
+
+    /*
+     * Fix up the parameters: this involves stripping leading and
+     * trailing whitespace and stripping braces if they are present.
+     */
+    nasm_newn(paramlen, nparam+1);
+
+    for (i = 1; (t = params[i]); i++) {
+        bool braced = false;
+        int brace = 0;
+        int white = 0;
+        bool comma = !m->plus || i < nparam;
+
+        t = skip_white(t);
+        if (tok_is(t, '{')) {
+            t = t->next;
+            brace = 1;
+            braced = true;
+            comma = false;
+        }
+
+        params[i] = t;
+        for (; t; t = t->next) {
+            if (tok_white(t)) {
+                white++;
+                continue;
+            }
+
+            switch(t->type) {
+            case ',':
+                if (comma && !brace)
+                    goto endparam;
+                break;
+
+            case '{':
+                brace++;
+                break;
+
+            case '}':
+                brace--;
+                if (braced && !brace) {
+                    paramlen[i] += white;
+                    goto endparam;
+                }
+                break;
+
+            default:
+                break;
+            }
+
+            paramlen[i] += white + 1;
+            white = 0;
+        }
+    endparam:
+        ;
+    }
+
+    /*
+     * OK, we have a MMacro structure together with a set of
+     * parameters. We must now go through the expansion and push
+     * copies of each Line on to istk->expansion. Substitution of
+     * parameter tokens and macro-local tokens doesn't get done
+     * until the single-line macro substitution process; this is
+     * because delaying them allows us to change the semantics
+     * later through %rotate and give the right semantics for
+     * nested mmacros.
+     *
+     * First, push an end marker on to istk->expansion, mark this
+     * macro as in progress, and set up its invocation-specific
+     * variables.
+     */
+    nasm_new(ll);
+    ll->next = istk->expansion;
+    ll->finishes = m;
+    ll->where = istk->where;
+    istk->expansion = ll;
+
+    /*
+     * Save the previous MMacro expansion in the case of
+     * macro recursion
+     */
+#if 0
+    if (m->max_depth && m->in_progress)
+        push_mmacro(m);
+#endif
+
+    m->in_progress ++;
+    m->params = params;
+    m->iline = tline;
+    m->iname = nasm_strdup(mname);
+    m->nparam = nparam;
+    m->rotate = 0;
+    m->paramlen = paramlen;
+    m->unique = unique++;
+    m->condcnt = 0;
+
+    m->mstk = istk->mstk;
+    istk->mstk.mstk = istk->mstk.mmac = m;
+
+    list_for_each(l, m->expansion) {
+        nasm_new(ll);
+        ll->next = istk->expansion;
+        istk->expansion = ll;
+        ll->first = dup_tlist(l->first, NULL);
+        ll->where = l->where;
+    }
+
+    /*
+     * If we had a label, and this macro definition does not include
+     * a %00, push it on as the first line of, ot
+     * the macro expansion.
+     */
+    if (label) {
+        /*
+         * We had a label. If this macro contains an %00 parameter,
+         * save the value as a special parameter (which is what it
+         * is), otherwise push it as the first line of the macro
+         * expansion.
+         */
+        if (m->capture_label) {
+            params[0] = dup_Token(NULL, label);
+            paramlen[0] = 1;
+            free_tlist(startline);
+       } else {
+            nasm_new(ll);
+            ll->finishes = NULL;
+            ll->next = istk->expansion;
+            istk->expansion = ll;
+            ll->first = startline;
+            ll->where = istk->where;
+            if (!dont_prepend) {
+                while (label->next)
+                    label = label->next;
+                label->next = tt = make_tok_char(NULL, ':');
+            }
+        }
+    }
+
+    istk->nolist += !!(m->nolist & NL_LIST);
+    istk->noline += !!(m->nolist & NL_LINE);
+
+    if (!istk->nolist) {
+        if (list_option('m'))
+            list_mmacro_call(m);
+
+        lfmt->uplevel(LIST_MACRO, 0);
+
+        if (ppdbg & PDBG_MMACROS)
+            debug_macro_start(m, src_where());
+    }
+
+    if (!istk->noline)
+        src_macro_push(m, istk->where);
+
+    return 1;
+}
+
+/*
+ * This function decides if an error message should be suppressed.
+ * It will never be called with a severity level of ERR_FATAL or
+ * higher.
+ */
+bool pp_suppress_error(errflags severity)
+{
+    /*
+     * If we're in a dead branch of IF or something like it, ignore the error.
+     * However, because %else etc are evaluated in the state context
+     * of the previous branch, errors might get lost:
+     *   %if 0 ... %else trailing garbage ... %endif
+     * So %else etc should set the ERR_PP_PRECOND flag.
+     */
+    if (istk && istk->conds &&
+	((severity & ERR_PP_PRECOND) ?
+	 istk->conds->state == COND_NEVER :
+	 !emitting(istk->conds->state)))
+        return true;
+
+    return false;
+}
+
+static Token *
+stdmac_file(const SMacro *s, Token **params, int nparams)
+{
+    const char *fname = src_get_fname();
+
+    (void)s;
+    (void)params;
+    (void)nparams;
+
+    return fname ? make_tok_qstr(NULL, fname) : NULL;
+}
+
+static Token *
+stdmac_line(const SMacro *s, Token **params, int nparams)
+{
+    (void)s;
+    (void)params;
+    (void)nparams;
+
+    return make_tok_num(NULL, src_get_linnum());
+}
+
+static Token *
+stdmac_bits(const SMacro *s, Token **params, int nparams)
+{
+    (void)s;
+    (void)params;
+    (void)nparams;
+
+    return make_tok_num(NULL, globalbits);
+}
+
+static Token *
+stdmac_ptr(const SMacro *s, Token **params, int nparams)
+{
+    (void)s;
+    (void)params;
+    (void)nparams;
+
+    switch (globalbits) {
+    case 16:
+	return new_Token(NULL, TOKEN_ID, "word", 4);
+    case 32:
+	return new_Token(NULL, TOKEN_ID, "dword", 5);
+    case 64:
+	return new_Token(NULL, TOKEN_ID, "qword", 5);
+    default:
+        panic();
+    }
+}
+
+/* %is...() function macros */
+static Token *
+stdmac_is(const SMacro *s, Token **params, int nparams)
+{
+    int retval;
+    struct Token *pline = params[0];
+
+    (void)nparams;
+
+    params[0] = NULL;           /* Don't free this later */
+
+    retval = if_condition(pline, s->expandpvt.u) == COND_IF_TRUE;
+    return make_tok_num(NULL, retval);
+}
+
+/*
+ * Join all expanded macro arguments with commas, e.g. %eval().
+ * Remember that this needs to output the tokens in reverse order.
+ *
+ * This can also be used when only single argument is already ready
+ * to be emitted, e.g. %str().
+ */
+static Token *
+stdmac_join(const SMacro *s, Token **params, int nparams)
+{
+    struct Token *tline = NULL;
+    int i;
+
+    (void)s;
+
+    for (i = 0; i < nparams; i++) {
+        Token *t, *ttmp;
+
+        if (i)
+            tline = make_tok_char(tline, ',');
+
+        list_for_each_safe(t, ttmp, params[i]) {
+            t->next = tline;
+            tline = t;
+        }
+
+        /* Avoid freeing the tokens we "stole" */
+        params[i] = NULL;
+    }
+
+    return tline;
+}
+
+/* %strcat() function */
+static Token *
+stdmac_strcat(const SMacro *s, Token **params, int nparams)
+{
+    int i;
+    size_t len = 0;
+    char *str, *p;
+
+    (void)s;
+
+    for (i = 0; i < nparams; i++) {
+        unquote_token(params[i]);
+        len += params[i]->len;
+    }
+
+    nasm_newn(str, len+1);
+    p = str;
+
+    for (i = 0; i < nparams; i++) {
+        p = mempcpy(p, tok_text(params[i]), params[i]->len);
+    }
+
+    return make_tok_qstr_len(NULL, str, len);
+}
+
+/* %substr() function */
+static Token *
+stdmac_substr(const SMacro *s, Token **params, int nparams)
+{
+    int64_t start, count;
+
+    (void)nparams;
+    (void)s;
+
+    start = get_tok_num(params[1], NULL);
+    count = get_tok_num(params[2], NULL);
+
+    return pp_substr_common(params[0], start, count);
+}
+
+/* %strlen() function */
+static Token *
+stdmac_strlen(const SMacro *s, Token **params, int nparams)
+{
+    (void)nparams;
+    (void)s;
+
+    unquote_token(params[0]);
+    return make_tok_num(NULL, params[0]->len);
+}
+
+/* %tok() function */
+static Token *
+stdmac_tok(const SMacro *s, Token **params, int nparams)
+{
+    (void)nparams;
+    (void)s;
+
+    return reverse_tokens(tokenize(unquote_token_cstr(params[0])));
+}
+
+/* %cond() or %sel() */
+static Token *
+stdmac_cond_sel(const SMacro *s, Token **params, int nparams)
+{
+    int64_t which;
+
+    /*
+     * params[0] will have been generated by make_tok_num.
+     */
+    which = get_tok_num(params[0], NULL);
+
+    if (s->expandpvt.u) {
+        /* Booleanize (for %cond): true -> 1, false -> 2 (else) */
+        which = which ? 1 : 2;
+        if (which >= nparams) {
+            /* false, and no else clause */
+            return NULL;
+        }
+    } else {
+            /*!
+             *!pp-sel-range [on] %sel() argument out of range
+             *!  warns that the %sel() preprocessor function was passed
+             *!  a value less than 1 or larger than the number of available
+             *!  arguments.
+             */
+        if (unlikely(which < 1)) {
+            nasm_warn(WARN_PP_SEL_RANGE,
+                      "%s(%"PRId64") is not a valid selector", s->name, which);
+            return NULL;
+        } else if (unlikely(which >= nparams)) {
+            nasm_warn(WARN_PP_SEL_RANGE,
+                      "%s(%"PRId64") exceeds the number of arguments",
+                      s->name, which);
+            return NULL;
+        }
+    }
+
+    return new_Token(NULL, tok_smac_param(which), "", 0);
+}
+
+/* %count() function */
+static Token *
+stdmac_count(const SMacro *s, Token **params, int nparams)
+{
+    (void)s;
+    (void)params;
+
+    return make_tok_num(NULL, nparams);
+}
+
+/* %num() function */
+static Token *
+stdmac_num(const SMacro *s, Token **params, int nparam)
+{
+    static const char num_digits[] =
+        "0123456789"
+        "abcdefghijklmnopqrstuvwxyz"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "@_";                   /* Compatible with bash */
+    int64_t parm[3];
+    uint64_t n;
+    int64_t dparm, bparm;
+    unsigned int i;
+    int nd;
+    unsigned int base;
+    char numstr[256];
+    char * const endstr = numstr + sizeof numstr - 1;
+    const int maxlen = sizeof numstr - 3;
+    const int maxbase = sizeof num_digits - 1;
+    char *p;
+    bool moredigits;
+
+    (void)nparam;
+
+    for (i = 0; i < (int)ARRAY_SIZE(parm); i++)
+        parm[i] = get_tok_num(params[i], NULL);
+
+    n      = parm[0];
+    dparm  = parm[1];
+    bparm  = parm[2];
+
+    if (bparm < 2 || bparm > maxbase) {
+        nasm_nonfatal("invalid base %"PRId64" given to %s()",
+                      bparm, s->name);
+        return NULL;
+    }
+
+    base = bparm;
+
+    if (dparm < -maxlen || dparm > maxlen) {
+        nasm_nonfatal("digit count %"PRId64" specified to %s() too large",
+                      dparm, s->name);
+        moredigits = true;
+        nd = 1;
+    } else if (dparm <= 0) {
+        moredigits = true;
+        nd = -dparm;
+    } else {
+        moredigits = false;
+        nd = dparm;
+    }
+
+    p = endstr;
+    *p = '\0';
+    *--p = '\'';
+
+    while (nd-- > 0 || (moredigits && n)) {
+        *--p = num_digits[n % base];
+        n /= base;
+    }
+    *--p = '\'';
+
+    return new_Token(NULL, TOKEN_STR, p, endstr - p);
+}
+
+/* %abs() function */
+static Token *
+stdmac_abs(const SMacro *s, Token **params, int nparam)
+{
+    char numbuf[24];
+    int len;
+    int64_t v;
+    uint64_t u;
+
+    (void)s;
+    (void)nparam;
+
+    v = get_tok_num(params[0], NULL);
+    u = v < 0 ? -v : v;
+
+    /*
+     * Don't use make_tok_num() here, to make sure we don't emit
+     * a minus sign for the case of v = -2^63
+     */
+    len = snprintf(numbuf, sizeof numbuf, "%"PRIu64, u);
+    return new_Token(NULL, TOKEN_NUM, numbuf, len);
+}
+
+/* Add magic standard macros */
+struct magic_macros {
+    const char *name;
+    bool casesense;
+    int nparam;
+    enum sparmflags flags;
+    ExpandSMacro func;
+};
+
+static void pp_add_magic_stdmac(void)
+{
+    static const struct magic_macros magic_macros[] = {
+        { "__?FILE?__", true, 0, 0, stdmac_file },
+        { "__?LINE?__", true, 0, 0, stdmac_line },
+        { "__?BITS?__", true, 0, 0, stdmac_bits },
+        { "__?PTR?__",  true, 0, 0, stdmac_ptr },
+        { "%abs",       false, 1, SPARM_EVAL, stdmac_abs },
+        { "%count",     false, 1, SPARM_VARADIC, stdmac_count },
+        { "%eval",      false, 1, SPARM_EVAL|SPARM_VARADIC, stdmac_join },
+        { "%str",       false, 1, SPARM_GREEDY|SPARM_STR, stdmac_join },
+        { "%strcat",    false, 1, SPARM_STR|SPARM_CONDQUOTE|SPARM_VARADIC, stdmac_strcat },
+        { "%strlen",    false, 1, SPARM_STR|SPARM_CONDQUOTE, stdmac_strlen },
+        { "%tok",       false, 1, SPARM_STR|SPARM_CONDQUOTE, stdmac_tok },
+        { NULL, false, 0, 0, NULL }
+    };
+    const struct magic_macros *m;
+    SMacro tmpl;
+    enum preproc_token pt;
+    char name_buf[PP_TOKLEN_MAX+1];
+
+    /*
+     * Simple standard magic macros and functions.
+     * Note that preprocessor functions are allowed to recurse.
+     */
+    nasm_zero(tmpl);
+    for (m = magic_macros; m->name; m++) {
+        tmpl.nparam = m->nparam;
+        tmpl.expand = m->func;
+        tmpl.recursive = m->nparam && m->name[0] == '%';
+
+        if (m->nparam) {
+            int i;
+            enum sparmflags flags = m->flags;
+
+            nasm_newn(tmpl.params, m->nparam);
+            for (i = m->nparam-1; i >= 0; i--) {
+                tmpl.params[i].flags = flags;
+                /* These flags for the last arg only */
+                flags &= ~(SPARM_GREEDY|SPARM_VARADIC|SPARM_OPTIONAL);
+            }
+        }
+        define_smacro(m->name, m->casesense, NULL, &tmpl);
+        if (m->name[0] == '%') {
+            enum preproc_token op = pp_token_hash(m->name);
+            if (op != PP_invalid)
+                pp_op_may_be_function[op] = true;
+        }
+    }
+
+    /* %sel() function */
+    nasm_zero(tmpl);
+    tmpl.nparam    = 2;
+    tmpl.recursive = true;
+    tmpl.expand    = stdmac_cond_sel;
+    nasm_newn(tmpl.params, tmpl.nparam);
+    tmpl.params[0].flags = SPARM_EVAL;
+    tmpl.params[1].flags = SPARM_VARADIC;
+    define_smacro("%sel", false, NULL, &tmpl);
+
+    /* %cond() function, a variation on %sel */
+    tmpl.nparam = 3;
+    tmpl.expandpvt.u = 1;         /* Booleanize */
+    nasm_newn(tmpl.params, tmpl.nparam);
+    tmpl.params[0].flags = SPARM_EVAL;
+    tmpl.params[1].flags = 0;
+    tmpl.params[2].flags = SPARM_OPTIONAL;
+    define_smacro("%cond", false, NULL, &tmpl);
+
+    /* %num() function */
+    nasm_zero(tmpl);
+    tmpl.nparam = 3;
+    tmpl.expand = stdmac_num;
+    tmpl.recursive = true;
+    nasm_newn(tmpl.params, tmpl.nparam);
+    tmpl.params[0].flags = SPARM_EVAL;
+    tmpl.params[1].flags = SPARM_EVAL|SPARM_OPTIONAL;
+    tmpl.params[1].def   = make_tok_num(NULL, -1);
+    tmpl.params[2].flags = SPARM_EVAL|SPARM_OPTIONAL;
+    tmpl.params[2].def   = make_tok_num(NULL, 10);
+    define_smacro("%num", false, NULL, &tmpl);
+
+    /* %substr() function */
+    nasm_zero(tmpl);
+    tmpl.nparam = 3;
+    tmpl.expand = stdmac_substr;
+    tmpl.recursive = true;
+    nasm_newn(tmpl.params, tmpl.nparam);
+    tmpl.params[0].flags  = SPARM_STR|SPARM_CONDQUOTE;
+    tmpl.params[1].flags  = SPARM_EVAL;
+    tmpl.params[2].flags  = SPARM_EVAL|SPARM_OPTIONAL;
+    tmpl.params[2].def    = make_tok_num(NULL, -1);
+    define_smacro("%substr", false, NULL, &tmpl);
+
+    /* %is...() macro functions */
+    nasm_zero(tmpl);
+    tmpl.nparam  = 1;
+    tmpl.expand  = stdmac_is;
+    tmpl.recursive = true;
+    name_buf[0]  = '%';
+    name_buf[1]  = 'i';
+    name_buf[2]  = 's';
+    for (pt = PP_IF; pt < (PP_IFN+(PP_IFN-PP_IF)); pt++) {
+        if (!pp_directives[pt])
+            continue;
+
+        nasm_new(tmpl.params);
+        tmpl.params[0].flags = SPARM_GREEDY;
+
+        strcpy(name_buf+3, pp_directives[pt]+3);
+        tmpl.expandpvt.u = pt;
+        define_smacro(name_buf, false, NULL, &tmpl);
+    }
+}
+
+static void pp_reset_stdmac(enum preproc_mode mode)
+{
+    int apass;
+    struct Include *inc;
+
+    /*
+     * Set up the stdmac packages as a virtual include file,
+     * indicated by a null file pointer.
+     */
+    nasm_new(inc);
+    inc->next = istk;
+    inc->nolist = inc->noline = !list_option('b');
+    inc->where = istk->where;
+    istk = inc;
+    if (!istk->nolist) {
+        lfmt->uplevel(LIST_INCLUDE, 0);
+    }
+    if (!istk->noline) {
+        src_set(0, NULL);
+        istk->where = src_where();
+        if (ppdbg & PDBG_INCLUDE)
+            dfmt->debug_include(true, istk->next->where, istk->where);
+    }
+
+    pp_add_magic_stdmac();
+
+    if (tasm_compatible_mode)
+        pp_add_stdmac(nasm_stdmac_tasm);
+
+    pp_add_stdmac(nasm_stdmac_nasm);
+    pp_add_stdmac(nasm_stdmac_version);
+
+    if (extrastdmac)
+        pp_add_stdmac(extrastdmac);
+
+    stdmacpos  = stdmacros[0];
+    stdmacnext = &stdmacros[1];
+
+    do_predef = true;
+
+    /*
+     * Define the __?PASS?__ macro.  This is defined here unlike all the
+     * other builtins, because it is special -- it varies between
+     * passes -- but there is really no particular reason to make it
+     * magic.
+     *
+     * 0 = dependencies only
+     * 1 = preparatory passes
+     * 2 = final pass
+     * 3 = preprocess only
+     */
+    switch (mode) {
+    case PP_NORMAL:
+        apass = pass_final() ? 2 : 1;
+        break;
+    case PP_DEPS:
+        apass = 0;
+        break;
+    case PP_PREPROC:
+        apass = 3;
+        break;
+    default:
+        panic();
+    }
+
+    define_smacro("__?PASS?__", true, make_tok_num(NULL, apass), NULL);
+}
+
+void pp_reset(const char *file, enum preproc_mode mode,
+              struct strlist *dep_list)
+{
+    cstk = NULL;
+    defining = NULL;
+    nested_mac_count = 0;
+    nested_rep_count = 0;
+    init_macros();
+    unique = 0;
+    deplist = dep_list;
+    pp_mode = mode;
+
+    /* Reset options to default */
+    nasm_zero(ppconf);
+
+    /* Disable all debugging info, except in the last pass */
+    ppdbg = 0;
+    if (!(ppopt & PP_TRIVIAL)) {
+        if (pass_final()) {
+            if (dfmt->debug_mmacros)
+                ppdbg |= PDBG_MMACROS;
+            if (dfmt->debug_smacros)
+                ppdbg |= PDBG_SMACROS;
+            if (dfmt->debug_include)
+                ppdbg |= PDBG_INCLUDE;
+        }
+
+        if (list_option('s'))
+            ppdbg |= PDBG_LIST_SMACROS;
+    }
+
+    memset(use_loaded, 0, use_package_count * sizeof(bool));
+
+    /* First set up the top level input file */
+    nasm_new(istk);
+    istk->fp = nasm_open_read(file, NF_TEXT);
+    if (!istk->fp) {
+	nasm_fatalf(ERR_NOFILE, "unable to open input file `%s'%s%s",
+                    file, errno ? " " : "", errno ? strerror(errno) : "");
+    }
+    src_set(0, file);
+    istk->where = src_where();
+    istk->lineinc = 1;
+
+    if (ppdbg & PDBG_INCLUDE) {
+        /* Let the debug format know the main file */
+        dfmt->debug_include(true, src_nowhere(), istk->where);
+    }
+
+    strlist_add(deplist, file);
+
+    do_predef = false;
+
+    if (!(ppopt & PP_TRIVIAL))
+        pp_reset_stdmac(mode);
+}
+
+void pp_init(enum preproc_opt opt)
+{
+    ppopt = opt;
+    nasm_newn(use_loaded, use_package_count);
+}
+
+/*
+ * Get a line of tokens. If we popped the macro expansion/include stack,
+ * we return a pointer to the dummy token tok_pop; at that point if
+ * istk is NULL then we have reached end of input;
+ */
+static Token tok_pop;           /* Dummy token placeholder */
+
+static Token *pp_tokline(void)
+{
+    while (true) {
+        Line *l = istk->expansion;
+        Token *tline = NULL;
+        Token *dtline;
+
+        /*
+         * Fetch a tokenized line, either from the macro-expansion
+         * buffer or from the input file.
+         */
+        tline = NULL;
+        while (l && l->finishes) {
+            MMacro *fm = l->finishes;
+
+            nasm_assert(fm == istk->mstk.mstk);
+
+            if (!fm->name && fm->in_progress > 1) {
+                /*
+                 * This is a macro-end marker for a macro with no
+                 * name, which means it's not really a macro at all
+                 * but a %rep block, and the `in_progress' field is
+                 * more than 1, meaning that we still need to
+                 * repeat. (1 means the natural last repetition; 0
+                 * means termination by %exitrep.) We have
+                 * therefore expanded up to the %endrep, and must
+                 * push the whole block on to the expansion buffer
+                 * again. We don't bother to remove the macro-end
+                 * marker: we'd only have to generate another one
+                 * if we did.
+                 */
+                fm->in_progress--;
+                list_for_each(l, fm->expansion) {
+                    Line *ll;
+
+                    nasm_new(ll);
+                    ll->next  = istk->expansion;
+                    ll->first = dup_tlist(l->first, NULL);
+                    ll->where = l->where;
+                    istk->expansion = ll;
+                }
+                break;
+            } else {
+                MMacro *m = istk->mstk.mstk;
+
+                /*
+                 * Check whether a `%rep' was started and not ended
+                 * within this macro expansion. This can happen and
+                 * should be detected. It's a fatal error because
+                 * I'm too confused to work out how to recover
+                 * sensibly from it.
+                 */
+                if (defining) {
+                    if (defining->name)
+                        nasm_panic("defining with name in expansion");
+                    else if (m->name)
+                        nasm_fatal("`%%rep' without `%%endrep' within"
+				   " expansion of macro `%s'", m->name);
+                }
+
+                /*
+                 * FIXME:  investigate the relationship at this point between
+                 * istk->mstk.mstk and fm
+                 */
+                istk->mstk = m->mstk;
+                if (m->name) {
+                    /*
+                     * This was a real macro call, not a %rep, and
+                     * therefore the parameter information needs to
+                     * be freed and the iteration count/nesting
+                     * depth adjusted.
+                     */
+
+                    if (!--mmacro_deadman.levels) {
+                        /*
+                         * If all mmacro processing done,
+                         * clear all counters and the deadman
+                         * message trigger.
+                         */
+                        nasm_zero(mmacro_deadman); /* Clear all counters */
+                    }
+
+#if 0
+                    if (m->prev) {
+                        pop_mmacro(m);
+                        fm->in_progress --;
+                    } else
+#endif
+                    {
+                        nasm_free(m->params);
+                        free_tlist(m->iline);
+                        nasm_free(m->paramlen);
+                        fm->in_progress = 0;
+			m->params = NULL;
+			m->iline = NULL;
+			m->paramlen = NULL;
+                    }
+                }
+
+                if (fm->nolist & NL_LINE) {
+                    istk->noline--;
+                } else if (!istk->noline) {
+                    if (fm == src_macro_current())
+                        src_macro_pop();
+                    src_update(l->where);
+                }
+
+                if (fm->nolist & NL_LIST) {
+                    istk->nolist--;
+                } else if (!istk->nolist) {
+                    lfmt->downlevel(LIST_MACRO);
+                    if ((ppdbg & PDBG_MMACROS) && fm->name)
+                        debug_macro_end(fm);
+                }
+
+                istk->where = l->where;
+
+                /*
+                 * FIXME It is incorrect to always free_mmacro here.
+                 * It leads to usage-after-free.
+                 *
+                 * https://bugzilla.nasm.us/show_bug.cgi?id=3392414
+                 */
+#if 0
+                else
+                    free_mmacro(m);
+#endif
+            }
+            istk->expansion = l->next;
+            nasm_free(l);
+
+            return &tok_pop;
+        }
+
+        do {                    /* until we get a line we can use */
+            char *line;
+
+            if (istk->expansion) {      /* from a macro expansion */
+                Line *l = istk->expansion;
+
+                istk->expansion = l->next;
+                istk->where = l->where;
+                tline = l->first;
+                nasm_free(l);
+
+                if (!istk->noline)
+                    src_update(istk->where);
+
+                if (!istk->nolist) {
+                    line = detoken(tline, false);
+                    lfmt->line(LIST_MACRO, istk->where.lineno, line);
+                    nasm_free(line);
+                }
+            } else if ((line = read_line())) {
+                tline = tokenize(line);
+                nasm_free(line);
+            } else {
+                /*
+                 * The current file has ended; work down the istk
+                 */
+                Include *i = istk;
+
+                if (i->fp)
+                    fclose(i->fp);
+                if (i->conds) {
+                    /* nasm_fatal can't be conditionally suppressed */
+                    nasm_fatal("expected `%%endif' before end of file");
+                }
+
+                istk = i->next;
+
+                if (!i->nolist)
+                    lfmt->downlevel(LIST_INCLUDE);
+                if (!i->noline) {
+                    struct src_location whereto
+                        = istk ? istk->where : src_nowhere();
+                    if (ppdbg & PDBG_INCLUDE)
+                        dfmt->debug_include(false, whereto, i->where);
+                    if (istk)
+                        src_update(istk->where);
+                }
+
+                nasm_free(i);
+                return &tok_pop;
+            }
+        } while (0);
+
+        /*
+         * We must expand MMacro parameters and MMacro-local labels
+         * _before_ we plunge into directive processing, to cope
+         * with things like `%define something %1' such as STRUC
+         * uses. Unless we're _defining_ a MMacro, in which case
+         * those tokens should be left alone to go into the
+         * definition; and unless we're in a non-emitting
+         * condition, in which case we don't want to meddle with
+         * anything.
+         */
+        if (!defining &&
+            !(istk->conds && !emitting(istk->conds->state)) &&
+            !(istk->mstk.mmac && !istk->mstk.mmac->in_progress)) {
+            tline = expand_mmac_params(tline);
+        }
+
+        /*
+         * Check the line to see if it's a preprocessor directive.
+         */
+        if (do_directive(tline, &dtline) == DIRECTIVE_FOUND) {
+            if (dtline)
+                return dtline;
+        } else if (defining) {
+            /*
+             * We're defining a multi-line macro. We emit nothing
+             * at all, and just
+             * shove the tokenized line on to the macro definition.
+             */
+            MMacro *mmac = defining->dstk.mmac;
+            Line *l;
+
+            nasm_new(l);
+            l->next = defining->expansion;
+            l->first = tline;
+            l->finishes = NULL;
+            l->where = istk->where;
+            defining->expansion = l;
+
+            /*
+             * Remember if this mmacro expansion contains %00:
+             * if it does, we will have to handle leading labels
+             * specially.
+             */
+            if (mmac) {
+                const Token *t;
+                list_for_each(t, tline) {
+                    if (t->type == TOKEN_MMACRO_PARAM &&
+                        !memcmp(t->text.a, "%00", 4))
+                        mmac->capture_label = true;
+                }
+            }
+        } else if (istk->conds && !emitting(istk->conds->state)) {
+            /*
+             * We're in a non-emitting branch of a condition block.
+             * Emit nothing at all, not even a blank line: when we
+             * emerge from the condition we'll give a line-number
+             * directive so we keep our place correctly.
+             */
+            free_tlist(tline);
+        } else if (istk->mstk.mstk && !istk->mstk.mstk->in_progress) {
+            /*
+             * We're in a %rep block which has been terminated, so
+             * we're walking through to the %endrep without
+             * emitting anything. Emit nothing at all, not even a
+             * blank line: when we emerge from the %rep block we'll
+             * give a line-number directive so we keep our place
+             * correctly.
+             */
+            free_tlist(tline);
+        } else {
+            tline = expand_smacro(tline);
+            if (!expand_mmacro(tline))
+                return tline;
+        }
+    }
+}
+
+char *pp_getline(void)
+{
+    char *line = NULL;
+    Token *tline;
+
+    while (true) {
+        tline = pp_tokline();
+        if (tline == &tok_pop) {
+            /*
+             * We popped the macro/include stack. If istk is empty,
+             * we are at end of input, otherwise just loop back.
+             */
+            if (!istk)
+                break;
+        } else {
+            /*
+             * De-tokenize the line and emit it.
+             */
+            line = detoken(tline, true);
+            free_tlist(tline);
+            break;
+        }
+    }
+
+    if (list_option('e') && istk && !istk->nolist && line && line[0]) {
+        char *buf = nasm_strcat(" ;;; ", line);
+        lfmt->line(LIST_MACRO, -1, buf);
+        nasm_free(buf);
+    }
+
+    return line;
+}
+
+void pp_cleanup_pass(void)
+{
+    if (defining) {
+        if (defining->name) {
+            nasm_nonfatal("end of file while still defining macro `%s'",
+                          defining->name);
+        } else {
+            nasm_nonfatal("end of file while still in %%rep");
+        }
+
+        free_mmacro(defining);
+        defining = NULL;
+    }
+
+    while (cstk)
+        ctx_pop();
+    free_macros();
+    while (istk) {
+        Include *i = istk;
+        istk = istk->next;
+        fclose(i->fp);
+        if (!istk && (ppdbg & PDBG_INCLUDE)) {
+            /* Signal closing the top-level input file */
+            dfmt->debug_include(false, src_nowhere(), i->where);
+        }
+        nasm_free(i);
+    }
+    while (cstk)
+        ctx_pop();
+    src_set_fname(NULL);
+
+    if (ppdbg & PDBG_MMACROS)
+        debug_macro_output();
+}
+
+void pp_cleanup_session(void)
+{
+    nasm_free(use_loaded);
+    free_llist(predef);
+    predef = NULL;
+    delete_Blocks();
+    ipath_list = NULL;
+}
+
+void pp_include_path(struct strlist *list)
+{
+    ipath_list = list;
+}
+
+void pp_pre_include(char *fname)
+{
+    Token *inc, *space, *name;
+    Line *l;
+
+    name = new_Token(NULL, TOKEN_INTERNAL_STR, fname, 0);
+    space = new_White(name);
+    inc = new_Token(space, TOKEN_PREPROC_ID, "%include", 0);
+
+    l = nasm_malloc(sizeof(Line));
+    l->next = predef;
+    l->first = inc;
+    l->finishes = NULL;
+    predef = l;
+}
+
+void pp_pre_define(char *definition)
+{
+    Token *def, *space;
+    Line *l;
+    char *equals;
+
+    equals = strchr(definition, '=');
+    space = new_White(NULL);
+    def = new_Token(space, TOKEN_PREPROC_ID, "%define", 0);
+    if (equals)
+        *equals = ' ';
+    space->next = tokenize(definition);
+    if (equals)
+        *equals = '=';
+
+    nasm_new(l);
+    l->next = predef;
+    l->first = def;
+    l->finishes = NULL;
+    predef = l;
+}
+
+void pp_pre_undefine(char *definition)
+{
+    Token *def, *space;
+    Line *l;
+
+    space = new_White(NULL);
+    def = new_Token(space, TOKEN_PREPROC_ID, "%undef", 0);
+    space->next = tokenize(definition);
+
+    nasm_new(l);
+    l->next = predef;
+    l->first = def;
+    l->finishes = NULL;
+    predef = l;
+}
+
+/* Insert an early preprocessor command that doesn't need special handling */
+void pp_pre_command(const char *what, char *string)
+{
+    Token *def, *space;
+    Line *l;
+
+    def = tokenize(string);
+    if (what) {
+        space = new_White(def);
+        def = new_Token(space, TOKEN_PREPROC_ID, what, 0);
+    }
+
+    nasm_new(l);
+    l->next = predef;
+    l->first = def;
+    l->finishes = NULL;
+    predef = l;
+}
+
+static void pp_add_stdmac(macros_t *macros)
+{
+    macros_t **mp;
+
+    /* Find the end of the list and avoid duplicates */
+    for (mp = stdmacros; *mp; mp++) {
+        if (*mp == macros)
+            return;             /* Nothing to do */
+    }
+
+    nasm_assert(mp < &stdmacros[ARRAY_SIZE(stdmacros)-1]);
+
+    *mp = macros;
+}
+
+void pp_extra_stdmac(macros_t *macros)
+{
+        extrastdmac = macros;
+}
+
+/* Create a numeric token, with possible - token in front */
+static Token *make_tok_num(Token *next, int64_t val)
+{
+    char numbuf[32];
+    int len;
+    uint64_t uval;
+    bool minus = val < 0;
+
+    uval = minus ? -val : val;
+
+    len = snprintf(numbuf, sizeof numbuf, "%"PRIu64, uval);
+    next = new_Token(next, TOKEN_NUM, numbuf, len);
+
+    if (minus)
+        next = make_tok_char(next, '-');
+
+    return next;
+}
+
+/*
+ * Do the inverse of make_tok_num(). This only needs to be able
+ * to parse the output of make_tok_num().
+ */
+static int64_t get_tok_num(const Token *t, bool *err)
+{
+    bool minus = false;
+    int64_t v;
+
+    if (tok_is(t, '-')) {
+        minus = true;
+        t = t->next;
+    }
+    if (!tok_is(t, TOKEN_NUM)) {
+        if (err)
+            *err = true;
+        return 0;
+    }
+
+    v = readnum(tok_text(t), err);
+    return minus ? -v : v;
+}
+
+/* Create a quoted string token */
+static Token *make_tok_qstr_len(Token *next, const char *str, size_t len)
+{
+    char *p = nasm_quote(str, &len);
+    return new_Token_free(next, TOKEN_STR, p, len);
+}
+static Token *make_tok_qstr(Token *next, const char *str)
+{
+    return make_tok_qstr_len(next, str, strlen(str));
+}
+
+/* Create a single-character operator token */
+static Token *make_tok_char(Token *next, char op)
+{
+    Token *t = new_Token(next, op, NULL, 1);
+    t->text.a[0] = op;
+    return t;
+}
+
+/*
+ * Descent the macro hierarchy and display the expansion after
+ * encountering an error message.
+ */
+void pp_error_list_macros(errflags severity)
+{
+    const MMacro *m;
+
+    severity |= ERR_PP_LISTMACRO | ERR_NO_SEVERITY | ERR_HERE;
+
+    while ((m = src_error_down())) {
+        if ((m->nolist & NL_LIST) || !m->where.filename)
+            break;
+	nasm_error(severity, "... from macro `%s' defined", m->name);
+    }
+
+    src_error_reset();
+}
diff --git a/vere/ext/nasm/asm/preproc.h b/vere/ext/nasm/asm/preproc.h
new file mode 100644
index 0000000..7113046
--- /dev/null
+++ b/vere/ext/nasm/asm/preproc.h
@@ -0,0 +1,56 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * preproc.h  header file for preproc.c
+ */
+
+#ifndef NASM_PREPROC_H
+#define NASM_PREPROC_H
+
+#include "nasmlib.h"
+#include "pptok.h"
+
+extern const char * const pp_directives[];
+extern const uint8_t pp_directives_len[];
+
+/* Pointer to a macro chain */
+typedef const unsigned char macros_t;
+
+enum preproc_token pp_token_hash(const char *token);
+enum preproc_token pp_tasm_token_hash(const char *token);
+
+/* Opens an include file or input file. This uses the include path. */
+FILE *pp_input_fopen(const char *filename, enum file_flags mode);
+
+#endif
diff --git a/vere/ext/nasm/asm/quote.c b/vere/ext/nasm/asm/quote.c
new file mode 100644
index 0000000..074f17d
--- /dev/null
+++ b/vere/ext/nasm/asm/quote.c
@@ -0,0 +1,563 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * quote.c
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "quote.h"
+#include "nctype.h"
+#include "error.h"
+
+/*
+ * Create a NASM quoted string in newly allocated memory. Update the
+ * *lenp parameter with the output length (sans final NUL).
+ */
+
+char *nasm_quote(const char *str, size_t *lenp)
+{
+    const char *p, *ep;
+    char c, c1, *q, *nstr;
+    unsigned char uc;
+    bool sq_ok, dq_ok;
+    size_t qlen;
+    size_t len = *lenp;
+
+    sq_ok = dq_ok = true;
+    ep = str+len;
+    qlen = 0;			/* Length if we need `...` quotes */
+    for (p = str; p < ep; p++) {
+	c = *p;
+	switch (c) {
+	case '\'':
+	    sq_ok = false;
+	    qlen++;
+	    break;
+	case '\"':
+	    dq_ok = false;
+	    qlen++;
+	    break;
+	case '`':
+	case '\\':
+	    qlen += 2;
+	    break;
+	default:
+	    if (c < ' ' || c > '~') {
+		sq_ok = dq_ok = false;
+		switch (c) {
+		case '\a':
+		case '\b':
+		case '\t':
+		case '\n':
+		case '\v':
+		case '\f':
+		case '\r':
+		case 27:
+		    qlen += 2;
+		    break;
+		default:
+		    c1 = (p+1 < ep) ? p[1] : 0;
+		    if (c1 >= '0' && c1 <= '7')
+			uc = 0377; /* Must use the full form */
+		    else
+			uc = c;
+		    if (uc > 077)
+			qlen++;
+		    if (uc > 07)
+			qlen++;
+		    qlen += 2;
+		    break;
+		}
+	    } else {
+		qlen++;
+	    }
+	    break;
+	}
+    }
+
+    if (sq_ok || dq_ok) {
+	/* Use '...' or "..." */
+	nstr = nasm_malloc(len+3);
+	nstr[0] = nstr[len+1] = sq_ok ? '\'' : '\"';
+        q = &nstr[len+2];
+	if (len > 0)
+	    memcpy(nstr+1, str, len);
+    } else {
+	/* Need to use `...` quoted syntax */
+	nstr = nasm_malloc(qlen+3);
+	q = nstr;
+	*q++ = '`';
+	for (p = str; p < ep; p++) {
+	    c = *p;
+	    switch (c) {
+	    case '`':
+	    case '\\':
+		*q++ = '\\';
+		*q++ = c;
+		break;
+	    case 7:
+		*q++ = '\\';
+		*q++ = 'a';
+		break;
+	    case 8:
+		*q++ = '\\';
+		*q++ = 'b';
+		break;
+	    case 9:
+		*q++ = '\\';
+		*q++ = 't';
+		break;
+	    case 10:
+		*q++ = '\\';
+		*q++ = 'n';
+		break;
+	    case 11:
+		*q++ = '\\';
+		*q++ = 'v';
+		break;
+	    case 12:
+		*q++ = '\\';
+		*q++ = 'f';
+		break;
+	    case 13:
+		*q++ = '\\';
+		*q++ = 'r';
+		break;
+	    case 27:
+		*q++ = '\\';
+		*q++ = 'e';
+		break;
+	    default:
+		if (c < ' ' || c > '~') {
+		    c1 = (p+1 < ep) ? p[1] : 0;
+		    if (c1 >= '0' && c1 <= '7')
+			uc = 0377; /* Must use the full form */
+		    else
+			uc = c;
+		    *q++ = '\\';
+		    if (uc > 077)
+			*q++ = ((unsigned char)c >> 6) + '0';
+		    if (uc > 07)
+			*q++ = (((unsigned char)c >> 3) & 7) + '0';
+		    *q++ = ((unsigned char)c & 7) + '0';
+		    break;
+		} else {
+		    *q++ = c;
+		}
+		break;
+	    }
+	}
+	*q++ = '`';
+	nasm_assert((size_t)(q-nstr) == qlen+2);
+    }
+    *q = '\0';
+    *lenp = q - nstr;
+    return nstr;
+}
+
+static unsigned char *emit_utf8(unsigned char *q, uint32_t v)
+{
+    uint32_t vb1, vb2, vb3, vb4, vb5;
+
+    if (v <= 0x7f) {
+	*q++ = v;
+        goto out0;
+    }
+
+    vb1 = v >> 6;
+    if (vb1 <= 0x1f) {
+	*q++ = 0xc0 + vb1;
+        goto out1;
+    }
+
+    vb2 = vb1 >> 6;
+    if (vb2 <= 0x0f) {
+        *q++ = 0xe0 + vb2;
+        goto out2;
+    }
+
+    vb3 = vb2 >> 6;
+    if (vb3 <= 0x07) {
+        *q++ = 0xf0 + vb3;
+        goto out3;
+    }
+
+    vb4 = vb3 >> 6;
+    if (vb4 <= 0x03) {
+        *q++ = 0xf8 + vb4;
+        goto out4;
+    }
+
+    /*
+     * Note: this is invalid even for "classic" (pre-UTF16) 31-bit
+     * UTF-8 if the value is >= 0x8000000. This at least tries to do
+     * something vaguely sensible with it. Caveat programmer.
+     * The __utf*__ string transform functions do reject these
+     * as invalid input.
+     *
+     * vb5 cannot be more than 3, as a 32-bit value has been shifted
+     * right by 5*6 = 30 bits already.
+     */
+    vb5 = vb4 >> 6;
+    *q++ = 0xfc + vb5;
+    goto out5;
+
+    /* Emit extension bytes as appropriate */
+out5: *q++ = 0x80 + (vb4 & 63);
+out4: *q++ = 0x80 + (vb3 & 63);
+out3: *q++ = 0x80 + (vb2 & 63);
+out2: *q++ = 0x80 + (vb1 & 63);
+out1: *q++ = 0x80 + (v & 63);
+out0: return q;
+}
+
+static inline uint32_t ctlbit(uint32_t v)
+{
+    return unlikely(v < 32) ? UINT32_C(1) << v : 0;
+}
+
+#define CTL_ERR(c)						\
+    (badctl & (ctlmask |= ctlbit(c)))
+
+#define EMIT_UTF8(c)						\
+    do {							\
+        uint32_t ec = (c);                                      \
+        if (!CTL_ERR(ec))                                       \
+            q = emit_utf8(q, ec);                               \
+    } while (0)
+
+#define EMIT(c)                                                 \
+    do {                                                        \
+        unsigned char ec = (c);                                 \
+        if (!CTL_ERR(ec))                                       \
+            *q++ = ec;                                          \
+    } while (0)
+
+/*
+ * Same as nasm_quote, but take the length of a C string;
+ * the lenp argument is optional.
+ */
+char *nasm_quote_cstr(const char *str, size_t *lenp)
+{
+    size_t len = strlen(str);
+    char *qstr = nasm_quote(str, &len);
+    if (lenp)
+        *lenp = len;
+    return qstr;
+}
+
+/*
+ * Do an *in-place* dequoting of the specified string, returning the
+ * resulting length (which may be containing embedded nulls.)
+ *
+ * In-place replacement is possible since the unquoted length is always
+ * shorter than or equal to the quoted length.
+ *
+ * *ep points to the final quote, or to the null if improperly quoted.
+ *
+ * Issue an error if the string contains control characters
+ * corresponding to bits set in badctl; in that case, the output
+ * string, but not *ep, is truncated before the first invalid
+ * character.
+ *
+ * badctl is a bitmask of control characters (0-31) which are forbidden
+ * from appearing in the final output.
+ *
+ * The qstart character can be either '`' (NASM style) or '\"' (C style),
+ * to indicate the lead marker of a quoted string. If it is '\"', then
+ * '`' is not a special character at all.
+ */
+
+size_t nasm_unquote_anystr(char *str, char **ep, const uint32_t badctl,
+                           const char qstart)
+{
+    unsigned char bq;
+    const unsigned char *p;
+    const unsigned char *escp = NULL;
+    unsigned char *q;
+    unsigned char c;
+    uint32_t ctlmask = 0;       /* Mask of control characters seen */
+    enum unq_state {
+	st_start,
+	st_backslash,
+	st_hex,
+	st_oct,
+	st_ucs,
+        st_done
+    } state;
+    int ndig = 0;
+    uint32_t nval = 0;
+
+    p = q = (unsigned char *)str;
+
+    bq = *p++;
+    if (!bq)
+	return 0;
+
+    if (bq == (unsigned char)qstart) {
+	/* `...` string */
+	state = st_start;
+
+	while (state != st_done) {
+	    c = *p++;
+	    switch (state) {
+	    case st_start:
+                if (c == '\\') {
+		    state = st_backslash;
+                } else if ((c == '\0') | (c == bq)) {
+                    state = st_done;
+                } else {
+                    EMIT(c);
+                }
+		break;
+
+	    case st_backslash:
+		state = st_start;
+		escp = p;	/* Beginning of argument sequence */
+		nval = 0;
+		switch (c) {
+		case 'a':
+		    nval = 7;
+		    break;
+		case 'b':
+		    nval = 8;
+		    break;
+		case 'e':
+		    nval = 27;
+		    break;
+		case 'f':
+		    nval = 12;
+		    break;
+		case 'n':
+		    nval = 10;
+		    break;
+		case 'r':
+		    nval = 13;
+		    break;
+		case 't':
+		    nval = 9;
+		    break;
+		case 'u':
+		    state = st_ucs;
+		    ndig = 4;
+		    break;
+		case 'U':
+		    state = st_ucs;
+		    ndig = 8;
+		    break;
+		case 'v':
+		    nval = 11;
+		    break;
+		case 'x':
+		case 'X':
+		    state = st_hex;
+		    ndig = 2;
+		    break;
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		    state = st_oct;
+		    ndig = 2;	/* Up to two more digits */
+		    nval = c - '0';
+		    break;
+                case '\0':
+                    nval = '\\';
+                    p--;        /* Reprocess; terminates string */
+                    break;
+		default:
+		    nval = c;
+		    break;
+		}
+                if (state == st_start)
+                    EMIT(nval);
+		break;
+
+	    case st_oct:
+		if (c >= '0' && c <= '7') {
+		    nval = (nval << 3) + (c - '0');
+                    if (--ndig)
+                        break;  /* Might have more digits */
+                } else {
+		    p--;	/* Process this character again */
+                }
+                EMIT(nval);
+                state = st_start;
+                break;
+
+	    case st_hex:
+            case st_ucs:
+		if (nasm_isxdigit(c)) {
+		    nval = (nval << 4) + numvalue(c);
+                    if (--ndig)
+                        break;  /* Might have more digits */
+                } else {
+		    p--;	/* Process this character again */
+                }
+
+                if (unlikely(p <= escp))
+                    EMIT(escp[-1]);
+                else if (state == st_ucs)
+                    EMIT_UTF8(nval);
+                else
+                    EMIT(nval);
+
+                state = st_start;
+		break;
+
+            default:
+                panic();
+            }
+        }
+    } else if (bq == '\'' || bq == '\"') {
+	/*
+         * '...' or "..." string, NASM legacy style (no escapes of
+         * * any kind, including collapsing double quote marks.)
+         * We obviously can't get here if qstart == '\"'.
+         */
+        while ((c = *p++) && (c != bq))
+            EMIT(c);
+    } else {
+	/* Not a quoted string, just return the input... */
+        while ((c = *p++))
+            EMIT(c);
+    }
+
+    /* Zero-terminate the output */
+    *q = '\0';
+
+    if (ctlmask & badctl)
+        nasm_nonfatal("control character in string not allowed here");
+
+    if (ep)
+	*ep = (char *)p - 1;
+    return (char *)q - str;
+}
+#undef EMIT
+
+/*
+ * Unquote any arbitrary string; may produce any bytes, including embedded
+ * control- and NUL characters.
+ */
+size_t nasm_unquote(char *str, char **ep)
+{
+    return nasm_unquote_anystr(str, ep, 0, STR_NASM);
+}
+
+/*
+ * Unquote a string intended to be used as a C string; most control
+ * characters are rejected, including whitespace characters that
+ * would imply line endings and so on.
+ */
+size_t nasm_unquote_cstr(char *str, char **ep)
+{
+    return nasm_unquote_anystr(str, ep, BADCTL, STR_NASM);
+}
+
+/*
+ * Find the end of a quoted string; returns the pointer to the terminating
+ * character (either the ending quote or the null character, if unterminated.)
+ * If the input is not a quoted string, return NULL.
+ * This applies to NASM style strings only.
+ */
+char *nasm_skip_string(const char *str)
+{
+    char bq;
+    const char *p;
+    char c;
+    enum unq_state {
+	st_start,
+	st_backslash,
+        st_done
+    } state;
+
+    bq = str[0];
+    p = str+1;
+    switch (bq) {
+    case '\'':
+    case '\"':
+	/* '...' or "..." string */
+        while ((c = *p++) && (c != bq))
+            ;
+        break;
+
+    case '`':
+	/* `...` string */
+	state = st_start;
+	while (state != st_done) {
+            c = *p++;
+	    switch (state) {
+	    case st_start:
+		switch (c) {
+		case '\\':
+		    state = st_backslash;
+		    break;
+		case '`':
+                case '\0':
+                    state = st_done;
+                    break;
+		default:
+		    break;
+		}
+		break;
+
+	    case st_backslash:
+		/*
+		 * Note: for the purpose of finding the end of the string,
+		 * all successor states to st_backslash are functionally
+		 * equivalent to st_start, since either a backslash or
+		 * a backquote will force a return to the st_start state,
+                 * and any possible multi-character state will terminate
+                 * for any non-alphanumeric character.
+		 */
+		state = c ? st_start : st_done;
+		break;
+
+            default:
+                panic();
+	    }
+	}
+        break;
+
+    default:
+        /* Not a string at all... */
+        return NULL;
+    }
+    return (char *)p - 1;
+}
diff --git a/vere/ext/nasm/asm/quote.h b/vere/ext/nasm/asm/quote.h
new file mode 100644
index 0000000..d8226cd
--- /dev/null
+++ b/vere/ext/nasm/asm/quote.h
@@ -0,0 +1,61 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASM_QUOTE_H
+#define NASM_QUOTE_H
+
+#include "compiler.h"
+
+char *nasm_quote(const char *str, size_t *len);
+char *nasm_quote_cstr(const char *str, size_t *len);
+size_t nasm_unquote_anystr(char *str, char **endptr,
+                           uint32_t badctl, char qstart);
+size_t nasm_unquote(char *str, char **endptr);
+size_t nasm_unquote_cstr(char *str, char **endptr);
+char *nasm_skip_string(const char *str);
+
+/* Arguments used with nasm_quote_anystr() */
+
+/*
+ * These are the only control characters when we produce a C string:
+ * BEL BS TAB ESC
+ */
+#define OKCTL ((1U << '\a') | (1U << '\b') | (1U << '\t') | (1U << 27))
+#define BADCTL (~(uint32_t)OKCTL)
+
+/* Initial quotation mark */
+#define STR_C    '\"'
+#define STR_NASM '`'
+
+#endif /* NASM_QUOTE_H */
+
diff --git a/vere/ext/nasm/asm/rdstrnum.c b/vere/ext/nasm/asm/rdstrnum.c
new file mode 100644
index 0000000..319f140
--- /dev/null
+++ b/vere/ext/nasm/asm/rdstrnum.c
@@ -0,0 +1,70 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rdstrnum.c
+ *
+ * This converts a NASM string to an integer, used when a string
+ * is used in an integer constant context.  This is a binary conversion,
+ * not a conversion from a numeric constant in text form.
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "nasm.h"
+
+int64_t readstrnum(char *str, int length, bool *warn)
+{
+    int64_t charconst = 0;
+    int i;
+
+    *warn = false;
+
+    str += length;
+    if (globalbits == 64) {
+        for (i = 0; i < length; i++) {
+            if (charconst & UINT64_C(0xFF00000000000000))
+                *warn = true;
+            charconst &= ~UINT64_C(0xFF00000000000000);
+            charconst = (charconst << 8) + (uint8_t)*--str;
+        }
+    } else {
+        for (i = 0; i < length; i++) {
+            if (charconst & UINT32_C(0xFF000000))
+                *warn = true;
+            charconst &= ~UINT32_C(0xFF000000);
+            charconst = (charconst << 8) + (uint8_t)*--str;
+        }
+    }
+    return charconst;
+}
diff --git a/vere/ext/nasm/asm/segalloc.c b/vere/ext/nasm/asm/segalloc.c
new file mode 100644
index 0000000..6d7a420
--- /dev/null
+++ b/vere/ext/nasm/asm/segalloc.c
@@ -0,0 +1,51 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+#include "nasm.h"
+#include "nasmlib.h"
+#include "insns.h"
+
+static int32_t next_seg  = 2;
+
+int32_t seg_alloc(void)
+{
+    int32_t this_seg = next_seg;
+
+    next_seg += 2;
+    return this_seg;
+}
diff --git a/vere/ext/nasm/asm/srcfile.c b/vere/ext/nasm/asm/srcfile.c
new file mode 100644
index 0000000..b44c021
--- /dev/null
+++ b/vere/ext/nasm/asm/srcfile.c
@@ -0,0 +1,118 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * srcfile.c - keep track of the current position in the input stream.
+ *
+ * This is used for error messages, listing, and debug information. In
+ * both cases we also want to understand where inside a non-nolist
+ * macro we may be.
+ *
+ * This hierarchy is a stack that is kept as a doubly-linked list, as
+ * we want to traverse it in either top-down order or bottom-up.
+ */
+
+#include "compiler.h"
+
+
+#include "nasmlib.h"
+#include "hashtbl.h"
+#include "srcfile.h"
+
+struct src_location_stack _src_top;
+struct src_location_stack *_src_bottom = &_src_top;
+struct src_location_stack *_src_error = &_src_top;
+
+static struct hash_table filename_hash;
+
+void src_init(void)
+{
+}
+
+void src_free(void)
+{
+    hash_free_all(&filename_hash, false);
+}
+
+/*
+ * Set the current filename, returning the old one.  The input
+ * filename is duplicated if needed.
+ */
+const char *src_set_fname(const char *newname)
+{
+    struct hash_insert hi;
+    const char *oldname;
+    void **dp;
+
+    if (newname) {
+        dp = hash_find(&filename_hash, newname, &hi);
+        if (dp) {
+            newname = (const char *)(*dp);
+        } else {
+            newname = nasm_strdup(newname);
+            hash_add(&hi, newname, (void *)newname);
+        }
+    }
+
+    oldname = _src_bottom->l.filename;
+    _src_bottom->l.filename = newname;
+    return oldname;
+}
+
+void src_set(int32_t line, const char *fname)
+{
+    src_set_fname(fname);
+    src_set_linnum(line);
+}
+
+void src_macro_push(const void *macro, struct src_location where)
+{
+    struct src_location_stack *sl;
+
+    nasm_new(sl);
+    sl->l = where;
+    sl->macro = macro;
+    sl->up = _src_bottom;
+    _src_bottom->down = sl;
+    _src_bottom = sl;
+}
+
+void src_macro_pop(void)
+{
+    struct src_location_stack *sl = _src_bottom;
+
+    _src_bottom = sl->up;
+    _src_bottom->down = NULL;
+
+    nasm_free(sl);
+}
diff --git a/vere/ext/nasm/asm/srcfile.h b/vere/ext/nasm/asm/srcfile.h
new file mode 100644
index 0000000..a185354
--- /dev/null
+++ b/vere/ext/nasm/asm/srcfile.h
@@ -0,0 +1,183 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * These functions are used to keep track of the source code file and name.
+ */
+#ifndef ASM_SRCFILE_H
+#define ASM_SRCFILE_H
+
+#include "compiler.h"
+
+struct src_location {
+    const char *filename;
+    int32_t lineno;
+};
+
+static inline const_func struct src_location src_nowhere(void)
+{
+    struct src_location no_where = { NULL, 0 };
+    return no_where;
+}
+
+/*
+ * Comparing the *pointer value* of filenames is valid, because the
+ * filename hash system guarantees that each unique filename string is
+ * permanently allocated in exactly one location.
+ */
+static inline bool
+src_location_same(struct src_location here, struct src_location there)
+{
+    return here.filename == there.filename && here.lineno == there.lineno;
+}
+
+struct src_location_stack {
+    struct src_location l;
+    struct src_location_stack *up, *down;
+    const void *macro;
+};
+extern struct src_location_stack _src_top;
+extern struct src_location_stack *_src_bottom;
+extern struct src_location_stack *_src_error;
+
+void src_init(void);
+void src_free(void);
+const char *src_set_fname(const char *newname);
+static inline const char *src_get_fname(void)
+{
+    return _src_bottom->l.filename;
+}
+static inline int32_t src_set_linnum(int32_t newline)
+{
+    int32_t oldline = _src_bottom->l.lineno;
+    _src_bottom->l.lineno = newline;
+    return oldline;
+}
+static inline int32_t src_get_linnum(void)
+{
+    return _src_bottom->l.lineno;
+}
+
+/* Can be used when there is no need for the old information */
+void src_set(int32_t line, const char *filename);
+
+/*
+ * src_get gets both the source file name and line.
+ * It is also used if you maintain private status about the source location
+ * It return 0 if the information was the same as the last time you
+ * checked, -2 if the name changed and (new-old) if just the line changed.
+ *
+ * xname must point to a filename string previously returned from any
+ * function of this subsystem or be NULL; another string value will
+ * not work.
+ */
+static inline int32_t src_get(int32_t *xline, const char **xname)
+{
+    const char *xn = *xname;
+    int32_t xl = *xline;
+    int32_t line = _src_bottom->l.lineno;
+
+    *xline = line;
+    *xname = _src_bottom->l.filename;
+
+    /* The return value is expected to be optimized out almost everywhere */
+    if (!xn || xn != _src_bottom->l.filename)
+        return -2;
+    else
+        return line - xl;
+}
+
+/*
+ * Returns the current information as a structure.
+ */
+static inline struct src_location src_where(void)
+{
+    return _src_bottom->l;
+}
+
+/*
+ * Returns the top-level information as a structure. Use this for panic
+ * errors, since descent is not possible there.
+ */
+static inline struct src_location src_where_top(void)
+{
+    return _src_top.l;
+}
+
+/*
+ * Returns the appropriate level of the location stack to use for error
+ * messages. This is the same as the top level except during the descent
+ * through the macro hierarchy for elucidation;
+ */
+static inline struct src_location src_where_error(void)
+{
+    return _src_error->l;
+}
+static inline const void *src_error_down(void)
+{
+    if (_src_error->down) {
+        _src_error = _src_error->down;
+        return _src_error->macro;
+    } else {
+        return NULL;
+    }
+}
+static inline void src_error_reset(void)
+{
+    _src_error = &_src_top;
+}
+
+/*
+ * Sets the current information. The filename member of the structure
+ * *must* have been previously returned by src_get(), src_where(), or
+ * src_get_fname() and therefore be present in the hash.
+ */
+static inline struct src_location src_update(struct src_location whence)
+{
+    struct src_location old = _src_bottom->l;
+    _src_bottom->l = whence;
+    return old;
+}
+
+/*
+ * Push/pop macro expansion level. "macroname" must remain constant at
+ * least until the same macro expansion level is popped.
+ */
+void src_macro_push(const void *macroname, struct src_location where);
+static inline const void *src_macro_current(void)
+{
+    return _src_bottom->macro;
+}
+void src_macro_pop(void);
+
+#endif /* ASM_SRCFILE_H */
diff --git a/vere/ext/nasm/asm/stdscan.c b/vere/ext/nasm/asm/stdscan.c
new file mode 100644
index 0000000..cbc0fc7
--- /dev/null
+++ b/vere/ext/nasm/asm/stdscan.c
@@ -0,0 +1,346 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "quote.h"
+#include "stdscan.h"
+#include "insns.h"
+
+/*
+ * Standard scanner routine used by parser.c and some output
+ * formats. It keeps a succession of temporary-storage strings in
+ * stdscan_tempstorage, which can be cleared using stdscan_reset.
+ */
+static char *stdscan_bufptr = NULL;
+static char **stdscan_tempstorage = NULL;
+static int stdscan_tempsize = 0, stdscan_templen = 0;
+#define STDSCAN_TEMP_DELTA 256
+
+void stdscan_set(char *str)
+{
+        stdscan_bufptr = str;
+}
+
+char *stdscan_get(void)
+{
+        return stdscan_bufptr;
+}
+
+static void stdscan_pop(void)
+{
+    nasm_free(stdscan_tempstorage[--stdscan_templen]);
+}
+
+void stdscan_reset(void)
+{
+    while (stdscan_templen > 0)
+        stdscan_pop();
+}
+
+/*
+ * Unimportant cleanup is done to avoid confusing people who are trying
+ * to debug real memory leaks
+ */
+void stdscan_cleanup(void)
+{
+    stdscan_reset();
+    nasm_free(stdscan_tempstorage);
+}
+
+static char *stdscan_copy(const char *p, int len)
+{
+    char *text;
+
+    text = nasm_malloc(len + 1);
+    memcpy(text, p, len);
+    text[len] = '\0';
+
+    if (stdscan_templen >= stdscan_tempsize) {
+        stdscan_tempsize += STDSCAN_TEMP_DELTA;
+        stdscan_tempstorage = nasm_realloc(stdscan_tempstorage,
+                                           stdscan_tempsize *
+                                           sizeof(char *));
+    }
+    stdscan_tempstorage[stdscan_templen++] = text;
+
+    return text;
+}
+
+/*
+ * a token is enclosed with braces. proper token type will be assigned
+ * accordingly with the token flag.
+ */
+static int stdscan_handle_brace(struct tokenval *tv)
+{
+    if (!(tv->t_flag & TFLAG_BRC_ANY)) {
+        /* invalid token is put inside braces */
+        nasm_nonfatal("`%s' is not a valid decorator with braces", tv->t_charptr);
+        tv->t_type = TOKEN_INVALID;
+    } else if (tv->t_flag & TFLAG_BRC_OPT) {
+        if (is_reg_class(OPMASKREG, tv->t_integer)) {
+            /* within braces, opmask register is now used as a mask */
+            tv->t_type = TOKEN_OPMASK;
+        }
+    }
+
+    return tv->t_type;
+}
+
+int stdscan(void *private_data, struct tokenval *tv)
+{
+    const char *r;
+
+    (void)private_data;         /* Don't warn that this parameter is unused */
+
+    nasm_zero(*tv);
+
+    stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr);
+    if (!*stdscan_bufptr)
+        return tv->t_type = TOKEN_EOS;
+
+    /* we have a token; either an id, a number or a char */
+    if (nasm_isidstart(*stdscan_bufptr) ||
+        (*stdscan_bufptr == '$' && nasm_isidstart(stdscan_bufptr[1]))) {
+        /* now we've got an identifier */
+        bool is_sym = false;
+        int token_type;
+
+        if (*stdscan_bufptr == '$') {
+            is_sym = true;
+            stdscan_bufptr++;
+        }
+
+        r = stdscan_bufptr++;
+        /* read the entire buffer to advance the buffer pointer but... */
+        while (nasm_isidchar(*stdscan_bufptr))
+            stdscan_bufptr++;
+
+        /* ... copy only up to IDLEN_MAX-1 characters */
+        tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r < IDLEN_MAX ?
+                                     stdscan_bufptr - r : IDLEN_MAX - 1);
+
+        if (is_sym || stdscan_bufptr - r > MAX_KEYWORD)
+            return tv->t_type = TOKEN_ID;       /* bypass all other checks */
+
+        token_type = nasm_token_hash(tv->t_charptr, tv);
+        if (unlikely(tv->t_flag & TFLAG_WARN)) {
+            /*!
+             *!ptr [on] non-NASM keyword used in other assemblers
+             *!  warns about keywords used in other assemblers that might
+             *!  indicate a mistake in the source code.  Currently only the MASM
+             *!  \c{PTR} keyword is recognized. See also \k{pkg_masm}.
+             */
+            nasm_warn(WARN_PTR, "`%s' is not a NASM keyword",
+                       tv->t_charptr);
+        }
+
+        if (likely(!(tv->t_flag & TFLAG_BRC))) {
+            /* most of the tokens fall into this case */
+            return token_type;
+        } else {
+            return tv->t_type = TOKEN_ID;
+        }
+    } else if (*stdscan_bufptr == '$' && !nasm_isnumchar(stdscan_bufptr[1])) {
+        /*
+         * It's a $ sign with no following hex number; this must
+         * mean it's a Here token ($), evaluating to the current
+         * assembly location, or a Base token ($$), evaluating to
+         * the base of the current segment.
+         */
+        stdscan_bufptr++;
+        if (*stdscan_bufptr == '$') {
+            stdscan_bufptr++;
+            return tv->t_type = TOKEN_BASE;
+        }
+        return tv->t_type = TOKEN_HERE;
+    } else if (nasm_isnumstart(*stdscan_bufptr)) {   /* now we've got a number */
+        bool rn_error;
+        bool is_hex = false;
+        bool is_float = false;
+        bool has_e = false;
+        char c;
+
+        r = stdscan_bufptr;
+
+        if (*stdscan_bufptr == '$') {
+            stdscan_bufptr++;
+            is_hex = true;
+        }
+
+        for (;;) {
+            c = *stdscan_bufptr++;
+
+            if (!is_hex && (c == 'e' || c == 'E')) {
+                has_e = true;
+                if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-') {
+                    /*
+                     * e can only be followed by +/- if it is either a
+                     * prefixed hex number or a floating-point number
+                     */
+                    is_float = true;
+                    stdscan_bufptr++;
+                }
+            } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') {
+                is_hex = true;
+            } else if (c == 'P' || c == 'p') {
+                is_float = true;
+                if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-')
+                    stdscan_bufptr++;
+            } else if (nasm_isnumchar(c))
+                ; /* just advance */
+            else if (c == '.')
+                is_float = true;
+            else
+                break;
+        }
+        stdscan_bufptr--;       /* Point to first character beyond number */
+
+        if (has_e && !is_hex) {
+            /* 1e13 is floating-point, but 1e13h is not */
+            is_float = true;
+        }
+
+        if (is_float) {
+            tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r);
+            return tv->t_type = TOKEN_FLOAT;
+        } else {
+            r = stdscan_copy(r, stdscan_bufptr - r);
+            tv->t_integer = readnum(r, &rn_error);
+            stdscan_pop();
+            if (rn_error) {
+                /* some malformation occurred */
+                return tv->t_type = TOKEN_ERRNUM;
+            }
+            tv->t_charptr = NULL;
+            return tv->t_type = TOKEN_NUM;
+        }
+    } else if (*stdscan_bufptr == '\'' || *stdscan_bufptr == '"' ||
+               *stdscan_bufptr == '`') {
+        /* a quoted string */
+        char start_quote = *stdscan_bufptr;
+        tv->t_charptr = stdscan_bufptr;
+        tv->t_inttwo = nasm_unquote(tv->t_charptr, &stdscan_bufptr);
+        if (*stdscan_bufptr != start_quote)
+            return tv->t_type = TOKEN_ERRSTR;
+        stdscan_bufptr++;       /* Skip final quote */
+        return tv->t_type = TOKEN_STR;
+    } else if (*stdscan_bufptr == '{') {
+        /* now we've got a decorator */
+        int token_len;
+
+        stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr);
+
+        r = ++stdscan_bufptr;
+        /*
+         * read the entire buffer to advance the buffer pointer
+         * {rn-sae}, {rd-sae}, {ru-sae}, {rz-sae} contain '-' in tokens.
+         */
+        while (nasm_isbrcchar(*stdscan_bufptr))
+            stdscan_bufptr++;
+
+        token_len = stdscan_bufptr - r;
+
+        /* ... copy only up to DECOLEN_MAX-1 characters */
+        tv->t_charptr = stdscan_copy(r, token_len < DECOLEN_MAX ?
+                                        token_len : DECOLEN_MAX - 1);
+
+        stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr);
+        /* if brace is not closed properly or token is too long  */
+        if ((*stdscan_bufptr != '}') || (token_len > MAX_KEYWORD)) {
+            nasm_nonfatal("invalid decorator token inside braces");
+            return tv->t_type = TOKEN_INVALID;
+        }
+
+        stdscan_bufptr++;       /* skip closing brace */
+
+        /* handle tokens inside braces */
+        nasm_token_hash(tv->t_charptr, tv);
+        return stdscan_handle_brace(tv);
+    } else if (*stdscan_bufptr == ';') {
+        /* a comment has happened - stay */
+        return tv->t_type = TOKEN_EOS;
+    } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '>') {
+        if (stdscan_bufptr[2] == '>') {
+            stdscan_bufptr += 3;
+            return tv->t_type = TOKEN_SAR;
+        } else {
+            stdscan_bufptr += 2;
+            return tv->t_type = TOKEN_SHR;
+        }
+    } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '<') {
+        stdscan_bufptr += stdscan_bufptr[2] == '<' ? 3 : 2;
+        return tv->t_type = TOKEN_SHL;
+    } else if (stdscan_bufptr[0] == '/' && stdscan_bufptr[1] == '/') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_SDIV;
+    } else if (stdscan_bufptr[0] == '%' && stdscan_bufptr[1] == '%') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_SMOD;
+    } else if (stdscan_bufptr[0] == '=' && stdscan_bufptr[1] == '=') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_EQ;
+    } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '>') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_NE;
+    } else if (stdscan_bufptr[0] == '!' && stdscan_bufptr[1] == '=') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_NE;
+    } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '=') {
+        if (stdscan_bufptr[2] == '>') {
+            stdscan_bufptr += 3;
+            return tv->t_type = TOKEN_LEG;
+        } else {
+            stdscan_bufptr += 2;
+            return tv->t_type = TOKEN_LE;
+        }
+    } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '=') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_GE;
+    } else if (stdscan_bufptr[0] == '&' && stdscan_bufptr[1] == '&') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_DBL_AND;
+    } else if (stdscan_bufptr[0] == '^' && stdscan_bufptr[1] == '^') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_DBL_XOR;
+    } else if (stdscan_bufptr[0] == '|' && stdscan_bufptr[1] == '|') {
+        stdscan_bufptr += 2;
+        return tv->t_type = TOKEN_DBL_OR;
+    } else                      /* just an ordinary char */
+        return tv->t_type = (uint8_t)(*stdscan_bufptr++);
+}
diff --git a/vere/ext/nasm/asm/stdscan.h b/vere/ext/nasm/asm/stdscan.h
new file mode 100644
index 0000000..8dbc2d0
--- /dev/null
+++ b/vere/ext/nasm/asm/stdscan.h
@@ -0,0 +1,49 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * stdscan.h	header file for stdscan.c
+ */
+
+#ifndef NASM_STDSCAN_H
+#define NASM_STDSCAN_H
+
+/* Standard scanner */
+void stdscan_set(char *str);
+char *stdscan_get(void);
+void stdscan_reset(void);
+int stdscan(void *private_data, struct tokenval *tv);
+int nasm_token_hash(const char *token, struct tokenval *tv);
+void stdscan_cleanup(void);
+
+#endif
diff --git a/vere/ext/nasm/asm/strfunc.c b/vere/ext/nasm/asm/strfunc.c
new file mode 100644
index 0000000..236b9d2
--- /dev/null
+++ b/vere/ext/nasm/asm/strfunc.c
@@ -0,0 +1,359 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * strfunc.c
+ *
+ * String transformation functions
+ */
+
+#include "nasmlib.h"
+#include "nasm.h"
+
+/*
+ * Convert a string in UTF-8 format to UTF-16LE
+ */
+static size_t utf8_to_16le(uint8_t *str, size_t len, char *op)
+{
+#define EMIT(x) do { if (op) { WRITESHORT(op,x); } outlen++; } while(0)
+
+    size_t outlen = 0;
+    int expect = 0;
+    uint8_t c;
+    uint32_t v = 0, vmin = 0;
+
+    while (len--) {
+        c = *str++;
+
+        if (expect) {
+            if ((c & 0xc0) != 0x80) {
+                expect = 0;
+                return -1;
+            } else {
+                v = (v << 6) | (c & 0x3f);
+                if (!--expect) {
+                    if (v < vmin || v > 0x10ffff ||
+                        (v >= 0xd800 && v <= 0xdfff)) {
+                        return -1;
+                    } else if (v > 0xffff) {
+                        v -= 0x10000;
+                        EMIT(0xd800 | (v >> 10));
+                        EMIT(0xdc00 | (v & 0x3ff));
+                    } else {
+                        EMIT(v);
+                    }
+                }
+                continue;
+            }
+        }
+
+        if (c < 0x80) {
+            EMIT(c);
+        } else if (c < 0xc0 || c >= 0xfe) {
+            /* Invalid UTF-8 */
+            return -1;
+        } else if (c < 0xe0) {
+            v = c & 0x1f;
+            expect = 1;
+            vmin = 0x80;
+        } else if (c < 0xf0) {
+            v = c & 0x0f;
+            expect = 2;
+            vmin = 0x800;
+        } else if (c < 0xf8) {
+            v = c & 0x07;
+            expect = 3;
+            vmin = 0x10000;
+        } else if (c < 0xfc) {
+            v = c & 0x03;
+            expect = 4;
+            vmin = 0x200000;
+        } else {
+            v = c & 0x01;
+            expect = 5;
+            vmin = 0x4000000;
+        }
+    }
+
+    return expect ? (size_t)-1 : outlen << 1;
+
+#undef EMIT
+}
+
+/*
+ * Convert a string in UTF-8 format to UTF-16BE
+ */
+static size_t utf8_to_16be(uint8_t *str, size_t len, char *op)
+{
+#define EMIT(x)                                 \
+    do {                                        \
+        uint16_t _y = (x);                      \
+        if (op) {                               \
+            WRITECHAR(op, _y >> 8);             \
+            WRITECHAR(op, _y);                  \
+        }                                       \
+        outlen++;                               \
+    } while (0)                                 \
+
+    size_t outlen = 0;
+    int expect = 0;
+    uint8_t c;
+    uint32_t v = 0, vmin = 0;
+
+    while (len--) {
+        c = *str++;
+
+        if (expect) {
+            if ((c & 0xc0) != 0x80) {
+                expect = 0;
+                return -1;
+            } else {
+                v = (v << 6) | (c & 0x3f);
+                if (!--expect) {
+                    if (v < vmin || v > 0x10ffff ||
+                        (v >= 0xd800 && v <= 0xdfff)) {
+                        return -1;
+                    } else if (v > 0xffff) {
+                        v -= 0x10000;
+                        EMIT(0xdc00 | (v & 0x3ff));
+                        EMIT(0xd800 | (v >> 10));
+                    } else {
+                        EMIT(v);
+                    }
+                }
+                continue;
+            }
+        }
+
+        if (c < 0x80) {
+            EMIT(c);
+        } else if (c < 0xc0 || c >= 0xfe) {
+            /* Invalid UTF-8 */
+            return -1;
+        } else if (c < 0xe0) {
+            v = c & 0x1f;
+            expect = 1;
+            vmin = 0x80;
+        } else if (c < 0xf0) {
+            v = c & 0x0f;
+            expect = 2;
+            vmin = 0x800;
+        } else if (c < 0xf8) {
+            v = c & 0x07;
+            expect = 3;
+            vmin = 0x10000;
+        } else if (c < 0xfc) {
+            v = c & 0x03;
+            expect = 4;
+            vmin = 0x200000;
+        } else {
+            v = c & 0x01;
+            expect = 5;
+            vmin = 0x4000000;
+        }
+    }
+
+    return expect ? (size_t)-1 : outlen << 1;
+
+#undef EMIT
+}
+
+/*
+ * Convert a string in UTF-8 format to UTF-32LE
+ */
+static size_t utf8_to_32le(uint8_t *str, size_t len, char *op)
+{
+#define EMIT(x) do { if (op) { WRITELONG(op,x); } outlen++; } while(0)
+
+    size_t outlen = 0;
+    int expect = 0;
+    uint8_t c;
+    uint32_t v = 0, vmin = 0;
+
+    while (len--) {
+        c = *str++;
+
+        if (expect) {
+            if ((c & 0xc0) != 0x80) {
+                return -1;
+            } else {
+                v = (v << 6) | (c & 0x3f);
+                if (!--expect) {
+                    if (v < vmin || (v >= 0xd800 && v <= 0xdfff)) {
+                        return -1;
+                    } else {
+                        EMIT(v);
+                    }
+                }
+                continue;
+            }
+        }
+
+        if (c < 0x80) {
+            EMIT(c);
+        } else if (c < 0xc0 || c >= 0xfe) {
+            /* Invalid UTF-8 */
+            return -1;
+        } else if (c < 0xe0) {
+            v = c & 0x1f;
+            expect = 1;
+            vmin = 0x80;
+        } else if (c < 0xf0) {
+            v = c & 0x0f;
+            expect = 2;
+            vmin = 0x800;
+        } else if (c < 0xf8) {
+            v = c & 0x07;
+            expect = 3;
+            vmin = 0x10000;
+        } else if (c < 0xfc) {
+            v = c & 0x03;
+            expect = 4;
+            vmin = 0x200000;
+        } else {
+            v = c & 0x01;
+            expect = 5;
+            vmin = 0x4000000;
+        }
+    }
+
+    return expect ? (size_t)-1 : outlen << 2;
+
+#undef EMIT
+}
+
+/*
+ * Convert a string in UTF-8 format to UTF-32BE
+ */
+static size_t utf8_to_32be(uint8_t *str, size_t len, char *op)
+{
+#define EMIT(x)                                         \
+    do {                                                \
+        uint32_t _y = (x);                              \
+        if (op) {                                       \
+            WRITECHAR(op,_y >> 24);                     \
+            WRITECHAR(op,_y >> 16);                     \
+            WRITECHAR(op,_y >> 8);                      \
+            WRITECHAR(op,_y);                           \
+        }                                               \
+        outlen++;                                       \
+    } while (0)
+
+    size_t outlen = 0;
+    int expect = 0;
+    uint8_t c;
+    uint32_t v = 0, vmin = 0;
+
+    while (len--) {
+        c = *str++;
+
+        if (expect) {
+            if ((c & 0xc0) != 0x80) {
+                return -1;
+            } else {
+                v = (v << 6) | (c & 0x3f);
+                if (!--expect) {
+                    if (v < vmin || (v >= 0xd800 && v <= 0xdfff)) {
+                        return -1;
+                    } else {
+                        EMIT(v);
+                    }
+                }
+                continue;
+            }
+        }
+
+        if (c < 0x80) {
+            EMIT(c);
+        } else if (c < 0xc0 || c >= 0xfe) {
+            /* Invalid UTF-8 */
+            return -1;
+        } else if (c < 0xe0) {
+            v = c & 0x1f;
+            expect = 1;
+            vmin = 0x80;
+        } else if (c < 0xf0) {
+            v = c & 0x0f;
+            expect = 2;
+            vmin = 0x800;
+        } else if (c < 0xf8) {
+            v = c & 0x07;
+            expect = 3;
+            vmin = 0x10000;
+        } else if (c < 0xfc) {
+            v = c & 0x03;
+            expect = 4;
+            vmin = 0x200000;
+        } else {
+            v = c & 0x01;
+            expect = 5;
+            vmin = 0x4000000;
+        }
+    }
+
+    return expect ? (size_t)-1 : outlen << 2;
+
+#undef EMIT
+}
+
+typedef size_t (*transform_func)(uint8_t *, size_t, char *);
+
+/*
+ * Apply a specific string transform and return it in a nasm_malloc'd
+ * buffer, returning the length.  On error, returns (size_t)-1 and no
+ * buffer is allocated.
+ */
+size_t string_transform(char *str, size_t len, char **out, enum strfunc func)
+{
+    /* This should match enum strfunc in nasm.h */
+    static const transform_func str_transforms[] = {
+        utf8_to_16le,
+        utf8_to_16le,
+        utf8_to_16be,
+        utf8_to_32le,
+        utf8_to_32le,
+        utf8_to_32be,
+    };
+    transform_func transform = str_transforms[func];
+    size_t outlen;
+    uint8_t *s = (uint8_t *)str;
+    char *buf;
+
+    outlen = transform(s, len, NULL);
+    if (outlen == (size_t)-1)
+        return -1;
+
+    *out = buf = nasm_malloc(outlen+1);
+    buf[outlen] = '\0'; /* Forcibly null-terminate the buffer */
+    return transform(s, len, buf);
+}
diff --git a/vere/ext/nasm/asm/tokens.dat b/vere/ext/nasm/asm/tokens.dat
new file mode 100644
index 0000000..fc155b0
--- /dev/null
+++ b/vere/ext/nasm/asm/tokens.dat
@@ -0,0 +1,215 @@
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2021 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+# The token parameters are in the other:
+# TOKEN_TYPE, t_inttwo, t_flags, t_integer
+#
+# * is replaced with the token name converted to upper case.
+# {xxx*yyy} is replaced with the token name stripped from the prefix
+# xxx and suffix yyy before converting to upper case.
+
+#
+# Tokens other than instructions and registers
+#
+
+# The ? operator is a keyword, because ? is a legitimate symbol character
+% TOKEN_QMARK, 0, 0, 0
+?
+
+% TOKEN_PREFIX, PPS_ASIZE, 0, P_*
+a16
+a32
+a64
+asp
+
+% TOKEN_PREFIX, PPS_LOCK, 0, P_*
+lock
+
+% TOKEN_PREFIX, PPS_OSIZE, 0, P_*
+o16
+o32
+o64
+osp
+
+% TOKEN_PREFIX, PPS_REP, 0, P_*
+rep
+repe
+repne
+repnz
+repz
+xacquire
+xrelease
+bnd
+nobnd
+
+% TOKEN_PREFIX, PPS_TIMES, 0, P_*
+times
+
+% TOKEN_PREFIX, PPS_WAIT, 0, P_*
+wait
+
+% TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_*
+rex
+evex
+vex
+vex3
+vex2
+
+% TOKEN_SIZE, SIZE_*, 0, S_*
+byte
+word
+dword
+qword
+tword
+oword
+yword
+zword
+
+% TOKEN_SPECIAL, 0, 0, S_*
+abs
+far
+long
+near
+nosplit
+rel
+short
+strict
+to
+
+# PTR is a legitimate symbol, but has an optional warning
+% TOKEN_ID, 0, TFLAG_WARN, 0
+ptr
+
+# DUP is a legitimate symbol, but also has context-specific use in extops
+% TOKEN_ID, 0, TFLAG_DUP, 0
+dup
+
+% TOKEN_FLOAT, 0, 0, 0
+__?infinity?__
+__?nan?__
+__?qnan?__
+__?snan?__
+
+% TOKEN_FLOATIZE, 0, 0, FLOAT_{__?float*?__}
+__?float8?__
+__?float16?__
+__?float32?__
+__?float64?__
+__?float80m?__
+__?float80e?__
+__?float128l?__
+__?float128h?__
+
+% TOKEN_FLOATIZE, 0, 0, FLOAT_B{__?bfloat*?__}
+__?bfloat16?__
+
+% TOKEN_STRFUNC, 0, 0, STRFUNC_{__?*?__}
+__?utf16?__
+__?utf16le?__
+__?utf16be?__
+__?utf32?__
+__?utf32le?__
+__?utf32be?__
+
+% TOKEN_IFUNC, 0, 0, IFUNC_{__?*?__}
+__?ilog2e?__
+__?ilog2w?__
+__?ilog2f?__
+__?ilog2c?__
+
+% TOKEN_*, 0, 0, 0
+seg
+wrt
+
+% TOKEN_{__?*?__}, 0, 0, 0
+__?masm_ptr?__
+__?masm_flat?__
+
+% TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO{1to*}
+1to2
+1to4
+1to8
+1to16
+1to32
+
+% TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_{*-sae}
+rn-sae
+rd-sae
+ru-sae
+rz-sae
+
+% TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_*
+sae
+z
+
+# Multi-character operators. Used in ppscan().
+% TOKEN_SHR, 0, 0, 0
+>>
+
+% TOKEN_SAR, 0, 0, 0
+>>>
+
+% TOKEN_SHL, 0, 0, 0
+<<
+<<<
+
+% TOKEN_SDIV, 0, 0, 0
+//
+
+% TOKEN_SMOD, 0, 0, 0
+%%
+
+% TOKEN_EQ, 0, 0, 0
+==
+
+% TOKEN_NE, 0, 0, 0
+!=
+<>
+
+% TOKEN_LE, 0, 0, 0
+<=
+
+% TOKEN_GE, 0, 0, 0
+>=
+
+% TOKEN_LEG, 0, 0, 0
+<=>
+
+% TOKEN_DBL_AND, 0, 0, 0
+&&
+
+% TOKEN_DBL_OR, 0, 0, 0
+||
+
+% TOKEN_DBL_XOR, 0, 0, 0
+^^
diff --git a/vere/ext/nasm/asm/tokens.h b/vere/ext/nasm/asm/tokens.h
new file mode 100644
index 0000000..b0e9887
--- /dev/null
+++ b/vere/ext/nasm/asm/tokens.h
@@ -0,0 +1,11 @@
+/*
+ * This file is generated from insns.dat, regs.dat and token.dat
+ * by tokhash.pl; do not edit.
+ */
+
+#ifndef NASM_TOKENS_H
+#define NASM_TOKENS_H
+
+#define MAX_KEYWORD 17 /* length of longest keyword */
+
+#endif /* NASM_TOKENS_H */
diff --git a/vere/ext/nasm/asm/tokhash.c b/vere/ext/nasm/asm/tokhash.c
new file mode 100644
index 0000000..f3fd779
--- /dev/null
+++ b/vere/ext/nasm/asm/tokhash.c
@@ -0,0 +1,19045 @@
+/*
+ * This file is generated from insns.dat, regs.dat and token.dat
+ * by tokhash.pl; do not edit.
+ */
+
+#include "compiler.h"
+#include "nasm.h"
+#include "hashtbl.h"
+#include "insns.h"
+#include "stdscan.h"
+
+struct tokendata {
+    const char *string;
+    uint16_t len;
+    int16_t tokentype;
+    int16_t aux;
+    uint16_t tokflag;
+    int32_t num;
+};
+
+int nasm_token_hash(const char *token, struct tokenval *tv)
+{
+#define INVALID_HASH_ENTRY (65535/3)
+    static const int16_t hashdata[16384] = {
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -1301,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        57,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1955,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1222,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        401,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        659,
+        0,
+        0,
+        1294,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        456,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1902,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1764,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        2154,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1218,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2105,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2345,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        226,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        247,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        824,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        643,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        1751,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1222,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        725,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        670,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        237,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2391,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1423,
+        2570,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        302,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1334,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1836,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        493,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        898,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        716,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        758,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2233,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1678,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        230,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        170,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1479,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1932,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2351,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2137,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1613,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1261,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1008,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        -184,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1076,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1434,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2040,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -521,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        291,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        318,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1625,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        729,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1162,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        476,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1793,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        395,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1995,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1518,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1304,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        750,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1547,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2563,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1051,
+        1602,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1435,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1882,
+        0,
+        1971,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1135,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1408,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1297,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        535,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        712,
+        0,
+        0,
+        536,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2328,
+        INVALID_HASH_ENTRY,
+        2490,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1465,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1742,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        487,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        915,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1293,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -55,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1901,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1986,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2240,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1541,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1596,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2262,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1422,
+        INVALID_HASH_ENTRY,
+        0,
+        2190,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1161,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1640,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        951,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2323,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1604,
+        INVALID_HASH_ENTRY,
+        -605,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        672,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2323,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        508,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2216,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        390,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2151,
+        INVALID_HASH_ENTRY,
+        1253,
+        0,
+        749,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2425,
+        0,
+        1195,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        467,
+        INVALID_HASH_ENTRY,
+        2558,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        822,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        945,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1029,
+        INVALID_HASH_ENTRY,
+        1171,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        869,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        2349,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        788,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        519,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2104,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1413,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        757,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1298,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1844,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1813,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -78,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        46,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2537,
+        INVALID_HASH_ENTRY,
+        0,
+        -733,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1951,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        663,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2100,
+        1291,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2506,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1805,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -30,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1972,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        192,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        580,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1217,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        873,
+        2569,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1023,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1239,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        1463,
+        1687,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2229,
+        INVALID_HASH_ENTRY,
+        0,
+        991,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1865,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2044,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        215,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        2025,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2205,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        -1183,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        928,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1126,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        365,
+        134,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        486,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2271,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -1881,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1736,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2184,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2562,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1175,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -152,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1669,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -45,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1146,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        187,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1137,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1389,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        6,
+        919,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        68,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1477,
+        INVALID_HASH_ENTRY,
+        1238,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1497,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        367,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        817,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1829,
+        1312,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        433,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        977,
+        1311,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        398,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1891,
+        0,
+        0,
+        1292,
+        0,
+        INVALID_HASH_ENTRY,
+        852,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2002,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1156,
+        1450,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        419,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1191,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2465,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1079,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2098,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        3089,
+        1409,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1637,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2310,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1102,
+        INVALID_HASH_ENTRY,
+        2160,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1871,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        488,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1576,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1617,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        267,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        613,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        427,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        685,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        121,
+        62,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2332,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        882,
+        539,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        36,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        728,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1105,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1228,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1769,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        888,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -837,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1716,
+        0,
+        INVALID_HASH_ENTRY,
+        1491,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        605,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2337,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        865,
+        1682,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1549,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        397,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        234,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        383,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        614,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1929,
+        0,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        818,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -637,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1300,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2498,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2419,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1432,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -1299,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1213,
+        504,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1641,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1587,
+        INVALID_HASH_ENTRY,
+        2567,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        223,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2056,
+        2129,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        935,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1271,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2371,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -522,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2404,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2305,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        653,
+        INVALID_HASH_ENTRY,
+        554,
+        INVALID_HASH_ENTRY,
+        902,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        606,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2298,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        239,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        315,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -184,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -2225,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1492,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1040,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1758,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1936,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1404,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1062,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1930,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1554,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1440,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2166,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2357,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2475,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2118,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1897,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1595,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        842,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2113,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        54,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        94,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        360,
+        INVALID_HASH_ENTRY,
+        2076,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1457,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        -330,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2299,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        305,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        300,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2092,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1385,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        627,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1263,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1541,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        483,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2334,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        414,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2123,
+        867,
+        1787,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1748,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        729,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        271,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1032,
+        -279,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2407,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1513,
+        0,
+        INVALID_HASH_ENTRY,
+        1726,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1470,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -865,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        225,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        755,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1126,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1123,
+        0,
+        55,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        976,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1274,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1316,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1006,
+        1941,
+        1287,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        442,
+        2239,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        174,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1992,
+        583,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1322,
+        1216,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        744,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        163,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2112,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        17,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1496,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -492,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        880,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1686,
+        1843,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        318,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1041,
+        1632,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        723,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2526,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -400,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2492,
+        INVALID_HASH_ENTRY,
+        2441,
+        1094,
+        INVALID_HASH_ENTRY,
+        -1676,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2134,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        867,
+        INVALID_HASH_ENTRY,
+        1260,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        654,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1768,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        766,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1780,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        814,
+        INVALID_HASH_ENTRY,
+        0,
+        114,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        680,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        791,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1730,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        758,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1241,
+        INVALID_HASH_ENTRY,
+        2462,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1880,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        3445,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1856,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1365,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        731,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2375,
+        0,
+        801,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        827,
+        INVALID_HASH_ENTRY,
+        1896,
+        INVALID_HASH_ENTRY,
+        993,
+        2358,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -80,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        386,
+        INVALID_HASH_ENTRY,
+        -492,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1144,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2438,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1013,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1566,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        12,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2128,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        555,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        387,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        60,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1534,
+        INVALID_HASH_ENTRY,
+        164,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1254,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        953,
+        1057,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -343,
+        INVALID_HASH_ENTRY,
+        1236,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        178,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1985,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2061,
+        INVALID_HASH_ENTRY,
+        2416,
+        INVALID_HASH_ENTRY,
+        1455,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        80,
+        918,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1605,
+        577,
+        346,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1199,
+        INVALID_HASH_ENTRY,
+        1315,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2496,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1474,
+        1030,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1288,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2033,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2247,
+        155,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1390,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        602,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1401,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1188,
+        INVALID_HASH_ENTRY,
+        1321,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2206,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1827,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2140,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1533,
+        2480,
+        1312,
+        2321,
+        71,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        816,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -53,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1944,
+        INVALID_HASH_ENTRY,
+        1128,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        678,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        13,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        781,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        739,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        100,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        967,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        444,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1621,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1209,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2013,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        160,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1401,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        685,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2198,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        624,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -968,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2908,
+        1755,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1066,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1860,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -525,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1685,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1362,
+        -1272,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2026,
+        INVALID_HASH_ENTRY,
+        1077,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        979,
+        2144,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1075,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -235,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -895,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        567,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        52,
+        INVALID_HASH_ENTRY,
+        925,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        821,
+        410,
+        0,
+        INVALID_HASH_ENTRY,
+        2483,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2159,
+        INVALID_HASH_ENTRY,
+        452,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2556,
+        INVALID_HASH_ENTRY,
+        2136,
+        -770,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1741,
+        INVALID_HASH_ENTRY,
+        2346,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        79,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2182,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2424,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -981,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        913,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1086,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2408,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        498,
+        INVALID_HASH_ENTRY,
+        969,
+        919,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2446,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        904,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1486,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1976,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -702,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        367,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        3630,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1969,
+        0,
+        INVALID_HASH_ENTRY,
+        1527,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        380,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1022,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1273,
+        2372,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        340,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1095,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2544,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        359,
+        INVALID_HASH_ENTRY,
+        1330,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1221,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1402,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1995,
+        204,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        328,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1063,
+        0,
+        INVALID_HASH_ENTRY,
+        1867,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -72,
+        454,
+        2313,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1223,
+        571,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        984,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -40,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1336,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        459,
+        765,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2542,
+        INVALID_HASH_ENTRY,
+        1578,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        641,
+        INVALID_HASH_ENTRY,
+        2503,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        372,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        976,
+        INVALID_HASH_ENTRY,
+        1115,
+        INVALID_HASH_ENTRY,
+        1055,
+        0,
+        INVALID_HASH_ENTRY,
+        1442,
+        2514,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        525,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        334,
+        1975,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        548,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        334,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1555,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        858,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1433,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1481,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2093,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1960,
+        2578,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        87,
+        1697,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        563,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        91,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2181,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        288,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -42,
+        INVALID_HASH_ENTRY,
+        1205,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        879,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1588,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        455,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        211,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1993,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        981,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1200,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1078,
+        INVALID_HASH_ENTRY,
+        2320,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        785,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        719,
+        779,
+        INVALID_HASH_ENTRY,
+        0,
+        754,
+        469,
+        529,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        856,
+        0,
+        INVALID_HASH_ENTRY,
+        1152,
+        INVALID_HASH_ENTRY,
+        0,
+        1270,
+        669,
+        943,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -2213,
+        709,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        608,
+        INVALID_HASH_ENTRY,
+        517,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2024,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2484,
+        293,
+        1333,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1692,
+        INVALID_HASH_ENTRY,
+        2461,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        462,
+        INVALID_HASH_ENTRY,
+        2557,
+        893,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        637,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        166,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        319,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1092,
+        INVALID_HASH_ENTRY,
+        454,
+        INVALID_HASH_ENTRY,
+        0,
+        1681,
+        INVALID_HASH_ENTRY,
+        181,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        2215,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2586,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1810,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1406,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        126,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        4,
+        INVALID_HASH_ENTRY,
+        1334,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1374,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1886,
+        INVALID_HASH_ENTRY,
+        0,
+        694,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2201,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        2530,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1912,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        769,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2518,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        940,
+        619,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        492,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        34,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1185,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1522,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1568,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2437,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        399,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1317,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -9,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1130,
+        0,
+        INVALID_HASH_ENTRY,
+        2507,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        829,
+        INVALID_HASH_ENTRY,
+        628,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        24,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1248,
+        INVALID_HASH_ENTRY,
+        2197,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        649,
+        0,
+        INVALID_HASH_ENTRY,
+        1520,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1614,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        372,
+        INVALID_HASH_ENTRY,
+        2187,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2331,
+        INVALID_HASH_ENTRY,
+        1180,
+        INVALID_HASH_ENTRY,
+        1246,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -315,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1067,
+        1168,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        557,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -496,
+        INVALID_HASH_ENTRY,
+        9,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        933,
+        2248,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -582,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1210,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -358,
+        INVALID_HASH_ENTRY,
+        -1539,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2458,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1177,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -312,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2352,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        21,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2445,
+        INVALID_HASH_ENTRY,
+        2251,
+        INVALID_HASH_ENTRY,
+        2539,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -123,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        999,
+        INVALID_HASH_ENTRY,
+        1078,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1575,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1237,
+        2581,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        647,
+        INVALID_HASH_ENTRY,
+        0,
+        1819,
+        140,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2552,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        449,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        872,
+        INVALID_HASH_ENTRY,
+        64,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -2092,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1002,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        692,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1390,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1998,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1866,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        238,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        158,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2243,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        37,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1584,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1080,
+        INVALID_HASH_ENTRY,
+        2085,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1872,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        42,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2155,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1686,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        777,
+        219,
+        893,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1733,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        1245,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        103,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        229,
+        2466,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2202,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        129,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1732,
+        0,
+        INVALID_HASH_ENTRY,
+        384,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        828,
+        INVALID_HASH_ENTRY,
+        -730,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1885,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1546,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1838,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1648,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        323,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        986,
+        INVALID_HASH_ENTRY,
+        2392,
+        959,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        576,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        847,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        779,
+        INVALID_HASH_ENTRY,
+        -985,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1231,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        88,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        870,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1318,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        125,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        308,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -906,
+        INVALID_HASH_ENTRY,
+        0,
+        1220,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2179,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        394,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        502,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1783,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        809,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        956,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        7,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2174,
+        INVALID_HASH_ENTRY,
+        77,
+        1553,
+        INVALID_HASH_ENTRY,
+        0,
+        1942,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        938,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1609,
+        2380,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1537,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2244,
+        245,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -5,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        417,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2257,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1796,
+        926,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1612,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        362,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        958,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        631,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        106,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2420,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -897,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2001,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        764,
+        1298,
+        2008,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        293,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -981,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2175,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        606,
+        INVALID_HASH_ENTRY,
+        353,
+        430,
+        0,
+        2371,
+        1994,
+        INVALID_HASH_ENTRY,
+        336,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        530,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -1600,
+        INVALID_HASH_ENTRY,
+        48,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        274,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1724,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2152,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        562,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        792,
+        -1007,
+        1503,
+        INVALID_HASH_ENTRY,
+        203,
+        1728,
+        INVALID_HASH_ENTRY,
+        1087,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        320,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        43,
+        INVALID_HASH_ENTRY,
+        294,
+        564,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        331,
+        -734,
+        INVALID_HASH_ENTRY,
+        1429,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        368,
+        INVALID_HASH_ENTRY,
+        1336,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        762,
+        1842,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        422,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        421,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        995,
+        INVALID_HASH_ENTRY,
+        335,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        27,
+        1214,
+        INVALID_HASH_ENTRY,
+        1946,
+        934,
+        INVALID_HASH_ENTRY,
+        766,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2114,
+        INVALID_HASH_ENTRY,
+        783,
+        0,
+        126,
+        674,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -465,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1749,
+        INVALID_HASH_ENTRY,
+        1928,
+        INVALID_HASH_ENTRY,
+        1569,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1114,
+        2521,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1438,
+        2336,
+        INVALID_HASH_ENTRY,
+        1511,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2385,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        280,
+        2050,
+        1607,
+        639,
+        INVALID_HASH_ENTRY,
+        697,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1752,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        840,
+        329,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1283,
+        874,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        666,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        1145,
+        INVALID_HASH_ENTRY,
+        748,
+        1622,
+        INVALID_HASH_ENTRY,
+        -880,
+        2053,
+        1025,
+        INVALID_HASH_ENTRY,
+        1160,
+        INVALID_HASH_ENTRY,
+        1073,
+        1344,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        852,
+        972,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        152,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1494,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        889,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        325,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2022,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        772,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1004,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2044,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1806,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        588,
+        -1630,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        399,
+        1855,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1377,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        793,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        47,
+        INVALID_HASH_ENTRY,
+        2405,
+        2397,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1542,
+        INVALID_HASH_ENTRY,
+        0,
+        1802,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1716,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2523,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1543,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1131,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        706,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1701,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        789,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        3614,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        222,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        356,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        441,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1068,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1201,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1927,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        484,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        97,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -847,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        924,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1767,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2508,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        281,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        574,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1098,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1284,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1005,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2574,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1151,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2146,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        675,
+        4413,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        186,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2294,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2356,
+        INVALID_HASH_ENTRY,
+        1652,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        216,
+        371,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1380,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        144,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        895,
+        INVALID_HASH_ENTRY,
+        668,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2543,
+        INVALID_HASH_ENTRY,
+        836,
+        INVALID_HASH_ENTRY,
+        943,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2088,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1467,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        980,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1387,
+        INVALID_HASH_ENTRY,
+        1540,
+        INVALID_HASH_ENTRY,
+        1412,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        369,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        306,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -211,
+        2302,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        439,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1737,
+        INVALID_HASH_ENTRY,
+        116,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2573,
+        1150,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -463,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        495,
+        INVALID_HASH_ENTRY,
+        431,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        937,
+        INVALID_HASH_ENTRY,
+        1832,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1661,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1702,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        481,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2130,
+        INVALID_HASH_ENTRY,
+        2326,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        203,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        929,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2347,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        594,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        410,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1794,
+        1136,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1276,
+        814,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        4911,
+        INVALID_HASH_ENTRY,
+        843,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2353,
+        0,
+        475,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2037,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2432,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1583,
+        INVALID_HASH_ENTRY,
+        0,
+        1057,
+        INVALID_HASH_ENTRY,
+        539,
+        INVALID_HASH_ENTRY,
+        545,
+        INVALID_HASH_ENTRY,
+        1164,
+        INVALID_HASH_ENTRY,
+        1137,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2393,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -733,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1033,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1378,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        843,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        412,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        429,
+        172,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1172,
+        2139,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1552,
+        INVALID_HASH_ENTRY,
+        1892,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        482,
+        INVALID_HASH_ENTRY,
+        1771,
+        INVALID_HASH_ENTRY,
+        2196,
+        INVALID_HASH_ENTRY,
+        -1353,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1143,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        514,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2319,
+        1890,
+        INVALID_HASH_ENTRY,
+        922,
+        INVALID_HASH_ENTRY,
+        0,
+        2190,
+        1140,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1419,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2176,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1369,
+        INVALID_HASH_ENTRY,
+        877,
+        757,
+        INVALID_HASH_ENTRY,
+        1155,
+        1154,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1336,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        960,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        987,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2982,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -247,
+        INVALID_HASH_ENTRY,
+        188,
+        INVALID_HASH_ENTRY,
+        0,
+        1536,
+        INVALID_HASH_ENTRY,
+        1574,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2291,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2456,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        66,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        633,
+        580,
+        2263,
+        167,
+        561,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1062,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1613,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1854,
+        329,
+        2238,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1909,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1660,
+        INVALID_HASH_ENTRY,
+        850,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1723,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1386,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        701,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -2350,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -979,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2157,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -116,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2222,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        93,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        635,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        491,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1212,
+        INVALID_HASH_ENTRY,
+        -1452,
+        2585,
+        1759,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1133,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -635,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2439,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1801,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1948,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1940,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2529,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        377,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2403,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        277,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2374,
+        409,
+        INVALID_HASH_ENTRY,
+        -1934,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        235,
+        2511,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        388,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1416,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -115,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2308,
+        162,
+        149,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        875,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2207,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        250,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1548,
+        2036,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2463,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        816,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1236,
+        INVALID_HASH_ENTRY,
+        238,
+        INVALID_HASH_ENTRY,
+        1,
+        1182,
+        INVALID_HASH_ENTRY,
+        2133,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1258,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1605,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1116,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1756,
+        1869,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1933,
+        578,
+        INVALID_HASH_ENTRY,
+        343,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2362,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        838,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        998,
+        INVALID_HASH_ENTRY,
+        0,
+        2246,
+        2431,
+        INVALID_HASH_ENTRY,
+        2183,
+        699,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        151,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1772,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        751,
+        -947,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1617,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2369,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        607,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        687,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        966,
+        0,
+        -475,
+        INVALID_HASH_ENTRY,
+        2417,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1257,
+        1729,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2152,
+        2142,
+        INVALID_HASH_ENTRY,
+        32,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1642,
+        INVALID_HASH_ENTRY,
+        2,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        286,
+        0,
+        INVALID_HASH_ENTRY,
+        1508,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2292,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1766,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1370,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        741,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        923,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1560,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        49,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        198,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2545,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1356,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        321,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2307,
+        0,
+        303,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2611,
+        INVALID_HASH_ENTRY,
+        537,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2367,
+        1517,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        169,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1346,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1739,
+        INVALID_HASH_ENTRY,
+        1350,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        902,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        352,
+        INVALID_HASH_ENTRY,
+        1509,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1176,
+        2451,
+        INVALID_HASH_ENTRY,
+        65,
+        INVALID_HASH_ENTRY,
+        155,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1272,
+        INVALID_HASH_ENTRY,
+        572,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        921,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1763,
+        106,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1946,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1785,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        702,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        290,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1279,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -158,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        497,
+        1689,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -2362,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        506,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        797,
+        INVALID_HASH_ENTRY,
+        376,
+        2415,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2343,
+        INVALID_HASH_ENTRY,
+        -1326,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        411,
+        1936,
+        -1845,
+        253,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        261,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2013,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1471,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        115,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        -352,
+        367,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1939,
+        INVALID_HASH_ENTRY,
+        2109,
+        855,
+        INVALID_HASH_ENTRY,
+        963,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1348,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2097,
+        1529,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1277,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        499,
+        0,
+        INVALID_HASH_ENTRY,
+        -1110,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1443,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2572,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1254,
+        1644,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        783,
+        INVALID_HASH_ENTRY,
+        -308,
+        INVALID_HASH_ENTRY,
+        -285,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2389,
+        INVALID_HASH_ENTRY,
+        1800,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1347,
+        2527,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        496,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2145,
+        971,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2536,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2260,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        626,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -438,
+        INVALID_HASH_ENTRY,
+        1476,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1217,
+        0,
+        740,
+        249,
+        883,
+        -816,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        205,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1207,
+        1275,
+        1699,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        562,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        462,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1313,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2494,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2269,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        711,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1612,
+        2411,
+        470,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2409,
+        INVALID_HASH_ENTRY,
+        283,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2330,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        581,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1485,
+        INVALID_HASH_ENTRY,
+        1840,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1895,
+        1465,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1874,
+        0,
+        1958,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        982,
+        446,
+        -382,
+        -1246,
+        2482,
+        690,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        950,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2310,
+        0,
+        1514,
+        INVALID_HASH_ENTRY,
+        515,
+        INVALID_HASH_ENTRY,
+        15,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        464,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        622,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        711,
+        INVALID_HASH_ENTRY,
+        620,
+        2477,
+        INVALID_HASH_ENTRY,
+        846,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        20,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        878,
+        -242,
+        2119,
+        1914,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        339,
+        INVALID_HASH_ENTRY,
+        0,
+        -954,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        693,
+        2027,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2211,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2256,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -813,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2064,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2082,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        105,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        667,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        241,
+        191,
+        INVALID_HASH_ENTRY,
+        0,
+        2227,
+        INVALID_HASH_ENTRY,
+        -2183,
+        INVALID_HASH_ENTRY,
+        1776,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -208,
+        1373,
+        INVALID_HASH_ENTRY,
+        1468,
+        1505,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1449,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2471,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        123,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1783,
+        INVALID_HASH_ENTRY,
+        154,
+        INVALID_HASH_ENTRY,
+        2000,
+        1653,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -809,
+        INVALID_HASH_ENTRY,
+        2312,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        656,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1711,
+        INVALID_HASH_ENTRY,
+        310,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        542,
+        INVALID_HASH_ENTRY,
+        522,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -835,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        1379,
+        INVALID_HASH_ENTRY,
+        1826,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2490,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -141,
+        INVALID_HASH_ENTRY,
+        1779,
+        INVALID_HASH_ENTRY,
+        29,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        391,
+        INVALID_HASH_ENTRY,
+        1467,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1601,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1186,
+        1700,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        806,
+        1343,
+        0,
+        INVALID_HASH_ENTRY,
+        1478,
+        INVALID_HASH_ENTRY,
+        1314,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1532,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1591,
+        0,
+        INVALID_HASH_ENTRY,
+        958,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1495,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        309,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1441,
+        INVALID_HASH_ENTRY,
+        1396,
+        INVALID_HASH_ENTRY,
+        1189,
+        1174,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        67,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -987,
+        -249,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2541,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1184,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -791,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1459,
+        566,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        996,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -140,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2048,
+        INVALID_HASH_ENTRY,
+        230,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2363,
+        INVALID_HASH_ENTRY,
+        0,
+        2285,
+        INVALID_HASH_ENTRY,
+        617,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1169,
+        -1244,
+        1570,
+        2590,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        177,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2176,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1265,
+        INVALID_HASH_ENTRY,
+        584,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2433,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1017,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1523,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1458,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2135,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1165,
+        1830,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1521,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        798,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        10,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1991,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        255,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1680,
+        -378,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2095,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        591,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1577,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        730,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        489,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1796,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2546,
+        854,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        650,
+        83,
+        1784,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -685,
+        1673,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2410,
+        INVALID_HASH_ENTRY,
+        906,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        541,
+        INVALID_HASH_ENTRY,
+        1335,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2016,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2141,
+        INVALID_HASH_ENTRY,
+        2214,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -241,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1493,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        596,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        150,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        99,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2041,
+        590,
+        INVALID_HASH_ENTRY,
+        949,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        639,
+        INVALID_HASH_ENTRY,
+        -820,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        509,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1107,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2177,
+        18,
+        INVALID_HASH_ENTRY,
+        892,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2518,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        281,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -825,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        72,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2381,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1166,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        165,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1847,
+        413,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        177,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1490,
+        -138,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        920,
+        1398,
+        2485,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1161,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2587,
+        1997,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        886,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2476,
+        1500,
+        INVALID_HASH_ENTRY,
+        1259,
+        665,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1366,
+        2497,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        358,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        660,
+        423,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        131,
+        2020,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1659,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2459,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1459,
+        -1439,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        110,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1271,
+        217,
+        INVALID_HASH_ENTRY,
+        1808,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1964,
+        2186,
+        894,
+        INVALID_HASH_ENTRY,
+        -1043,
+        1507,
+        791,
+        INVALID_HASH_ENTRY,
+        192,
+        INVALID_HASH_ENTRY,
+        1230,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1391,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        589,
+        599,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        866,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -183,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1910,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        341,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1544,
+        INVALID_HASH_ENTRY,
+        2793,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        587,
+        INVALID_HASH_ENTRY,
+        1488,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        796,
+        2339,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1338,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1516,
+        1563,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        874,
+        INVALID_HASH_ENTRY,
+        826,
+        INVALID_HASH_ENTRY,
+        985,
+        -1247,
+        INVALID_HASH_ENTRY,
+        2121,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        394,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1888,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1935,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        33,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        901,
+        INVALID_HASH_ENTRY,
+        1009,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        710,
+        INVALID_HASH_ENTRY,
+        2060,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1243,
+        INVALID_HASH_ENTRY,
+        -97,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1441,
+        INVALID_HASH_ENTRY,
+        522,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2528,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2548,
+        2249,
+        INVALID_HASH_ENTRY,
+        26,
+        INVALID_HASH_ENTRY,
+        236,
+        INVALID_HASH_ENTRY,
+        392,
+        INVALID_HASH_ENTRY,
+        2242,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        653,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -700,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        185,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        147,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1228,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -996,
+        21,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        90,
+        INVALID_HASH_ENTRY,
+        794,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1934,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -156,
+        2500,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        208,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        983,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2057,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2054,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1987,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        700,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1720,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2234,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1137,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2090,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        978,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1121,
+        1633,
+        2531,
+        1201,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1012,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1495,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        864,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2268,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        567,
+        INVALID_HASH_ENTRY,
+        2457,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        592,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        472,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2218,
+        330,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        349,
+        2444,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1503,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2555,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        87,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1774,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        128,
+        0,
+        INVALID_HASH_ENTRY,
+        2253,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1212,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -465,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1440,
+        932,
+        INVALID_HASH_ENTRY,
+        618,
+        INVALID_HASH_ENTRY,
+        1473,
+        8,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -163,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        533,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2450,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1337,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1851,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        194,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -701,
+        2264,
+        111,
+        1641,
+        0,
+        761,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2513,
+        -371,
+        INVALID_HASH_ENTRY,
+        1559,
+        INVALID_HASH_ENTRY,
+        1897,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        733,
+        1111,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2366,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1472,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2004,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        480,
+        INVALID_HASH_ENTRY,
+        2301,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1597,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1244,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1839,
+        332,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2203,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        477,
+        INVALID_HASH_ENTRY,
+        2467,
+        2427,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        278,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        375,
+        INVALID_HASH_ENTRY,
+        40,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1365,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1984,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        661,
+        132,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        890,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        837,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2414,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        255,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        260,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1347,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1550,
+        1861,
+        448,
+        848,
+        INVALID_HASH_ENTRY,
+        364,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2279,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2035,
+        2065,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        30,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1977,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        98,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        742,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        109,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2034,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1141,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        735,
+        876,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1740,
+        168,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        638,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1615,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1492,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1340,
+        910,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        691,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1139,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        811,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1682,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1690,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        214,
+        INVALID_HASH_ENTRY,
+        956,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2421,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1163,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        756,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        970,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1054,
+        INVALID_HASH_ENTRY,
+        646,
+        1818,
+        1016,
+        160,
+        -859,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        354,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        941,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        432,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        644,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        99,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        342,
+        INVALID_HASH_ENTRY,
+        -317,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        625,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1845,
+        INVALID_HASH_ENTRY,
+        45,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1198,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1592,
+        INVALID_HASH_ENTRY,
+        689,
+        1058,
+        0,
+        2568,
+        896,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        346,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1853,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1385,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2056,
+        119,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        273,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1203,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1591,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1453,
+        1792,
+        1005,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        458,
+        INVALID_HASH_ENTRY,
+        676,
+        INVALID_HASH_ENTRY,
+        -883,
+        INVALID_HASH_ENTRY,
+        2509,
+        1831,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1909,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1858,
+        INVALID_HASH_ENTRY,
+        1068,
+        INVALID_HASH_ENTRY,
+        0,
+        1937,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1232,
+        INVALID_HASH_ENTRY,
+        703,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -288,
+        INVALID_HASH_ENTRY,
+        2277,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2015,
+        INVALID_HASH_ENTRY,
+        707,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1196,
+        1502,
+        1000,
+        INVALID_HASH_ENTRY,
+        2210,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1990,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        173,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2333,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2161,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        292,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        297,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1101,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        942,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        777,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1803,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1694,
+        585,
+        118,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1162,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1290,
+        55,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        870,
+        INVALID_HASH_ENTRY,
+        1049,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        752,
+        1224,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2315,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1684,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1564,
+        1709,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        86,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        28,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        597,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2117,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -2400,
+        INVALID_HASH_ENTRY,
+        2280,
+        -471,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2283,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2051,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2360,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        107,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -7,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1469,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1811,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1722,
+        INVALID_HASH_ENTRY,
+        1353,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        82,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2348,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1938,
+        1286,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1664,
+        INVALID_HASH_ENTRY,
+        -294,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1645,
+        INVALID_HASH_ENTRY,
+        2235,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2258,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1044,
+        1159,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2178,
+        0,
+        2281,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        299,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2000,
+        279,
+        INVALID_HASH_ENTRY,
+        2158,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1678,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2300,
+        0,
+        -1065,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1417,
+        2266,
+        INVALID_HASH_ENTRY,
+        1398,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1256,
+        INVALID_HASH_ENTRY,
+        2324,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1367,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        737,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        863,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        50,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1325,
+        720,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1132,
+        INVALID_HASH_ENTRY,
+        1900,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        861,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2335,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1142,
+        INVALID_HASH_ENTRY,
+        453,
+        INVALID_HASH_ENTRY,
+        957,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        60,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        416,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2398,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1841,
+        INVALID_HASH_ENTRY,
+        1567,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2468,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1289,
+        193,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2344,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1979,
+        0,
+        2048,
+        705,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        916,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -464,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1662,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2579,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        282,
+        INVALID_HASH_ENTRY,
+        1918,
+        INVALID_HASH_ENTRY,
+        242,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1683,
+        INVALID_HASH_ENTRY,
+        1506,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1970,
+        INVALID_HASH_ENTRY,
+        2036,
+        INVALID_HASH_ENTRY,
+        1920,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1127,
+        INVALID_HASH_ENTRY,
+        0,
+        -1669,
+        INVALID_HASH_ENTRY,
+        1040,
+        558,
+        INVALID_HASH_ENTRY,
+        1355,
+        INVALID_HASH_ENTRY,
+        2426,
+        2489,
+        2012,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        312,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2120,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        959,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2478,
+        2390,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        152,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1143,
+        296,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1082,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        156,
+        0,
+        INVALID_HASH_ENTRY,
+        -1976,
+        INVALID_HASH_ENTRY,
+        2208,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1028,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2066,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2232,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2224,
+        476,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        0,
+        726,
+        988,
+        INVALID_HASH_ENTRY,
+        -806,
+        INVALID_HASH_ENTRY,
+        1197,
+        0,
+        INVALID_HASH_ENTRY,
+        2350,
+        2576,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1524,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        542,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        714,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        206,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1278,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1835,
+        -393,
+        -261,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        717,
+        INVALID_HASH_ENTRY,
+        2180,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        748,
+        1323,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2318,
+        1823,
+        INVALID_HASH_ENTRY,
+        1445,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1833,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        207,
+        INVALID_HASH_ENTRY,
+        907,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1899,
+        63,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        461,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1105,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1738,
+        -323,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        445,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1048,
+        INVALID_HASH_ENTRY,
+        486,
+        INVALID_HASH_ENTRY,
+        -318,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2149,
+        INVALID_HASH_ENTRY,
+        1281,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        166,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2395,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2473,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        587,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        311,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        338,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        157,
+        1817,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2553,
+        1837,
+        435,
+        1354,
+        1071,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1586,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1138,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        389,
+        75,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1937,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1026,
+        INVALID_HASH_ENTRY,
+        1671,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        396,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1754,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        831,
+        1857,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        973,
+        INVALID_HASH_ENTRY,
+        2359,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1967,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1795,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1638,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1968,
+        -985,
+        2571,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1096,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1922,
+        1014,
+        INVALID_HASH_ENTRY,
+        159,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2106,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1153,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1916,
+        1489,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        127,
+        2452,
+        INVALID_HASH_ENTRY,
+        1090,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        677,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1674,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2436,
+        58,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1345,
+        1295,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2138,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2039,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1814,
+        1361,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1770,
+        INVALID_HASH_ENTRY,
+        -1169,
+        778,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1670,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        575,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1889,
+        1718,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        359,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1158,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        183,
+        2501,
+        1965,
+        INVALID_HASH_ENTRY,
+        1059,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2204,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        299,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        767,
+        2259,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        884,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1932,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1267,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1816,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        121,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1735,
+        0,
+        INVALID_HASH_ENTRY,
+        1573,
+        INVALID_HASH_ENTRY,
+        366,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1590,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1797,
+        INVALID_HASH_ENTRY,
+        113,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1304,
+        2110,
+        2373,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2524,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -53,
+        -1231,
+        INVALID_HASH_ENTRY,
+        651,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        572,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2156,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        134,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2428,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        944,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        688,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2101,
+        1211,
+        INVALID_HASH_ENTRY,
+        1062,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        937,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1407,
+        2413,
+        1925,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2029,
+        INVALID_HASH_ENTRY,
+        2515,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1424,
+        INVALID_HASH_ENTRY,
+        487,
+        1192,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        153,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1371,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1047,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1415,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        773,
+        INVALID_HASH_ENTRY,
+        1656,
+        INVALID_HASH_ENTRY,
+        0,
+        287,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        337,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -705,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        808,
+        1505,
+        INVALID_HASH_ENTRY,
+        2241,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        233,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        5,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2049,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        0,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -56,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        745,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2050,
+        676,
+        INVALID_HASH_ENTRY,
+        2289,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1104,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1436,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        243,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        812,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2365,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        124,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1676,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1309,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1427,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        96,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        871,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1703,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1753,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1439,
+        2172,
+        2237,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        802,
+        INVALID_HASH_ENTRY,
+        1430,
+        INVALID_HASH_ENTRY,
+        382,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2200,
+        1110,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        673,
+        INVALID_HASH_ENTRY,
+        2261,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1089,
+        INVALID_HASH_ENTRY,
+        994,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1099,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1868,
+        1634,
+        930,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1084,
+        INVALID_HASH_ENTRY,
+        413,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1561,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1606,
+        1907,
+        INVALID_HASH_ENTRY,
+        0,
+        474,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2221,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        600,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        2071,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2317,
+        INVALID_HASH_ENTRY,
+        1421,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1565,
+        1119,
+        INVALID_HASH_ENTRY,
+        1234,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        3355,
+        1097,
+        1711,
+        INVALID_HASH_ENTRY,
+        131,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        655,
+        INVALID_HASH_ENTRY,
+        74,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        968,
+        2424,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        275,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2322,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1643,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1359,
+        INVALID_HASH_ENTRY,
+        295,
+        1400,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2284,
+        INVALID_HASH_ENTRY,
+        1091,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2188,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        629,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1346,
+        1815,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2517,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1983,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        3,
+        INVALID_HASH_ENTRY,
+        1053,
+        2342,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        624,
+        1981,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        611,
+        -213,
+        INVALID_HASH_ENTRY,
+        1036,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1630,
+        619,
+        1594,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        642,
+        INVALID_HASH_ENTRY,
+        698,
+        0,
+        -156,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        379,
+        2270,
+        INVALID_HASH_ENTRY,
+        810,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1202,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1788,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1904,
+        569,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        381,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1762,
+        INVALID_HASH_ENTRY,
+        -1478,
+        INVALID_HASH_ENTRY,
+        815,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2533,
+        715,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2031,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2193,
+        1188,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1820,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2087,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1996,
+        1042,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1219,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1039,
+        4,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1487,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        485,
+        -1382,
+        INVALID_HASH_ENTRY,
+        1952,
+        201,
+        298,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2532,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1037,
+        1665,
+        INVALID_HASH_ENTRY,
+        2561,
+        406,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1873,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        917,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        463,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1381,
+        713,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1225,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        304,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        96,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2028,
+        INVALID_HASH_ENTRY,
+        122,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        161,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2047,
+        1705,
+        INVALID_HASH_ENTRY,
+        1373,
+        1672,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        990,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        800,
+        2120,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        865,
+        2018,
+        INVALID_HASH_ENTRY,
+        2170,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2388,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1572,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2401,
+        2274,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1260,
+        INVALID_HASH_ENTRY,
+        634,
+        92,
+        1824,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1425,
+        -391,
+        -287,
+        1034,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        955,
+        1414,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2418,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1056,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1319,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        664,
+        INVALID_HASH_ENTRY,
+        610,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1713,
+        INVALID_HASH_ENTRY,
+        256,
+        814,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -372,
+        465,
+        1324,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        617,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        662,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2435,
+        INVALID_HASH_ENTRY,
+        1877,
+        1227,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        526,
+        887,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1319,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1898,
+        200,
+        1384,
+        1999,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2164,
+        1179,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        975,
+        INVALID_HASH_ENTRY,
+        2085,
+        2449,
+        INVALID_HASH_ENTRY,
+        1073,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        410,
+        -400,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1210,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1282,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        193,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        505,
+        INVALID_HASH_ENTRY,
+        117,
+        1879,
+        457,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        820,
+        INVALID_HASH_ENTRY,
+        0,
+        727,
+        0,
+        INVALID_HASH_ENTRY,
+        2797,
+        -14,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2499,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        859,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1848,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1060,
+        INVALID_HASH_ENTRY,
+        0,
+        1129,
+        INVALID_HASH_ENTRY,
+        1070,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2074,
+        1875,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1876,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1247,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        11,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -497,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1765,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        403,
+        INVALID_HASH_ENTRY,
+        1027,
+        171,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1170,
+        2273,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1308,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1688,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2566,
+        INVALID_HASH_ENTRY,
+        1178,
+        INVALID_HASH_ENTRY,
+        330,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2683,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2540,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1639,
+        38,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        199,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        408,
+        832,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        145,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        376,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1747,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1974,
+        1064,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2115,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        494,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -471,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        1668,
+        1993,
+        1631,
+        INVALID_HASH_ENTRY,
+        1663,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1655,
+        1619,
+        INVALID_HASH_ENTRY,
+        104,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        759,
+        232,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        738,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2072,
+        2275,
+        1358,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2077,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1157,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1917,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2169,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        156,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1124,
+        INVALID_HASH_ENTRY,
+        543,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        686,
+        INVALID_HASH_ENTRY,
+        1356,
+        658,
+        -671,
+        2266,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2454,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        807,
+        369,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2589,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2329,
+        1778,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        154,
+        682,
+        385,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2481,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2293,
+        220,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        400,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2126,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2525,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        263,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        478,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1989,
+        167,
+        1721,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1924,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        853,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        961,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -369,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        81,
+        327,
+        490,
+        2191,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        804,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2070,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2493,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -754,
+        INVALID_HASH_ENTRY,
+        1093,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        511,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1166,
+        INVALID_HASH_ENTRY,
+        -1464,
+        213,
+        908,
+        2217,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1046,
+        2042,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1732,
+        INVALID_HASH_ENTRY,
+        1649,
+        1949,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        228,
+        INVALID_HASH_ENTRY,
+        254,
+        INVALID_HASH_ENTRY,
+        1519,
+        INVALID_HASH_ENTRY,
+        306,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -371,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1173,
+        0,
+        1307,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2212,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1243,
+        INVALID_HASH_ENTRY,
+        1285,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2580,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1475,
+        1568,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1375,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1045,
+        393,
+        148,
+        INVALID_HASH_ENTRY,
+        3871,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        556,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1714,
+        INVALID_HASH_ENTRY,
+        1825,
+        152,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        601,
+        INVALID_HASH_ENTRY,
+        576,
+        -12,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1859,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        851,
+        INVALID_HASH_ENTRY,
+        -371,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        909,
+        INVALID_HASH_ENTRY,
+        734,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        435,
+        INVALID_HASH_ENTRY,
+        1378,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2588,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1368,
+        INVALID_HASH_ENTRY,
+        690,
+        1122,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        841,
+        1564,
+        268,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        41,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        332,
+        INVALID_HASH_ENTRY,
+        -866,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1326,
+        INVALID_HASH_ENTRY,
+        276,
+        INVALID_HASH_ENTRY,
+        1410,
+        1021,
+        INVALID_HASH_ENTRY,
+        2472,
+        INVALID_HASH_ENTRY,
+        1980,
+        2382,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1928,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        770,
+        496,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        1003,
+        2394,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        2098,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1910,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2577,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1894,
+        0,
+        -40,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1445,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2228,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1202,
+        INVALID_HASH_ENTRY,
+        1242,
+        -689,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        550,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -448,
+        2470,
+        1088,
+        819,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        671,
+        INVALID_HASH_ENTRY,
+        -1440,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1154,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2386,
+        2469,
+        40,
+        INVALID_HASH_ENTRY,
+        1988,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2316,
+        1953,
+        INVALID_HASH_ENTRY,
+        208,
+        2150,
+        954,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        899,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2290,
+        1010,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1007,
+        -252,
+        509,
+        1102,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2399,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1782,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2584,
+        INVALID_HASH_ENTRY,
+        1693,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2185,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1065,
+        1725,
+        424,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1093,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2002,
+        2430,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        59,
+        423,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2023,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1654,
+        INVALID_HASH_ENTRY,
+        133,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1710,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        196,
+        1357,
+        507,
+        INVALID_HASH_ENTRY,
+        2510,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2080,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2547,
+        712,
+        2094,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1300,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        -1047,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2348,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        153,
+        270,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        534,
+        440,
+        INVALID_HASH_ENTRY,
+        2052,
+        76,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        102,
+        2102,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2069,
+        INVALID_HASH_ENTRY,
+        1903,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1327,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1807,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        790,
+        1043,
+        INVALID_HASH_ENTRY,
+        603,
+        2021,
+        INVALID_HASH_ENTRY,
+        2516,
+        1687,
+        2412,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -187,
+        INVALID_HASH_ENTRY,
+        1342,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1647,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2340,
+        1552,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1651,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        225,
+        INVALID_HASH_ENTRY,
+        425,
+        INVALID_HASH_ENTRY,
+        248,
+        1760,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2429,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2148,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        760,
+        INVALID_HASH_ENTRY,
+        355,
+        1393,
+        1905,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        224,
+        -191,
+        INVALID_HASH_ENTRY,
+        2303,
+        2019,
+        492,
+        221,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        512,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2011,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1706,
+        2378,
+        1374,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        671,
+        INVALID_HASH_ENTRY,
+        -1651,
+        INVALID_HASH_ENTRY,
+        1418,
+        INVALID_HASH_ENTRY,
+        1011,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        911,
+        1887,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1041,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1240,
+        1962,
+        885,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2502,
+        INVALID_HASH_ENTRY,
+        2447,
+        1978,
+        1305,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        139,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1480,
+        947,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1035,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        47,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2448,
+        INVALID_HASH_ENTRY,
+        2442,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        977,
+        -678,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1302,
+        INVALID_HASH_ENTRY,
+        1678,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1320,
+        578,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        683,
+        1943,
+        1864,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        437,
+        INVALID_HASH_ENTRY,
+        1001,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        456,
+        INVALID_HASH_ENTRY,
+        -1935,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        974,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        891,
+        INVALID_HASH_ENTRY,
+        2185,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1624,
+        INVALID_HASH_ENTRY,
+        1956,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        540,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -617,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2560,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1399,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        450,
+        44,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1083,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        106,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1074,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -387,
+        INVALID_HASH_ENTRY,
+        1264,
+        2119,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -378,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2106,
+        2295,
+        INVALID_HASH_ENTRY,
+        1963,
+        INVALID_HASH_ENTRY,
+        2479,
+        INVALID_HASH_ENTRY,
+        -42,
+        1351,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2453,
+        1090,
+        INVALID_HASH_ENTRY,
+        1420,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        344,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        672,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2554,
+        1744,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        736,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -223,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1148,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        210,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        615,
+        1973,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        15,
+        609,
+        61,
+        120,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1160,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1117,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1360,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        143,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        593,
+        1717,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2081,
+        1113,
+        195,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1557,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        447,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1620,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1208,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        136,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -91,
+        1579,
+        1746,
+        1251,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1950,
+        2143,
+        0,
+        264,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2068,
+        1125,
+        INVALID_HASH_ENTRY,
+        -263,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        500,
+        -95,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2550,
+        INVALID_HASH_ENTRY,
+        2440,
+        1451,
+        2384,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1393,
+        1883,
+        INVALID_HASH_ENTRY,
+        345,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1167,
+        INVALID_HASH_ENTRY,
+        527,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2086,
+        1419,
+        2058,
+        965,
+        695,
+        INVALID_HASH_ENTRY,
+        1558,
+        834,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        326,
+        2059,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        407,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1262,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        931,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        345,
+        INVALID_HASH_ENTRY,
+        1241,
+        560,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        347,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        95,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        547,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1399,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        993,
+        INVALID_HASH_ENTRY,
+        1482,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        983,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1926,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2488,
+        -959,
+        348,
+        INVALID_HASH_ENTRY,
+        1731,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        716,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        328,
+        1301,
+        16,
+        1679,
+        INVALID_HASH_ENTRY,
+        551,
+        2017,
+        INVALID_HASH_ENTRY,
+        1372,
+        -716,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1046,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        604,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2443,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        998,
+        351,
+        2265,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        552,
+        INVALID_HASH_ENTRY,
+        1460,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1304,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        636,
+        INVALID_HASH_ENTRY,
+        1667,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1194,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        468,
+        285,
+        INVALID_HASH_ENTRY,
+        616,
+        INVALID_HASH_ENTRY,
+        2099,
+        INVALID_HASH_ENTRY,
+        1200,
+        INVALID_HASH_ENTRY,
+        0,
+        140,
+        1215,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        503,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        -1567,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        148,
+        INVALID_HASH_ENTRY,
+        721,
+        784,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1983,
+        1103,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1650,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        598,
+        INVALID_HASH_ENTRY,
+        269,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1906,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2219,
+        INVALID_HASH_ENTRY,
+        212,
+        210,
+        1310,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1426,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1187,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2073,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        267,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2592,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1915,
+        70,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1921,
+        INVALID_HASH_ENTRY,
+        434,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        544,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1675,
+        2559,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2220,
+        -555,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2455,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1691,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2116,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1618,
+        1362,
+        903,
+        INVALID_HASH_ENTRY,
+        2003,
+        INVALID_HASH_ENTRY,
+        271,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1252,
+        117,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1635,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1916,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        258,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        108,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1551,
+        1020,
+        1896,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1628,
+        INVALID_HASH_ENTRY,
+        1204,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1945,
+        INVALID_HASH_ENTRY,
+        2195,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        591,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1852,
+        190,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        479,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        78,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        48,
+        378,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        85,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1453,
+        970,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        39,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2226,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2189,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1881,
+        INVALID_HASH_ENTRY,
+        1397,
+        INVALID_HASH_ENTRY,
+        182,
+        -171,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2464,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        169,
+        INVALID_HASH_ENTRY,
+        1303,
+        1585,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1181,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2125,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2147,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        31,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        1893,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+    };
+    static const struct tokendata tokendata[2594] = {
+        { "db", 2, TOKEN_INSN, 0, 0, I_DB },
+        { "dw", 2, TOKEN_INSN, 0, 0, I_DW },
+        { "dd", 2, TOKEN_INSN, 0, 0, I_DD },
+        { "dq", 2, TOKEN_INSN, 0, 0, I_DQ },
+        { "dt", 2, TOKEN_INSN, 0, 0, I_DT },
+        { "do", 2, TOKEN_INSN, 0, 0, I_DO },
+        { "dy", 2, TOKEN_INSN, 0, 0, I_DY },
+        { "dz", 2, TOKEN_INSN, 0, 0, I_DZ },
+        { "resb", 4, TOKEN_INSN, 0, 0, I_RESB },
+        { "resw", 4, TOKEN_INSN, 0, 0, I_RESW },
+        { "resd", 4, TOKEN_INSN, 0, 0, I_RESD },
+        { "resq", 4, TOKEN_INSN, 0, 0, I_RESQ },
+        { "rest", 4, TOKEN_INSN, 0, 0, I_REST },
+        { "reso", 4, TOKEN_INSN, 0, 0, I_RESO },
+        { "resy", 4, TOKEN_INSN, 0, 0, I_RESY },
+        { "resz", 4, TOKEN_INSN, 0, 0, I_RESZ },
+        { "incbin", 6, TOKEN_INSN, 0, 0, I_INCBIN },
+        { "aaa", 3, TOKEN_INSN, 0, 0, I_AAA },
+        { "aad", 3, TOKEN_INSN, 0, 0, I_AAD },
+        { "aam", 3, TOKEN_INSN, 0, 0, I_AAM },
+        { "aas", 3, TOKEN_INSN, 0, 0, I_AAS },
+        { "adc", 3, TOKEN_INSN, 0, 0, I_ADC },
+        { "add", 3, TOKEN_INSN, 0, 0, I_ADD },
+        { "and", 3, TOKEN_INSN, 0, 0, I_AND },
+        { "arpl", 4, TOKEN_INSN, 0, 0, I_ARPL },
+        { "bb0_reset", 9, TOKEN_INSN, 0, 0, I_BB0_RESET },
+        { "bb1_reset", 9, TOKEN_INSN, 0, 0, I_BB1_RESET },
+        { "bound", 5, TOKEN_INSN, 0, 0, I_BOUND },
+        { "bsf", 3, TOKEN_INSN, 0, 0, I_BSF },
+        { "bsr", 3, TOKEN_INSN, 0, 0, I_BSR },
+        { "bswap", 5, TOKEN_INSN, 0, 0, I_BSWAP },
+        { "bt", 2, TOKEN_INSN, 0, 0, I_BT },
+        { "btc", 3, TOKEN_INSN, 0, 0, I_BTC },
+        { "btr", 3, TOKEN_INSN, 0, 0, I_BTR },
+        { "bts", 3, TOKEN_INSN, 0, 0, I_BTS },
+        { "call", 4, TOKEN_INSN, 0, 0, I_CALL },
+        { "cbw", 3, TOKEN_INSN, 0, 0, I_CBW },
+        { "cdq", 3, TOKEN_INSN, 0, 0, I_CDQ },
+        { "cdqe", 4, TOKEN_INSN, 0, 0, I_CDQE },
+        { "clc", 3, TOKEN_INSN, 0, 0, I_CLC },
+        { "cld", 3, TOKEN_INSN, 0, 0, I_CLD },
+        { "cli", 3, TOKEN_INSN, 0, 0, I_CLI },
+        { "clts", 4, TOKEN_INSN, 0, 0, I_CLTS },
+        { "cmc", 3, TOKEN_INSN, 0, 0, I_CMC },
+        { "cmp", 3, TOKEN_INSN, 0, 0, I_CMP },
+        { "cmpsb", 5, TOKEN_INSN, 0, 0, I_CMPSB },
+        { "cmpsd", 5, TOKEN_INSN, 0, 0, I_CMPSD },
+        { "cmpsq", 5, TOKEN_INSN, 0, 0, I_CMPSQ },
+        { "cmpsw", 5, TOKEN_INSN, 0, 0, I_CMPSW },
+        { "cmpxchg", 7, TOKEN_INSN, 0, 0, I_CMPXCHG },
+        { "cmpxchg486", 10, TOKEN_INSN, 0, 0, I_CMPXCHG486 },
+        { "cmpxchg8b", 9, TOKEN_INSN, 0, 0, I_CMPXCHG8B },
+        { "cmpxchg16b", 10, TOKEN_INSN, 0, 0, I_CMPXCHG16B },
+        { "cpuid", 5, TOKEN_INSN, 0, 0, I_CPUID },
+        { "cpu_read", 8, TOKEN_INSN, 0, 0, I_CPU_READ },
+        { "cpu_write", 9, TOKEN_INSN, 0, 0, I_CPU_WRITE },
+        { "cqo", 3, TOKEN_INSN, 0, 0, I_CQO },
+        { "cwd", 3, TOKEN_INSN, 0, 0, I_CWD },
+        { "cwde", 4, TOKEN_INSN, 0, 0, I_CWDE },
+        { "daa", 3, TOKEN_INSN, 0, 0, I_DAA },
+        { "das", 3, TOKEN_INSN, 0, 0, I_DAS },
+        { "dec", 3, TOKEN_INSN, 0, 0, I_DEC },
+        { "div", 3, TOKEN_INSN, 0, 0, I_DIV },
+        { "dmint", 5, TOKEN_INSN, 0, 0, I_DMINT },
+        { "emms", 4, TOKEN_INSN, 0, 0, I_EMMS },
+        { "enter", 5, TOKEN_INSN, 0, 0, I_ENTER },
+        { "equ", 3, TOKEN_INSN, 0, 0, I_EQU },
+        { "f2xm1", 5, TOKEN_INSN, 0, 0, I_F2XM1 },
+        { "fabs", 4, TOKEN_INSN, 0, 0, I_FABS },
+        { "fadd", 4, TOKEN_INSN, 0, 0, I_FADD },
+        { "faddp", 5, TOKEN_INSN, 0, 0, I_FADDP },
+        { "fbld", 4, TOKEN_INSN, 0, 0, I_FBLD },
+        { "fbstp", 5, TOKEN_INSN, 0, 0, I_FBSTP },
+        { "fchs", 4, TOKEN_INSN, 0, 0, I_FCHS },
+        { "fclex", 5, TOKEN_INSN, 0, 0, I_FCLEX },
+        { "fcmovb", 6, TOKEN_INSN, 0, 0, I_FCMOVB },
+        { "fcmovbe", 7, TOKEN_INSN, 0, 0, I_FCMOVBE },
+        { "fcmove", 6, TOKEN_INSN, 0, 0, I_FCMOVE },
+        { "fcmovnb", 7, TOKEN_INSN, 0, 0, I_FCMOVNB },
+        { "fcmovnbe", 8, TOKEN_INSN, 0, 0, I_FCMOVNBE },
+        { "fcmovne", 7, TOKEN_INSN, 0, 0, I_FCMOVNE },
+        { "fcmovnu", 7, TOKEN_INSN, 0, 0, I_FCMOVNU },
+        { "fcmovu", 6, TOKEN_INSN, 0, 0, I_FCMOVU },
+        { "fcom", 4, TOKEN_INSN, 0, 0, I_FCOM },
+        { "fcomi", 5, TOKEN_INSN, 0, 0, I_FCOMI },
+        { "fcomip", 6, TOKEN_INSN, 0, 0, I_FCOMIP },
+        { "fcomp", 5, TOKEN_INSN, 0, 0, I_FCOMP },
+        { "fcompp", 6, TOKEN_INSN, 0, 0, I_FCOMPP },
+        { "fcos", 4, TOKEN_INSN, 0, 0, I_FCOS },
+        { "fdecstp", 7, TOKEN_INSN, 0, 0, I_FDECSTP },
+        { "fdisi", 5, TOKEN_INSN, 0, 0, I_FDISI },
+        { "fdiv", 4, TOKEN_INSN, 0, 0, I_FDIV },
+        { "fdivp", 5, TOKEN_INSN, 0, 0, I_FDIVP },
+        { "fdivr", 5, TOKEN_INSN, 0, 0, I_FDIVR },
+        { "fdivrp", 6, TOKEN_INSN, 0, 0, I_FDIVRP },
+        { "femms", 5, TOKEN_INSN, 0, 0, I_FEMMS },
+        { "feni", 4, TOKEN_INSN, 0, 0, I_FENI },
+        { "ffree", 5, TOKEN_INSN, 0, 0, I_FFREE },
+        { "ffreep", 6, TOKEN_INSN, 0, 0, I_FFREEP },
+        { "fiadd", 5, TOKEN_INSN, 0, 0, I_FIADD },
+        { "ficom", 5, TOKEN_INSN, 0, 0, I_FICOM },
+        { "ficomp", 6, TOKEN_INSN, 0, 0, I_FICOMP },
+        { "fidiv", 5, TOKEN_INSN, 0, 0, I_FIDIV },
+        { "fidivr", 6, TOKEN_INSN, 0, 0, I_FIDIVR },
+        { "fild", 4, TOKEN_INSN, 0, 0, I_FILD },
+        { "fimul", 5, TOKEN_INSN, 0, 0, I_FIMUL },
+        { "fincstp", 7, TOKEN_INSN, 0, 0, I_FINCSTP },
+        { "finit", 5, TOKEN_INSN, 0, 0, I_FINIT },
+        { "fist", 4, TOKEN_INSN, 0, 0, I_FIST },
+        { "fistp", 5, TOKEN_INSN, 0, 0, I_FISTP },
+        { "fisttp", 6, TOKEN_INSN, 0, 0, I_FISTTP },
+        { "fisub", 5, TOKEN_INSN, 0, 0, I_FISUB },
+        { "fisubr", 6, TOKEN_INSN, 0, 0, I_FISUBR },
+        { "fld", 3, TOKEN_INSN, 0, 0, I_FLD },
+        { "fld1", 4, TOKEN_INSN, 0, 0, I_FLD1 },
+        { "fldcw", 5, TOKEN_INSN, 0, 0, I_FLDCW },
+        { "fldenv", 6, TOKEN_INSN, 0, 0, I_FLDENV },
+        { "fldl2e", 6, TOKEN_INSN, 0, 0, I_FLDL2E },
+        { "fldl2t", 6, TOKEN_INSN, 0, 0, I_FLDL2T },
+        { "fldlg2", 6, TOKEN_INSN, 0, 0, I_FLDLG2 },
+        { "fldln2", 6, TOKEN_INSN, 0, 0, I_FLDLN2 },
+        { "fldpi", 5, TOKEN_INSN, 0, 0, I_FLDPI },
+        { "fldz", 4, TOKEN_INSN, 0, 0, I_FLDZ },
+        { "fmul", 4, TOKEN_INSN, 0, 0, I_FMUL },
+        { "fmulp", 5, TOKEN_INSN, 0, 0, I_FMULP },
+        { "fnclex", 6, TOKEN_INSN, 0, 0, I_FNCLEX },
+        { "fndisi", 6, TOKEN_INSN, 0, 0, I_FNDISI },
+        { "fneni", 5, TOKEN_INSN, 0, 0, I_FNENI },
+        { "fninit", 6, TOKEN_INSN, 0, 0, I_FNINIT },
+        { "fnop", 4, TOKEN_INSN, 0, 0, I_FNOP },
+        { "fnsave", 6, TOKEN_INSN, 0, 0, I_FNSAVE },
+        { "fnstcw", 6, TOKEN_INSN, 0, 0, I_FNSTCW },
+        { "fnstenv", 7, TOKEN_INSN, 0, 0, I_FNSTENV },
+        { "fnstsw", 6, TOKEN_INSN, 0, 0, I_FNSTSW },
+        { "fpatan", 6, TOKEN_INSN, 0, 0, I_FPATAN },
+        { "fprem", 5, TOKEN_INSN, 0, 0, I_FPREM },
+        { "fprem1", 6, TOKEN_INSN, 0, 0, I_FPREM1 },
+        { "fptan", 5, TOKEN_INSN, 0, 0, I_FPTAN },
+        { "frndint", 7, TOKEN_INSN, 0, 0, I_FRNDINT },
+        { "frstor", 6, TOKEN_INSN, 0, 0, I_FRSTOR },
+        { "fsave", 5, TOKEN_INSN, 0, 0, I_FSAVE },
+        { "fscale", 6, TOKEN_INSN, 0, 0, I_FSCALE },
+        { "fsetpm", 6, TOKEN_INSN, 0, 0, I_FSETPM },
+        { "fsin", 4, TOKEN_INSN, 0, 0, I_FSIN },
+        { "fsincos", 7, TOKEN_INSN, 0, 0, I_FSINCOS },
+        { "fsqrt", 5, TOKEN_INSN, 0, 0, I_FSQRT },
+        { "fst", 3, TOKEN_INSN, 0, 0, I_FST },
+        { "fstcw", 5, TOKEN_INSN, 0, 0, I_FSTCW },
+        { "fstenv", 6, TOKEN_INSN, 0, 0, I_FSTENV },
+        { "fstp", 4, TOKEN_INSN, 0, 0, I_FSTP },
+        { "fstsw", 5, TOKEN_INSN, 0, 0, I_FSTSW },
+        { "fsub", 4, TOKEN_INSN, 0, 0, I_FSUB },
+        { "fsubp", 5, TOKEN_INSN, 0, 0, I_FSUBP },
+        { "fsubr", 5, TOKEN_INSN, 0, 0, I_FSUBR },
+        { "fsubrp", 6, TOKEN_INSN, 0, 0, I_FSUBRP },
+        { "ftst", 4, TOKEN_INSN, 0, 0, I_FTST },
+        { "fucom", 5, TOKEN_INSN, 0, 0, I_FUCOM },
+        { "fucomi", 6, TOKEN_INSN, 0, 0, I_FUCOMI },
+        { "fucomip", 7, TOKEN_INSN, 0, 0, I_FUCOMIP },
+        { "fucomp", 6, TOKEN_INSN, 0, 0, I_FUCOMP },
+        { "fucompp", 7, TOKEN_INSN, 0, 0, I_FUCOMPP },
+        { "fxam", 4, TOKEN_INSN, 0, 0, I_FXAM },
+        { "fxch", 4, TOKEN_INSN, 0, 0, I_FXCH },
+        { "fxtract", 7, TOKEN_INSN, 0, 0, I_FXTRACT },
+        { "fyl2x", 5, TOKEN_INSN, 0, 0, I_FYL2X },
+        { "fyl2xp1", 7, TOKEN_INSN, 0, 0, I_FYL2XP1 },
+        { "hlt", 3, TOKEN_INSN, 0, 0, I_HLT },
+        { "ibts", 4, TOKEN_INSN, 0, 0, I_IBTS },
+        { "icebp", 5, TOKEN_INSN, 0, 0, I_ICEBP },
+        { "idiv", 4, TOKEN_INSN, 0, 0, I_IDIV },
+        { "imul", 4, TOKEN_INSN, 0, 0, I_IMUL },
+        { "in", 2, TOKEN_INSN, 0, 0, I_IN },
+        { "inc", 3, TOKEN_INSN, 0, 0, I_INC },
+        { "insb", 4, TOKEN_INSN, 0, 0, I_INSB },
+        { "insd", 4, TOKEN_INSN, 0, 0, I_INSD },
+        { "insw", 4, TOKEN_INSN, 0, 0, I_INSW },
+        { "int", 3, TOKEN_INSN, 0, 0, I_INT },
+        { "int01", 5, TOKEN_INSN, 0, 0, I_INT01 },
+        { "int1", 4, TOKEN_INSN, 0, 0, I_INT1 },
+        { "int03", 5, TOKEN_INSN, 0, 0, I_INT03 },
+        { "int3", 4, TOKEN_INSN, 0, 0, I_INT3 },
+        { "into", 4, TOKEN_INSN, 0, 0, I_INTO },
+        { "invd", 4, TOKEN_INSN, 0, 0, I_INVD },
+        { "invpcid", 7, TOKEN_INSN, 0, 0, I_INVPCID },
+        { "invlpg", 6, TOKEN_INSN, 0, 0, I_INVLPG },
+        { "invlpga", 7, TOKEN_INSN, 0, 0, I_INVLPGA },
+        { "iret", 4, TOKEN_INSN, 0, 0, I_IRET },
+        { "iretd", 5, TOKEN_INSN, 0, 0, I_IRETD },
+        { "iretq", 5, TOKEN_INSN, 0, 0, I_IRETQ },
+        { "iretw", 5, TOKEN_INSN, 0, 0, I_IRETW },
+        { "jcxz", 4, TOKEN_INSN, 0, 0, I_JCXZ },
+        { "jecxz", 5, TOKEN_INSN, 0, 0, I_JECXZ },
+        { "jrcxz", 5, TOKEN_INSN, 0, 0, I_JRCXZ },
+        { "jmp", 3, TOKEN_INSN, 0, 0, I_JMP },
+        { "jmpe", 4, TOKEN_INSN, 0, 0, I_JMPE },
+        { "lahf", 4, TOKEN_INSN, 0, 0, I_LAHF },
+        { "lar", 3, TOKEN_INSN, 0, 0, I_LAR },
+        { "lds", 3, TOKEN_INSN, 0, 0, I_LDS },
+        { "lea", 3, TOKEN_INSN, 0, 0, I_LEA },
+        { "leave", 5, TOKEN_INSN, 0, 0, I_LEAVE },
+        { "les", 3, TOKEN_INSN, 0, 0, I_LES },
+        { "lfence", 6, TOKEN_INSN, 0, 0, I_LFENCE },
+        { "lfs", 3, TOKEN_INSN, 0, 0, I_LFS },
+        { "lgdt", 4, TOKEN_INSN, 0, 0, I_LGDT },
+        { "lgs", 3, TOKEN_INSN, 0, 0, I_LGS },
+        { "lidt", 4, TOKEN_INSN, 0, 0, I_LIDT },
+        { "lldt", 4, TOKEN_INSN, 0, 0, I_LLDT },
+        { "lmsw", 4, TOKEN_INSN, 0, 0, I_LMSW },
+        { "loadall", 7, TOKEN_INSN, 0, 0, I_LOADALL },
+        { "loadall286", 10, TOKEN_INSN, 0, 0, I_LOADALL286 },
+        { "lodsb", 5, TOKEN_INSN, 0, 0, I_LODSB },
+        { "lodsd", 5, TOKEN_INSN, 0, 0, I_LODSD },
+        { "lodsq", 5, TOKEN_INSN, 0, 0, I_LODSQ },
+        { "lodsw", 5, TOKEN_INSN, 0, 0, I_LODSW },
+        { "loop", 4, TOKEN_INSN, 0, 0, I_LOOP },
+        { "loope", 5, TOKEN_INSN, 0, 0, I_LOOPE },
+        { "loopne", 6, TOKEN_INSN, 0, 0, I_LOOPNE },
+        { "loopnz", 6, TOKEN_INSN, 0, 0, I_LOOPNZ },
+        { "loopz", 5, TOKEN_INSN, 0, 0, I_LOOPZ },
+        { "lsl", 3, TOKEN_INSN, 0, 0, I_LSL },
+        { "lss", 3, TOKEN_INSN, 0, 0, I_LSS },
+        { "ltr", 3, TOKEN_INSN, 0, 0, I_LTR },
+        { "mfence", 6, TOKEN_INSN, 0, 0, I_MFENCE },
+        { "monitor", 7, TOKEN_INSN, 0, 0, I_MONITOR },
+        { "monitorx", 8, TOKEN_INSN, 0, 0, I_MONITORX },
+        { "mov", 3, TOKEN_INSN, 0, 0, I_MOV },
+        { "movd", 4, TOKEN_INSN, 0, 0, I_MOVD },
+        { "movq", 4, TOKEN_INSN, 0, 0, I_MOVQ },
+        { "movsb", 5, TOKEN_INSN, 0, 0, I_MOVSB },
+        { "movsd", 5, TOKEN_INSN, 0, 0, I_MOVSD },
+        { "movsq", 5, TOKEN_INSN, 0, 0, I_MOVSQ },
+        { "movsw", 5, TOKEN_INSN, 0, 0, I_MOVSW },
+        { "movsx", 5, TOKEN_INSN, 0, 0, I_MOVSX },
+        { "movsxd", 6, TOKEN_INSN, 0, 0, I_MOVSXD },
+        { "movzx", 5, TOKEN_INSN, 0, 0, I_MOVZX },
+        { "mul", 3, TOKEN_INSN, 0, 0, I_MUL },
+        { "mwait", 5, TOKEN_INSN, 0, 0, I_MWAIT },
+        { "mwaitx", 6, TOKEN_INSN, 0, 0, I_MWAITX },
+        { "neg", 3, TOKEN_INSN, 0, 0, I_NEG },
+        { "nop", 3, TOKEN_INSN, 0, 0, I_NOP },
+        { "not", 3, TOKEN_INSN, 0, 0, I_NOT },
+        { "or", 2, TOKEN_INSN, 0, 0, I_OR },
+        { "out", 3, TOKEN_INSN, 0, 0, I_OUT },
+        { "outsb", 5, TOKEN_INSN, 0, 0, I_OUTSB },
+        { "outsd", 5, TOKEN_INSN, 0, 0, I_OUTSD },
+        { "outsw", 5, TOKEN_INSN, 0, 0, I_OUTSW },
+        { "packssdw", 8, TOKEN_INSN, 0, 0, I_PACKSSDW },
+        { "packsswb", 8, TOKEN_INSN, 0, 0, I_PACKSSWB },
+        { "packuswb", 8, TOKEN_INSN, 0, 0, I_PACKUSWB },
+        { "paddb", 5, TOKEN_INSN, 0, 0, I_PADDB },
+        { "paddd", 5, TOKEN_INSN, 0, 0, I_PADDD },
+        { "paddsb", 6, TOKEN_INSN, 0, 0, I_PADDSB },
+        { "paddsiw", 7, TOKEN_INSN, 0, 0, I_PADDSIW },
+        { "paddsw", 6, TOKEN_INSN, 0, 0, I_PADDSW },
+        { "paddusb", 7, TOKEN_INSN, 0, 0, I_PADDUSB },
+        { "paddusw", 7, TOKEN_INSN, 0, 0, I_PADDUSW },
+        { "paddw", 5, TOKEN_INSN, 0, 0, I_PADDW },
+        { "pand", 4, TOKEN_INSN, 0, 0, I_PAND },
+        { "pandn", 5, TOKEN_INSN, 0, 0, I_PANDN },
+        { "pause", 5, TOKEN_INSN, 0, 0, I_PAUSE },
+        { "paveb", 5, TOKEN_INSN, 0, 0, I_PAVEB },
+        { "pavgusb", 7, TOKEN_INSN, 0, 0, I_PAVGUSB },
+        { "pcmpeqb", 7, TOKEN_INSN, 0, 0, I_PCMPEQB },
+        { "pcmpeqd", 7, TOKEN_INSN, 0, 0, I_PCMPEQD },
+        { "pcmpeqw", 7, TOKEN_INSN, 0, 0, I_PCMPEQW },
+        { "pcmpgtb", 7, TOKEN_INSN, 0, 0, I_PCMPGTB },
+        { "pcmpgtd", 7, TOKEN_INSN, 0, 0, I_PCMPGTD },
+        { "pcmpgtw", 7, TOKEN_INSN, 0, 0, I_PCMPGTW },
+        { "pdistib", 7, TOKEN_INSN, 0, 0, I_PDISTIB },
+        { "pf2id", 5, TOKEN_INSN, 0, 0, I_PF2ID },
+        { "pfacc", 5, TOKEN_INSN, 0, 0, I_PFACC },
+        { "pfadd", 5, TOKEN_INSN, 0, 0, I_PFADD },
+        { "pfcmpeq", 7, TOKEN_INSN, 0, 0, I_PFCMPEQ },
+        { "pfcmpge", 7, TOKEN_INSN, 0, 0, I_PFCMPGE },
+        { "pfcmpgt", 7, TOKEN_INSN, 0, 0, I_PFCMPGT },
+        { "pfmax", 5, TOKEN_INSN, 0, 0, I_PFMAX },
+        { "pfmin", 5, TOKEN_INSN, 0, 0, I_PFMIN },
+        { "pfmul", 5, TOKEN_INSN, 0, 0, I_PFMUL },
+        { "pfrcp", 5, TOKEN_INSN, 0, 0, I_PFRCP },
+        { "pfrcpit1", 8, TOKEN_INSN, 0, 0, I_PFRCPIT1 },
+        { "pfrcpit2", 8, TOKEN_INSN, 0, 0, I_PFRCPIT2 },
+        { "pfrsqit1", 8, TOKEN_INSN, 0, 0, I_PFRSQIT1 },
+        { "pfrsqrt", 7, TOKEN_INSN, 0, 0, I_PFRSQRT },
+        { "pfsub", 5, TOKEN_INSN, 0, 0, I_PFSUB },
+        { "pfsubr", 6, TOKEN_INSN, 0, 0, I_PFSUBR },
+        { "pi2fd", 5, TOKEN_INSN, 0, 0, I_PI2FD },
+        { "pmachriw", 8, TOKEN_INSN, 0, 0, I_PMACHRIW },
+        { "pmaddwd", 7, TOKEN_INSN, 0, 0, I_PMADDWD },
+        { "pmagw", 5, TOKEN_INSN, 0, 0, I_PMAGW },
+        { "pmulhriw", 8, TOKEN_INSN, 0, 0, I_PMULHRIW },
+        { "pmulhrwa", 8, TOKEN_INSN, 0, 0, I_PMULHRWA },
+        { "pmulhrwc", 8, TOKEN_INSN, 0, 0, I_PMULHRWC },
+        { "pmulhw", 6, TOKEN_INSN, 0, 0, I_PMULHW },
+        { "pmullw", 6, TOKEN_INSN, 0, 0, I_PMULLW },
+        { "pmvgezb", 7, TOKEN_INSN, 0, 0, I_PMVGEZB },
+        { "pmvlzb", 6, TOKEN_INSN, 0, 0, I_PMVLZB },
+        { "pmvnzb", 6, TOKEN_INSN, 0, 0, I_PMVNZB },
+        { "pmvzb", 5, TOKEN_INSN, 0, 0, I_PMVZB },
+        { "pop", 3, TOKEN_INSN, 0, 0, I_POP },
+        { "popa", 4, TOKEN_INSN, 0, 0, I_POPA },
+        { "popad", 5, TOKEN_INSN, 0, 0, I_POPAD },
+        { "popaw", 5, TOKEN_INSN, 0, 0, I_POPAW },
+        { "popf", 4, TOKEN_INSN, 0, 0, I_POPF },
+        { "popfd", 5, TOKEN_INSN, 0, 0, I_POPFD },
+        { "popfq", 5, TOKEN_INSN, 0, 0, I_POPFQ },
+        { "popfw", 5, TOKEN_INSN, 0, 0, I_POPFW },
+        { "por", 3, TOKEN_INSN, 0, 0, I_POR },
+        { "prefetch", 8, TOKEN_INSN, 0, 0, I_PREFETCH },
+        { "prefetchw", 9, TOKEN_INSN, 0, 0, I_PREFETCHW },
+        { "pslld", 5, TOKEN_INSN, 0, 0, I_PSLLD },
+        { "psllq", 5, TOKEN_INSN, 0, 0, I_PSLLQ },
+        { "psllw", 5, TOKEN_INSN, 0, 0, I_PSLLW },
+        { "psrad", 5, TOKEN_INSN, 0, 0, I_PSRAD },
+        { "psraw", 5, TOKEN_INSN, 0, 0, I_PSRAW },
+        { "psrld", 5, TOKEN_INSN, 0, 0, I_PSRLD },
+        { "psrlq", 5, TOKEN_INSN, 0, 0, I_PSRLQ },
+        { "psrlw", 5, TOKEN_INSN, 0, 0, I_PSRLW },
+        { "psubb", 5, TOKEN_INSN, 0, 0, I_PSUBB },
+        { "psubd", 5, TOKEN_INSN, 0, 0, I_PSUBD },
+        { "psubsb", 6, TOKEN_INSN, 0, 0, I_PSUBSB },
+        { "psubsiw", 7, TOKEN_INSN, 0, 0, I_PSUBSIW },
+        { "psubsw", 6, TOKEN_INSN, 0, 0, I_PSUBSW },
+        { "psubusb", 7, TOKEN_INSN, 0, 0, I_PSUBUSB },
+        { "psubusw", 7, TOKEN_INSN, 0, 0, I_PSUBUSW },
+        { "psubw", 5, TOKEN_INSN, 0, 0, I_PSUBW },
+        { "punpckhbw", 9, TOKEN_INSN, 0, 0, I_PUNPCKHBW },
+        { "punpckhdq", 9, TOKEN_INSN, 0, 0, I_PUNPCKHDQ },
+        { "punpckhwd", 9, TOKEN_INSN, 0, 0, I_PUNPCKHWD },
+        { "punpcklbw", 9, TOKEN_INSN, 0, 0, I_PUNPCKLBW },
+        { "punpckldq", 9, TOKEN_INSN, 0, 0, I_PUNPCKLDQ },
+        { "punpcklwd", 9, TOKEN_INSN, 0, 0, I_PUNPCKLWD },
+        { "push", 4, TOKEN_INSN, 0, 0, I_PUSH },
+        { "pusha", 5, TOKEN_INSN, 0, 0, I_PUSHA },
+        { "pushad", 6, TOKEN_INSN, 0, 0, I_PUSHAD },
+        { "pushaw", 6, TOKEN_INSN, 0, 0, I_PUSHAW },
+        { "pushf", 5, TOKEN_INSN, 0, 0, I_PUSHF },
+        { "pushfd", 6, TOKEN_INSN, 0, 0, I_PUSHFD },
+        { "pushfq", 6, TOKEN_INSN, 0, 0, I_PUSHFQ },
+        { "pushfw", 6, TOKEN_INSN, 0, 0, I_PUSHFW },
+        { "pxor", 4, TOKEN_INSN, 0, 0, I_PXOR },
+        { "rcl", 3, TOKEN_INSN, 0, 0, I_RCL },
+        { "rcr", 3, TOKEN_INSN, 0, 0, I_RCR },
+        { "rdshr", 5, TOKEN_INSN, 0, 0, I_RDSHR },
+        { "rdmsr", 5, TOKEN_INSN, 0, 0, I_RDMSR },
+        { "rdpmc", 5, TOKEN_INSN, 0, 0, I_RDPMC },
+        { "rdtsc", 5, TOKEN_INSN, 0, 0, I_RDTSC },
+        { "rdtscp", 6, TOKEN_INSN, 0, 0, I_RDTSCP },
+        { "ret", 3, TOKEN_INSN, 0, 0, I_RET },
+        { "retf", 4, TOKEN_INSN, 0, 0, I_RETF },
+        { "retn", 4, TOKEN_INSN, 0, 0, I_RETN },
+        { "retw", 4, TOKEN_INSN, 0, 0, I_RETW },
+        { "retfw", 5, TOKEN_INSN, 0, 0, I_RETFW },
+        { "retnw", 5, TOKEN_INSN, 0, 0, I_RETNW },
+        { "retd", 4, TOKEN_INSN, 0, 0, I_RETD },
+        { "retfd", 5, TOKEN_INSN, 0, 0, I_RETFD },
+        { "retnd", 5, TOKEN_INSN, 0, 0, I_RETND },
+        { "retq", 4, TOKEN_INSN, 0, 0, I_RETQ },
+        { "retfq", 5, TOKEN_INSN, 0, 0, I_RETFQ },
+        { "retnq", 5, TOKEN_INSN, 0, 0, I_RETNQ },
+        { "rol", 3, TOKEN_INSN, 0, 0, I_ROL },
+        { "ror", 3, TOKEN_INSN, 0, 0, I_ROR },
+        { "rdm", 3, TOKEN_INSN, 0, 0, I_RDM },
+        { "rsdc", 4, TOKEN_INSN, 0, 0, I_RSDC },
+        { "rsldt", 5, TOKEN_INSN, 0, 0, I_RSLDT },
+        { "rsm", 3, TOKEN_INSN, 0, 0, I_RSM },
+        { "rsts", 4, TOKEN_INSN, 0, 0, I_RSTS },
+        { "sahf", 4, TOKEN_INSN, 0, 0, I_SAHF },
+        { "sal", 3, TOKEN_INSN, 0, 0, I_SAL },
+        { "salc", 4, TOKEN_INSN, 0, 0, I_SALC },
+        { "sar", 3, TOKEN_INSN, 0, 0, I_SAR },
+        { "sbb", 3, TOKEN_INSN, 0, 0, I_SBB },
+        { "scasb", 5, TOKEN_INSN, 0, 0, I_SCASB },
+        { "scasd", 5, TOKEN_INSN, 0, 0, I_SCASD },
+        { "scasq", 5, TOKEN_INSN, 0, 0, I_SCASQ },
+        { "scasw", 5, TOKEN_INSN, 0, 0, I_SCASW },
+        { "sfence", 6, TOKEN_INSN, 0, 0, I_SFENCE },
+        { "sgdt", 4, TOKEN_INSN, 0, 0, I_SGDT },
+        { "shl", 3, TOKEN_INSN, 0, 0, I_SHL },
+        { "shld", 4, TOKEN_INSN, 0, 0, I_SHLD },
+        { "shr", 3, TOKEN_INSN, 0, 0, I_SHR },
+        { "shrd", 4, TOKEN_INSN, 0, 0, I_SHRD },
+        { "sidt", 4, TOKEN_INSN, 0, 0, I_SIDT },
+        { "sldt", 4, TOKEN_INSN, 0, 0, I_SLDT },
+        { "skinit", 6, TOKEN_INSN, 0, 0, I_SKINIT },
+        { "smi", 3, TOKEN_INSN, 0, 0, I_SMI },
+        { "smint", 5, TOKEN_INSN, 0, 0, I_SMINT },
+        { "smintold", 8, TOKEN_INSN, 0, 0, I_SMINTOLD },
+        { "smsw", 4, TOKEN_INSN, 0, 0, I_SMSW },
+        { "stc", 3, TOKEN_INSN, 0, 0, I_STC },
+        { "std", 3, TOKEN_INSN, 0, 0, I_STD },
+        { "sti", 3, TOKEN_INSN, 0, 0, I_STI },
+        { "stosb", 5, TOKEN_INSN, 0, 0, I_STOSB },
+        { "stosd", 5, TOKEN_INSN, 0, 0, I_STOSD },
+        { "stosq", 5, TOKEN_INSN, 0, 0, I_STOSQ },
+        { "stosw", 5, TOKEN_INSN, 0, 0, I_STOSW },
+        { "str", 3, TOKEN_INSN, 0, 0, I_STR },
+        { "sub", 3, TOKEN_INSN, 0, 0, I_SUB },
+        { "svdc", 4, TOKEN_INSN, 0, 0, I_SVDC },
+        { "svldt", 5, TOKEN_INSN, 0, 0, I_SVLDT },
+        { "svts", 4, TOKEN_INSN, 0, 0, I_SVTS },
+        { "swapgs", 6, TOKEN_INSN, 0, 0, I_SWAPGS },
+        { "syscall", 7, TOKEN_INSN, 0, 0, I_SYSCALL },
+        { "sysenter", 8, TOKEN_INSN, 0, 0, I_SYSENTER },
+        { "sysexit", 7, TOKEN_INSN, 0, 0, I_SYSEXIT },
+        { "sysret", 6, TOKEN_INSN, 0, 0, I_SYSRET },
+        { "test", 4, TOKEN_INSN, 0, 0, I_TEST },
+        { "ud0", 3, TOKEN_INSN, 0, 0, I_UD0 },
+        { "ud1", 3, TOKEN_INSN, 0, 0, I_UD1 },
+        { "ud2b", 4, TOKEN_INSN, 0, 0, I_UD2B },
+        { "ud2", 3, TOKEN_INSN, 0, 0, I_UD2 },
+        { "ud2a", 4, TOKEN_INSN, 0, 0, I_UD2A },
+        { "umov", 4, TOKEN_INSN, 0, 0, I_UMOV },
+        { "verr", 4, TOKEN_INSN, 0, 0, I_VERR },
+        { "verw", 4, TOKEN_INSN, 0, 0, I_VERW },
+        { "fwait", 5, TOKEN_INSN, 0, 0, I_FWAIT },
+        { "wbinvd", 6, TOKEN_INSN, 0, 0, I_WBINVD },
+        { "wrshr", 5, TOKEN_INSN, 0, 0, I_WRSHR },
+        { "wrmsr", 5, TOKEN_INSN, 0, 0, I_WRMSR },
+        { "xadd", 4, TOKEN_INSN, 0, 0, I_XADD },
+        { "xbts", 4, TOKEN_INSN, 0, 0, I_XBTS },
+        { "xchg", 4, TOKEN_INSN, 0, 0, I_XCHG },
+        { "xlatb", 5, TOKEN_INSN, 0, 0, I_XLATB },
+        { "xlat", 4, TOKEN_INSN, 0, 0, I_XLAT },
+        { "xor", 3, TOKEN_INSN, 0, 0, I_XOR },
+        { "cmova", 5, TOKEN_INSN, 0, 0, I_CMOVA },
+        { "cmovae", 6, TOKEN_INSN, 0, 0, I_CMOVAE },
+        { "cmovb", 5, TOKEN_INSN, 0, 0, I_CMOVB },
+        { "cmovbe", 6, TOKEN_INSN, 0, 0, I_CMOVBE },
+        { "cmovc", 5, TOKEN_INSN, 0, 0, I_CMOVC },
+        { "cmove", 5, TOKEN_INSN, 0, 0, I_CMOVE },
+        { "cmovg", 5, TOKEN_INSN, 0, 0, I_CMOVG },
+        { "cmovge", 6, TOKEN_INSN, 0, 0, I_CMOVGE },
+        { "cmovl", 5, TOKEN_INSN, 0, 0, I_CMOVL },
+        { "cmovle", 6, TOKEN_INSN, 0, 0, I_CMOVLE },
+        { "cmovna", 6, TOKEN_INSN, 0, 0, I_CMOVNA },
+        { "cmovnae", 7, TOKEN_INSN, 0, 0, I_CMOVNAE },
+        { "cmovnb", 6, TOKEN_INSN, 0, 0, I_CMOVNB },
+        { "cmovnbe", 7, TOKEN_INSN, 0, 0, I_CMOVNBE },
+        { "cmovnc", 6, TOKEN_INSN, 0, 0, I_CMOVNC },
+        { "cmovne", 6, TOKEN_INSN, 0, 0, I_CMOVNE },
+        { "cmovng", 6, TOKEN_INSN, 0, 0, I_CMOVNG },
+        { "cmovnge", 7, TOKEN_INSN, 0, 0, I_CMOVNGE },
+        { "cmovnl", 6, TOKEN_INSN, 0, 0, I_CMOVNL },
+        { "cmovnle", 7, TOKEN_INSN, 0, 0, I_CMOVNLE },
+        { "cmovno", 6, TOKEN_INSN, 0, 0, I_CMOVNO },
+        { "cmovnp", 6, TOKEN_INSN, 0, 0, I_CMOVNP },
+        { "cmovns", 6, TOKEN_INSN, 0, 0, I_CMOVNS },
+        { "cmovnz", 6, TOKEN_INSN, 0, 0, I_CMOVNZ },
+        { "cmovo", 5, TOKEN_INSN, 0, 0, I_CMOVO },
+        { "cmovp", 5, TOKEN_INSN, 0, 0, I_CMOVP },
+        { "cmovpe", 6, TOKEN_INSN, 0, 0, I_CMOVPE },
+        { "cmovpo", 6, TOKEN_INSN, 0, 0, I_CMOVPO },
+        { "cmovs", 5, TOKEN_INSN, 0, 0, I_CMOVS },
+        { "cmovz", 5, TOKEN_INSN, 0, 0, I_CMOVZ },
+        { "ja", 2, TOKEN_INSN, 0, 0, I_JA },
+        { "jae", 3, TOKEN_INSN, 0, 0, I_JAE },
+        { "jb", 2, TOKEN_INSN, 0, 0, I_JB },
+        { "jbe", 3, TOKEN_INSN, 0, 0, I_JBE },
+        { "jc", 2, TOKEN_INSN, 0, 0, I_JC },
+        { "je", 2, TOKEN_INSN, 0, 0, I_JE },
+        { "jg", 2, TOKEN_INSN, 0, 0, I_JG },
+        { "jge", 3, TOKEN_INSN, 0, 0, I_JGE },
+        { "jl", 2, TOKEN_INSN, 0, 0, I_JL },
+        { "jle", 3, TOKEN_INSN, 0, 0, I_JLE },
+        { "jna", 3, TOKEN_INSN, 0, 0, I_JNA },
+        { "jnae", 4, TOKEN_INSN, 0, 0, I_JNAE },
+        { "jnb", 3, TOKEN_INSN, 0, 0, I_JNB },
+        { "jnbe", 4, TOKEN_INSN, 0, 0, I_JNBE },
+        { "jnc", 3, TOKEN_INSN, 0, 0, I_JNC },
+        { "jne", 3, TOKEN_INSN, 0, 0, I_JNE },
+        { "jng", 3, TOKEN_INSN, 0, 0, I_JNG },
+        { "jnge", 4, TOKEN_INSN, 0, 0, I_JNGE },
+        { "jnl", 3, TOKEN_INSN, 0, 0, I_JNL },
+        { "jnle", 4, TOKEN_INSN, 0, 0, I_JNLE },
+        { "jno", 3, TOKEN_INSN, 0, 0, I_JNO },
+        { "jnp", 3, TOKEN_INSN, 0, 0, I_JNP },
+        { "jns", 3, TOKEN_INSN, 0, 0, I_JNS },
+        { "jnz", 3, TOKEN_INSN, 0, 0, I_JNZ },
+        { "jo", 2, TOKEN_INSN, 0, 0, I_JO },
+        { "jp", 2, TOKEN_INSN, 0, 0, I_JP },
+        { "jpe", 3, TOKEN_INSN, 0, 0, I_JPE },
+        { "jpo", 3, TOKEN_INSN, 0, 0, I_JPO },
+        { "js", 2, TOKEN_INSN, 0, 0, I_JS },
+        { "jz", 2, TOKEN_INSN, 0, 0, I_JZ },
+        { "seta", 4, TOKEN_INSN, 0, 0, I_SETA },
+        { "setae", 5, TOKEN_INSN, 0, 0, I_SETAE },
+        { "setb", 4, TOKEN_INSN, 0, 0, I_SETB },
+        { "setbe", 5, TOKEN_INSN, 0, 0, I_SETBE },
+        { "setc", 4, TOKEN_INSN, 0, 0, I_SETC },
+        { "sete", 4, TOKEN_INSN, 0, 0, I_SETE },
+        { "setg", 4, TOKEN_INSN, 0, 0, I_SETG },
+        { "setge", 5, TOKEN_INSN, 0, 0, I_SETGE },
+        { "setl", 4, TOKEN_INSN, 0, 0, I_SETL },
+        { "setle", 5, TOKEN_INSN, 0, 0, I_SETLE },
+        { "setna", 5, TOKEN_INSN, 0, 0, I_SETNA },
+        { "setnae", 6, TOKEN_INSN, 0, 0, I_SETNAE },
+        { "setnb", 5, TOKEN_INSN, 0, 0, I_SETNB },
+        { "setnbe", 6, TOKEN_INSN, 0, 0, I_SETNBE },
+        { "setnc", 5, TOKEN_INSN, 0, 0, I_SETNC },
+        { "setne", 5, TOKEN_INSN, 0, 0, I_SETNE },
+        { "setng", 5, TOKEN_INSN, 0, 0, I_SETNG },
+        { "setnge", 6, TOKEN_INSN, 0, 0, I_SETNGE },
+        { "setnl", 5, TOKEN_INSN, 0, 0, I_SETNL },
+        { "setnle", 6, TOKEN_INSN, 0, 0, I_SETNLE },
+        { "setno", 5, TOKEN_INSN, 0, 0, I_SETNO },
+        { "setnp", 5, TOKEN_INSN, 0, 0, I_SETNP },
+        { "setns", 5, TOKEN_INSN, 0, 0, I_SETNS },
+        { "setnz", 5, TOKEN_INSN, 0, 0, I_SETNZ },
+        { "seto", 4, TOKEN_INSN, 0, 0, I_SETO },
+        { "setp", 4, TOKEN_INSN, 0, 0, I_SETP },
+        { "setpe", 5, TOKEN_INSN, 0, 0, I_SETPE },
+        { "setpo", 5, TOKEN_INSN, 0, 0, I_SETPO },
+        { "sets", 4, TOKEN_INSN, 0, 0, I_SETS },
+        { "setz", 4, TOKEN_INSN, 0, 0, I_SETZ },
+        { "addps", 5, TOKEN_INSN, 0, 0, I_ADDPS },
+        { "addss", 5, TOKEN_INSN, 0, 0, I_ADDSS },
+        { "andnps", 6, TOKEN_INSN, 0, 0, I_ANDNPS },
+        { "andps", 5, TOKEN_INSN, 0, 0, I_ANDPS },
+        { "cmpeqps", 7, TOKEN_INSN, 0, 0, I_CMPEQPS },
+        { "cmpeqss", 7, TOKEN_INSN, 0, 0, I_CMPEQSS },
+        { "cmpleps", 7, TOKEN_INSN, 0, 0, I_CMPLEPS },
+        { "cmpless", 7, TOKEN_INSN, 0, 0, I_CMPLESS },
+        { "cmpltps", 7, TOKEN_INSN, 0, 0, I_CMPLTPS },
+        { "cmpltss", 7, TOKEN_INSN, 0, 0, I_CMPLTSS },
+        { "cmpneqps", 8, TOKEN_INSN, 0, 0, I_CMPNEQPS },
+        { "cmpneqss", 8, TOKEN_INSN, 0, 0, I_CMPNEQSS },
+        { "cmpnleps", 8, TOKEN_INSN, 0, 0, I_CMPNLEPS },
+        { "cmpnless", 8, TOKEN_INSN, 0, 0, I_CMPNLESS },
+        { "cmpnltps", 8, TOKEN_INSN, 0, 0, I_CMPNLTPS },
+        { "cmpnltss", 8, TOKEN_INSN, 0, 0, I_CMPNLTSS },
+        { "cmpordps", 8, TOKEN_INSN, 0, 0, I_CMPORDPS },
+        { "cmpordss", 8, TOKEN_INSN, 0, 0, I_CMPORDSS },
+        { "cmpunordps", 10, TOKEN_INSN, 0, 0, I_CMPUNORDPS },
+        { "cmpunordss", 10, TOKEN_INSN, 0, 0, I_CMPUNORDSS },
+        { "cmpps", 5, TOKEN_INSN, 0, 0, I_CMPPS },
+        { "cmpss", 5, TOKEN_INSN, 0, 0, I_CMPSS },
+        { "comiss", 6, TOKEN_INSN, 0, 0, I_COMISS },
+        { "cvtpi2ps", 8, TOKEN_INSN, 0, 0, I_CVTPI2PS },
+        { "cvtps2pi", 8, TOKEN_INSN, 0, 0, I_CVTPS2PI },
+        { "cvtsi2ss", 8, TOKEN_INSN, 0, 0, I_CVTSI2SS },
+        { "cvtss2si", 8, TOKEN_INSN, 0, 0, I_CVTSS2SI },
+        { "cvttps2pi", 9, TOKEN_INSN, 0, 0, I_CVTTPS2PI },
+        { "cvttss2si", 9, TOKEN_INSN, 0, 0, I_CVTTSS2SI },
+        { "divps", 5, TOKEN_INSN, 0, 0, I_DIVPS },
+        { "divss", 5, TOKEN_INSN, 0, 0, I_DIVSS },
+        { "ldmxcsr", 7, TOKEN_INSN, 0, 0, I_LDMXCSR },
+        { "maxps", 5, TOKEN_INSN, 0, 0, I_MAXPS },
+        { "maxss", 5, TOKEN_INSN, 0, 0, I_MAXSS },
+        { "minps", 5, TOKEN_INSN, 0, 0, I_MINPS },
+        { "minss", 5, TOKEN_INSN, 0, 0, I_MINSS },
+        { "movaps", 6, TOKEN_INSN, 0, 0, I_MOVAPS },
+        { "movhps", 6, TOKEN_INSN, 0, 0, I_MOVHPS },
+        { "movlhps", 7, TOKEN_INSN, 0, 0, I_MOVLHPS },
+        { "movlps", 6, TOKEN_INSN, 0, 0, I_MOVLPS },
+        { "movhlps", 7, TOKEN_INSN, 0, 0, I_MOVHLPS },
+        { "movmskps", 8, TOKEN_INSN, 0, 0, I_MOVMSKPS },
+        { "movntps", 7, TOKEN_INSN, 0, 0, I_MOVNTPS },
+        { "movss", 5, TOKEN_INSN, 0, 0, I_MOVSS },
+        { "movups", 6, TOKEN_INSN, 0, 0, I_MOVUPS },
+        { "mulps", 5, TOKEN_INSN, 0, 0, I_MULPS },
+        { "mulss", 5, TOKEN_INSN, 0, 0, I_MULSS },
+        { "orps", 4, TOKEN_INSN, 0, 0, I_ORPS },
+        { "rcpps", 5, TOKEN_INSN, 0, 0, I_RCPPS },
+        { "rcpss", 5, TOKEN_INSN, 0, 0, I_RCPSS },
+        { "rsqrtps", 7, TOKEN_INSN, 0, 0, I_RSQRTPS },
+        { "rsqrtss", 7, TOKEN_INSN, 0, 0, I_RSQRTSS },
+        { "shufps", 6, TOKEN_INSN, 0, 0, I_SHUFPS },
+        { "sqrtps", 6, TOKEN_INSN, 0, 0, I_SQRTPS },
+        { "sqrtss", 6, TOKEN_INSN, 0, 0, I_SQRTSS },
+        { "stmxcsr", 7, TOKEN_INSN, 0, 0, I_STMXCSR },
+        { "subps", 5, TOKEN_INSN, 0, 0, I_SUBPS },
+        { "subss", 5, TOKEN_INSN, 0, 0, I_SUBSS },
+        { "ucomiss", 7, TOKEN_INSN, 0, 0, I_UCOMISS },
+        { "unpckhps", 8, TOKEN_INSN, 0, 0, I_UNPCKHPS },
+        { "unpcklps", 8, TOKEN_INSN, 0, 0, I_UNPCKLPS },
+        { "xorps", 5, TOKEN_INSN, 0, 0, I_XORPS },
+        { "fxrstor", 7, TOKEN_INSN, 0, 0, I_FXRSTOR },
+        { "fxrstor64", 9, TOKEN_INSN, 0, 0, I_FXRSTOR64 },
+        { "fxsave", 6, TOKEN_INSN, 0, 0, I_FXSAVE },
+        { "fxsave64", 8, TOKEN_INSN, 0, 0, I_FXSAVE64 },
+        { "xgetbv", 6, TOKEN_INSN, 0, 0, I_XGETBV },
+        { "xsetbv", 6, TOKEN_INSN, 0, 0, I_XSETBV },
+        { "xsave", 5, TOKEN_INSN, 0, 0, I_XSAVE },
+        { "xsave64", 7, TOKEN_INSN, 0, 0, I_XSAVE64 },
+        { "xsavec", 6, TOKEN_INSN, 0, 0, I_XSAVEC },
+        { "xsavec64", 8, TOKEN_INSN, 0, 0, I_XSAVEC64 },
+        { "xsaveopt", 8, TOKEN_INSN, 0, 0, I_XSAVEOPT },
+        { "xsaveopt64", 10, TOKEN_INSN, 0, 0, I_XSAVEOPT64 },
+        { "xsaves", 6, TOKEN_INSN, 0, 0, I_XSAVES },
+        { "xsaves64", 8, TOKEN_INSN, 0, 0, I_XSAVES64 },
+        { "xrstor", 6, TOKEN_INSN, 0, 0, I_XRSTOR },
+        { "xrstor64", 8, TOKEN_INSN, 0, 0, I_XRSTOR64 },
+        { "xrstors", 7, TOKEN_INSN, 0, 0, I_XRSTORS },
+        { "xrstors64", 9, TOKEN_INSN, 0, 0, I_XRSTORS64 },
+        { "prefetchnta", 11, TOKEN_INSN, 0, 0, I_PREFETCHNTA },
+        { "prefetcht0", 10, TOKEN_INSN, 0, 0, I_PREFETCHT0 },
+        { "prefetcht1", 10, TOKEN_INSN, 0, 0, I_PREFETCHT1 },
+        { "prefetcht2", 10, TOKEN_INSN, 0, 0, I_PREFETCHT2 },
+        { "prefetchit0", 11, TOKEN_INSN, 0, 0, I_PREFETCHIT0 },
+        { "prefetchit1", 11, TOKEN_INSN, 0, 0, I_PREFETCHIT1 },
+        { "maskmovq", 8, TOKEN_INSN, 0, 0, I_MASKMOVQ },
+        { "movntq", 6, TOKEN_INSN, 0, 0, I_MOVNTQ },
+        { "pavgb", 5, TOKEN_INSN, 0, 0, I_PAVGB },
+        { "pavgw", 5, TOKEN_INSN, 0, 0, I_PAVGW },
+        { "pextrw", 6, TOKEN_INSN, 0, 0, I_PEXTRW },
+        { "pinsrw", 6, TOKEN_INSN, 0, 0, I_PINSRW },
+        { "pmaxsw", 6, TOKEN_INSN, 0, 0, I_PMAXSW },
+        { "pmaxub", 6, TOKEN_INSN, 0, 0, I_PMAXUB },
+        { "pminsw", 6, TOKEN_INSN, 0, 0, I_PMINSW },
+        { "pminub", 6, TOKEN_INSN, 0, 0, I_PMINUB },
+        { "pmovmskb", 8, TOKEN_INSN, 0, 0, I_PMOVMSKB },
+        { "pmulhuw", 7, TOKEN_INSN, 0, 0, I_PMULHUW },
+        { "psadbw", 6, TOKEN_INSN, 0, 0, I_PSADBW },
+        { "pshufw", 6, TOKEN_INSN, 0, 0, I_PSHUFW },
+        { "pf2iw", 5, TOKEN_INSN, 0, 0, I_PF2IW },
+        { "pfnacc", 6, TOKEN_INSN, 0, 0, I_PFNACC },
+        { "pfpnacc", 7, TOKEN_INSN, 0, 0, I_PFPNACC },
+        { "pi2fw", 5, TOKEN_INSN, 0, 0, I_PI2FW },
+        { "pswapd", 6, TOKEN_INSN, 0, 0, I_PSWAPD },
+        { "maskmovdqu", 10, TOKEN_INSN, 0, 0, I_MASKMOVDQU },
+        { "clflush", 7, TOKEN_INSN, 0, 0, I_CLFLUSH },
+        { "movntdq", 7, TOKEN_INSN, 0, 0, I_MOVNTDQ },
+        { "movnti", 6, TOKEN_INSN, 0, 0, I_MOVNTI },
+        { "movntpd", 7, TOKEN_INSN, 0, 0, I_MOVNTPD },
+        { "movdqa", 6, TOKEN_INSN, 0, 0, I_MOVDQA },
+        { "movdqu", 6, TOKEN_INSN, 0, 0, I_MOVDQU },
+        { "movdq2q", 7, TOKEN_INSN, 0, 0, I_MOVDQ2Q },
+        { "movq2dq", 7, TOKEN_INSN, 0, 0, I_MOVQ2DQ },
+        { "paddq", 5, TOKEN_INSN, 0, 0, I_PADDQ },
+        { "pmuludq", 7, TOKEN_INSN, 0, 0, I_PMULUDQ },
+        { "pshufd", 6, TOKEN_INSN, 0, 0, I_PSHUFD },
+        { "pshufhw", 7, TOKEN_INSN, 0, 0, I_PSHUFHW },
+        { "pshuflw", 7, TOKEN_INSN, 0, 0, I_PSHUFLW },
+        { "pslldq", 6, TOKEN_INSN, 0, 0, I_PSLLDQ },
+        { "psrldq", 6, TOKEN_INSN, 0, 0, I_PSRLDQ },
+        { "psubq", 5, TOKEN_INSN, 0, 0, I_PSUBQ },
+        { "punpckhqdq", 10, TOKEN_INSN, 0, 0, I_PUNPCKHQDQ },
+        { "punpcklqdq", 10, TOKEN_INSN, 0, 0, I_PUNPCKLQDQ },
+        { "addpd", 5, TOKEN_INSN, 0, 0, I_ADDPD },
+        { "addsd", 5, TOKEN_INSN, 0, 0, I_ADDSD },
+        { "andnpd", 6, TOKEN_INSN, 0, 0, I_ANDNPD },
+        { "andpd", 5, TOKEN_INSN, 0, 0, I_ANDPD },
+        { "cmpeqpd", 7, TOKEN_INSN, 0, 0, I_CMPEQPD },
+        { "cmpeqsd", 7, TOKEN_INSN, 0, 0, I_CMPEQSD },
+        { "cmplepd", 7, TOKEN_INSN, 0, 0, I_CMPLEPD },
+        { "cmplesd", 7, TOKEN_INSN, 0, 0, I_CMPLESD },
+        { "cmpltpd", 7, TOKEN_INSN, 0, 0, I_CMPLTPD },
+        { "cmpltsd", 7, TOKEN_INSN, 0, 0, I_CMPLTSD },
+        { "cmpneqpd", 8, TOKEN_INSN, 0, 0, I_CMPNEQPD },
+        { "cmpneqsd", 8, TOKEN_INSN, 0, 0, I_CMPNEQSD },
+        { "cmpnlepd", 8, TOKEN_INSN, 0, 0, I_CMPNLEPD },
+        { "cmpnlesd", 8, TOKEN_INSN, 0, 0, I_CMPNLESD },
+        { "cmpnltpd", 8, TOKEN_INSN, 0, 0, I_CMPNLTPD },
+        { "cmpnltsd", 8, TOKEN_INSN, 0, 0, I_CMPNLTSD },
+        { "cmpordpd", 8, TOKEN_INSN, 0, 0, I_CMPORDPD },
+        { "cmpordsd", 8, TOKEN_INSN, 0, 0, I_CMPORDSD },
+        { "cmpunordpd", 10, TOKEN_INSN, 0, 0, I_CMPUNORDPD },
+        { "cmpunordsd", 10, TOKEN_INSN, 0, 0, I_CMPUNORDSD },
+        { "cmppd", 5, TOKEN_INSN, 0, 0, I_CMPPD },
+        { "comisd", 6, TOKEN_INSN, 0, 0, I_COMISD },
+        { "cvtdq2pd", 8, TOKEN_INSN, 0, 0, I_CVTDQ2PD },
+        { "cvtdq2ps", 8, TOKEN_INSN, 0, 0, I_CVTDQ2PS },
+        { "cvtpd2dq", 8, TOKEN_INSN, 0, 0, I_CVTPD2DQ },
+        { "cvtpd2pi", 8, TOKEN_INSN, 0, 0, I_CVTPD2PI },
+        { "cvtpd2ps", 8, TOKEN_INSN, 0, 0, I_CVTPD2PS },
+        { "cvtpi2pd", 8, TOKEN_INSN, 0, 0, I_CVTPI2PD },
+        { "cvtps2dq", 8, TOKEN_INSN, 0, 0, I_CVTPS2DQ },
+        { "cvtps2pd", 8, TOKEN_INSN, 0, 0, I_CVTPS2PD },
+        { "cvtsd2si", 8, TOKEN_INSN, 0, 0, I_CVTSD2SI },
+        { "cvtsd2ss", 8, TOKEN_INSN, 0, 0, I_CVTSD2SS },
+        { "cvtsi2sd", 8, TOKEN_INSN, 0, 0, I_CVTSI2SD },
+        { "cvtss2sd", 8, TOKEN_INSN, 0, 0, I_CVTSS2SD },
+        { "cvttpd2pi", 9, TOKEN_INSN, 0, 0, I_CVTTPD2PI },
+        { "cvttpd2dq", 9, TOKEN_INSN, 0, 0, I_CVTTPD2DQ },
+        { "cvttps2dq", 9, TOKEN_INSN, 0, 0, I_CVTTPS2DQ },
+        { "cvttsd2si", 9, TOKEN_INSN, 0, 0, I_CVTTSD2SI },
+        { "divpd", 5, TOKEN_INSN, 0, 0, I_DIVPD },
+        { "divsd", 5, TOKEN_INSN, 0, 0, I_DIVSD },
+        { "maxpd", 5, TOKEN_INSN, 0, 0, I_MAXPD },
+        { "maxsd", 5, TOKEN_INSN, 0, 0, I_MAXSD },
+        { "minpd", 5, TOKEN_INSN, 0, 0, I_MINPD },
+        { "minsd", 5, TOKEN_INSN, 0, 0, I_MINSD },
+        { "movapd", 6, TOKEN_INSN, 0, 0, I_MOVAPD },
+        { "movhpd", 6, TOKEN_INSN, 0, 0, I_MOVHPD },
+        { "movlpd", 6, TOKEN_INSN, 0, 0, I_MOVLPD },
+        { "movmskpd", 8, TOKEN_INSN, 0, 0, I_MOVMSKPD },
+        { "movupd", 6, TOKEN_INSN, 0, 0, I_MOVUPD },
+        { "mulpd", 5, TOKEN_INSN, 0, 0, I_MULPD },
+        { "mulsd", 5, TOKEN_INSN, 0, 0, I_MULSD },
+        { "orpd", 4, TOKEN_INSN, 0, 0, I_ORPD },
+        { "shufpd", 6, TOKEN_INSN, 0, 0, I_SHUFPD },
+        { "sqrtpd", 6, TOKEN_INSN, 0, 0, I_SQRTPD },
+        { "sqrtsd", 6, TOKEN_INSN, 0, 0, I_SQRTSD },
+        { "subpd", 5, TOKEN_INSN, 0, 0, I_SUBPD },
+        { "subsd", 5, TOKEN_INSN, 0, 0, I_SUBSD },
+        { "ucomisd", 7, TOKEN_INSN, 0, 0, I_UCOMISD },
+        { "unpckhpd", 8, TOKEN_INSN, 0, 0, I_UNPCKHPD },
+        { "unpcklpd", 8, TOKEN_INSN, 0, 0, I_UNPCKLPD },
+        { "xorpd", 5, TOKEN_INSN, 0, 0, I_XORPD },
+        { "addsubpd", 8, TOKEN_INSN, 0, 0, I_ADDSUBPD },
+        { "addsubps", 8, TOKEN_INSN, 0, 0, I_ADDSUBPS },
+        { "haddpd", 6, TOKEN_INSN, 0, 0, I_HADDPD },
+        { "haddps", 6, TOKEN_INSN, 0, 0, I_HADDPS },
+        { "hsubpd", 6, TOKEN_INSN, 0, 0, I_HSUBPD },
+        { "hsubps", 6, TOKEN_INSN, 0, 0, I_HSUBPS },
+        { "lddqu", 5, TOKEN_INSN, 0, 0, I_LDDQU },
+        { "movddup", 7, TOKEN_INSN, 0, 0, I_MOVDDUP },
+        { "movshdup", 8, TOKEN_INSN, 0, 0, I_MOVSHDUP },
+        { "movsldup", 8, TOKEN_INSN, 0, 0, I_MOVSLDUP },
+        { "clgi", 4, TOKEN_INSN, 0, 0, I_CLGI },
+        { "stgi", 4, TOKEN_INSN, 0, 0, I_STGI },
+        { "vmcall", 6, TOKEN_INSN, 0, 0, I_VMCALL },
+        { "vmclear", 7, TOKEN_INSN, 0, 0, I_VMCLEAR },
+        { "vmfunc", 6, TOKEN_INSN, 0, 0, I_VMFUNC },
+        { "vmlaunch", 8, TOKEN_INSN, 0, 0, I_VMLAUNCH },
+        { "vmload", 6, TOKEN_INSN, 0, 0, I_VMLOAD },
+        { "vmmcall", 7, TOKEN_INSN, 0, 0, I_VMMCALL },
+        { "vmptrld", 7, TOKEN_INSN, 0, 0, I_VMPTRLD },
+        { "vmptrst", 7, TOKEN_INSN, 0, 0, I_VMPTRST },
+        { "vmread", 6, TOKEN_INSN, 0, 0, I_VMREAD },
+        { "vmresume", 8, TOKEN_INSN, 0, 0, I_VMRESUME },
+        { "vmrun", 5, TOKEN_INSN, 0, 0, I_VMRUN },
+        { "vmsave", 6, TOKEN_INSN, 0, 0, I_VMSAVE },
+        { "vmwrite", 7, TOKEN_INSN, 0, 0, I_VMWRITE },
+        { "vmxoff", 6, TOKEN_INSN, 0, 0, I_VMXOFF },
+        { "vmxon", 5, TOKEN_INSN, 0, 0, I_VMXON },
+        { "invept", 6, TOKEN_INSN, 0, 0, I_INVEPT },
+        { "invvpid", 7, TOKEN_INSN, 0, 0, I_INVVPID },
+        { "pvalidate", 9, TOKEN_INSN, 0, 0, I_PVALIDATE },
+        { "rmpadjust", 9, TOKEN_INSN, 0, 0, I_RMPADJUST },
+        { "vmgexit", 7, TOKEN_INSN, 0, 0, I_VMGEXIT },
+        { "pabsb", 5, TOKEN_INSN, 0, 0, I_PABSB },
+        { "pabsw", 5, TOKEN_INSN, 0, 0, I_PABSW },
+        { "pabsd", 5, TOKEN_INSN, 0, 0, I_PABSD },
+        { "palignr", 7, TOKEN_INSN, 0, 0, I_PALIGNR },
+        { "phaddw", 6, TOKEN_INSN, 0, 0, I_PHADDW },
+        { "phaddd", 6, TOKEN_INSN, 0, 0, I_PHADDD },
+        { "phaddsw", 7, TOKEN_INSN, 0, 0, I_PHADDSW },
+        { "phsubw", 6, TOKEN_INSN, 0, 0, I_PHSUBW },
+        { "phsubd", 6, TOKEN_INSN, 0, 0, I_PHSUBD },
+        { "phsubsw", 7, TOKEN_INSN, 0, 0, I_PHSUBSW },
+        { "pmaddubsw", 9, TOKEN_INSN, 0, 0, I_PMADDUBSW },
+        { "pmulhrsw", 8, TOKEN_INSN, 0, 0, I_PMULHRSW },
+        { "pshufb", 6, TOKEN_INSN, 0, 0, I_PSHUFB },
+        { "psignb", 6, TOKEN_INSN, 0, 0, I_PSIGNB },
+        { "psignw", 6, TOKEN_INSN, 0, 0, I_PSIGNW },
+        { "psignd", 6, TOKEN_INSN, 0, 0, I_PSIGND },
+        { "extrq", 5, TOKEN_INSN, 0, 0, I_EXTRQ },
+        { "insertq", 7, TOKEN_INSN, 0, 0, I_INSERTQ },
+        { "movntsd", 7, TOKEN_INSN, 0, 0, I_MOVNTSD },
+        { "movntss", 7, TOKEN_INSN, 0, 0, I_MOVNTSS },
+        { "lzcnt", 5, TOKEN_INSN, 0, 0, I_LZCNT },
+        { "blendpd", 7, TOKEN_INSN, 0, 0, I_BLENDPD },
+        { "blendps", 7, TOKEN_INSN, 0, 0, I_BLENDPS },
+        { "blendvpd", 8, TOKEN_INSN, 0, 0, I_BLENDVPD },
+        { "blendvps", 8, TOKEN_INSN, 0, 0, I_BLENDVPS },
+        { "dppd", 4, TOKEN_INSN, 0, 0, I_DPPD },
+        { "dpps", 4, TOKEN_INSN, 0, 0, I_DPPS },
+        { "extractps", 9, TOKEN_INSN, 0, 0, I_EXTRACTPS },
+        { "insertps", 8, TOKEN_INSN, 0, 0, I_INSERTPS },
+        { "movntdqa", 8, TOKEN_INSN, 0, 0, I_MOVNTDQA },
+        { "mpsadbw", 7, TOKEN_INSN, 0, 0, I_MPSADBW },
+        { "packusdw", 8, TOKEN_INSN, 0, 0, I_PACKUSDW },
+        { "pblendvb", 8, TOKEN_INSN, 0, 0, I_PBLENDVB },
+        { "pblendw", 7, TOKEN_INSN, 0, 0, I_PBLENDW },
+        { "pcmpeqq", 7, TOKEN_INSN, 0, 0, I_PCMPEQQ },
+        { "pextrb", 6, TOKEN_INSN, 0, 0, I_PEXTRB },
+        { "pextrd", 6, TOKEN_INSN, 0, 0, I_PEXTRD },
+        { "pextrq", 6, TOKEN_INSN, 0, 0, I_PEXTRQ },
+        { "phminposuw", 10, TOKEN_INSN, 0, 0, I_PHMINPOSUW },
+        { "pinsrb", 6, TOKEN_INSN, 0, 0, I_PINSRB },
+        { "pinsrd", 6, TOKEN_INSN, 0, 0, I_PINSRD },
+        { "pinsrq", 6, TOKEN_INSN, 0, 0, I_PINSRQ },
+        { "pmaxsb", 6, TOKEN_INSN, 0, 0, I_PMAXSB },
+        { "pmaxsd", 6, TOKEN_INSN, 0, 0, I_PMAXSD },
+        { "pmaxud", 6, TOKEN_INSN, 0, 0, I_PMAXUD },
+        { "pmaxuw", 6, TOKEN_INSN, 0, 0, I_PMAXUW },
+        { "pminsb", 6, TOKEN_INSN, 0, 0, I_PMINSB },
+        { "pminsd", 6, TOKEN_INSN, 0, 0, I_PMINSD },
+        { "pminud", 6, TOKEN_INSN, 0, 0, I_PMINUD },
+        { "pminuw", 6, TOKEN_INSN, 0, 0, I_PMINUW },
+        { "pmovsxbw", 8, TOKEN_INSN, 0, 0, I_PMOVSXBW },
+        { "pmovsxbd", 8, TOKEN_INSN, 0, 0, I_PMOVSXBD },
+        { "pmovsxbq", 8, TOKEN_INSN, 0, 0, I_PMOVSXBQ },
+        { "pmovsxwd", 8, TOKEN_INSN, 0, 0, I_PMOVSXWD },
+        { "pmovsxwq", 8, TOKEN_INSN, 0, 0, I_PMOVSXWQ },
+        { "pmovsxdq", 8, TOKEN_INSN, 0, 0, I_PMOVSXDQ },
+        { "pmovzxbw", 8, TOKEN_INSN, 0, 0, I_PMOVZXBW },
+        { "pmovzxbd", 8, TOKEN_INSN, 0, 0, I_PMOVZXBD },
+        { "pmovzxbq", 8, TOKEN_INSN, 0, 0, I_PMOVZXBQ },
+        { "pmovzxwd", 8, TOKEN_INSN, 0, 0, I_PMOVZXWD },
+        { "pmovzxwq", 8, TOKEN_INSN, 0, 0, I_PMOVZXWQ },
+        { "pmovzxdq", 8, TOKEN_INSN, 0, 0, I_PMOVZXDQ },
+        { "pmuldq", 6, TOKEN_INSN, 0, 0, I_PMULDQ },
+        { "pmulld", 6, TOKEN_INSN, 0, 0, I_PMULLD },
+        { "ptest", 5, TOKEN_INSN, 0, 0, I_PTEST },
+        { "roundpd", 7, TOKEN_INSN, 0, 0, I_ROUNDPD },
+        { "roundps", 7, TOKEN_INSN, 0, 0, I_ROUNDPS },
+        { "roundsd", 7, TOKEN_INSN, 0, 0, I_ROUNDSD },
+        { "roundss", 7, TOKEN_INSN, 0, 0, I_ROUNDSS },
+        { "crc32", 5, TOKEN_INSN, 0, 0, I_CRC32 },
+        { "pcmpestri", 9, TOKEN_INSN, 0, 0, I_PCMPESTRI },
+        { "pcmpestrm", 9, TOKEN_INSN, 0, 0, I_PCMPESTRM },
+        { "pcmpistri", 9, TOKEN_INSN, 0, 0, I_PCMPISTRI },
+        { "pcmpistrm", 9, TOKEN_INSN, 0, 0, I_PCMPISTRM },
+        { "pcmpgtq", 7, TOKEN_INSN, 0, 0, I_PCMPGTQ },
+        { "popcnt", 6, TOKEN_INSN, 0, 0, I_POPCNT },
+        { "getsec", 6, TOKEN_INSN, 0, 0, I_GETSEC },
+        { "pfrcpv", 6, TOKEN_INSN, 0, 0, I_PFRCPV },
+        { "pfrsqrtv", 8, TOKEN_INSN, 0, 0, I_PFRSQRTV },
+        { "movbe", 5, TOKEN_INSN, 0, 0, I_MOVBE },
+        { "aesenc", 6, TOKEN_INSN, 0, 0, I_AESENC },
+        { "aesenclast", 10, TOKEN_INSN, 0, 0, I_AESENCLAST },
+        { "aesdec", 6, TOKEN_INSN, 0, 0, I_AESDEC },
+        { "aesdeclast", 10, TOKEN_INSN, 0, 0, I_AESDECLAST },
+        { "aesimc", 6, TOKEN_INSN, 0, 0, I_AESIMC },
+        { "aeskeygenassist", 15, TOKEN_INSN, 0, 0, I_AESKEYGENASSIST },
+        { "vaesenc", 7, TOKEN_INSN, 0, 0, I_VAESENC },
+        { "vaesenclast", 11, TOKEN_INSN, 0, 0, I_VAESENCLAST },
+        { "vaesdec", 7, TOKEN_INSN, 0, 0, I_VAESDEC },
+        { "vaesdeclast", 11, TOKEN_INSN, 0, 0, I_VAESDECLAST },
+        { "vaesimc", 7, TOKEN_INSN, 0, 0, I_VAESIMC },
+        { "vaeskeygenassist", 16, TOKEN_INSN, 0, 0, I_VAESKEYGENASSIST },
+        { "vaddpd", 6, TOKEN_INSN, 0, 0, I_VADDPD },
+        { "vaddps", 6, TOKEN_INSN, 0, 0, I_VADDPS },
+        { "vaddsd", 6, TOKEN_INSN, 0, 0, I_VADDSD },
+        { "vaddss", 6, TOKEN_INSN, 0, 0, I_VADDSS },
+        { "vaddsubpd", 9, TOKEN_INSN, 0, 0, I_VADDSUBPD },
+        { "vaddsubps", 9, TOKEN_INSN, 0, 0, I_VADDSUBPS },
+        { "vandpd", 6, TOKEN_INSN, 0, 0, I_VANDPD },
+        { "vandps", 6, TOKEN_INSN, 0, 0, I_VANDPS },
+        { "vandnpd", 7, TOKEN_INSN, 0, 0, I_VANDNPD },
+        { "vandnps", 7, TOKEN_INSN, 0, 0, I_VANDNPS },
+        { "vblendpd", 8, TOKEN_INSN, 0, 0, I_VBLENDPD },
+        { "vblendps", 8, TOKEN_INSN, 0, 0, I_VBLENDPS },
+        { "vblendvpd", 9, TOKEN_INSN, 0, 0, I_VBLENDVPD },
+        { "vblendvps", 9, TOKEN_INSN, 0, 0, I_VBLENDVPS },
+        { "vbroadcastss", 12, TOKEN_INSN, 0, 0, I_VBROADCASTSS },
+        { "vbroadcastsd", 12, TOKEN_INSN, 0, 0, I_VBROADCASTSD },
+        { "vbroadcastf128", 14, TOKEN_INSN, 0, 0, I_VBROADCASTF128 },
+        { "vcmpeq_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSPD },
+        { "vcmpeqpd", 8, TOKEN_INSN, 0, 0, I_VCMPEQPD },
+        { "vcmplt_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSPD },
+        { "vcmpltpd", 8, TOKEN_INSN, 0, 0, I_VCMPLTPD },
+        { "vcmple_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSPD },
+        { "vcmplepd", 8, TOKEN_INSN, 0, 0, I_VCMPLEPD },
+        { "vcmpunord_qpd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QPD },
+        { "vcmpunordpd", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDPD },
+        { "vcmpneq_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQPD },
+        { "vcmpneqpd", 9, TOKEN_INSN, 0, 0, I_VCMPNEQPD },
+        { "vcmpnlt_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USPD },
+        { "vcmpnltpd", 9, TOKEN_INSN, 0, 0, I_VCMPNLTPD },
+        { "vcmpnle_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USPD },
+        { "vcmpnlepd", 9, TOKEN_INSN, 0, 0, I_VCMPNLEPD },
+        { "vcmpord_qpd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QPD },
+        { "vcmpordpd", 9, TOKEN_INSN, 0, 0, I_VCMPORDPD },
+        { "vcmpeq_uqpd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQPD },
+        { "vcmpnge_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USPD },
+        { "vcmpngepd", 9, TOKEN_INSN, 0, 0, I_VCMPNGEPD },
+        { "vcmpngt_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USPD },
+        { "vcmpngtpd", 9, TOKEN_INSN, 0, 0, I_VCMPNGTPD },
+        { "vcmpfalse_oqpd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQPD },
+        { "vcmpfalsepd", 11, TOKEN_INSN, 0, 0, I_VCMPFALSEPD },
+        { "vcmpneq_oqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQPD },
+        { "vcmpge_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSPD },
+        { "vcmpgepd", 8, TOKEN_INSN, 0, 0, I_VCMPGEPD },
+        { "vcmpgt_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSPD },
+        { "vcmpgtpd", 8, TOKEN_INSN, 0, 0, I_VCMPGTPD },
+        { "vcmptrue_uqpd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQPD },
+        { "vcmptruepd", 10, TOKEN_INSN, 0, 0, I_VCMPTRUEPD },
+        { "vcmplt_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQPD },
+        { "vcmple_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQPD },
+        { "vcmpunord_spd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SPD },
+        { "vcmpneq_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USPD },
+        { "vcmpnlt_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQPD },
+        { "vcmpnle_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQPD },
+        { "vcmpord_spd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SPD },
+        { "vcmpeq_uspd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USPD },
+        { "vcmpnge_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQPD },
+        { "vcmpngt_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQPD },
+        { "vcmpfalse_ospd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSPD },
+        { "vcmpneq_ospd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSPD },
+        { "vcmpge_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQPD },
+        { "vcmpgt_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQPD },
+        { "vcmptrue_uspd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USPD },
+        { "vcmppd", 6, TOKEN_INSN, 0, 0, I_VCMPPD },
+        { "vcmpeq_osps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSPS },
+        { "vcmpeqps", 8, TOKEN_INSN, 0, 0, I_VCMPEQPS },
+        { "vcmplt_osps", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSPS },
+        { "vcmpltps", 8, TOKEN_INSN, 0, 0, I_VCMPLTPS },
+        { "vcmple_osps", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSPS },
+        { "vcmpleps", 8, TOKEN_INSN, 0, 0, I_VCMPLEPS },
+        { "vcmpunord_qps", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QPS },
+        { "vcmpunordps", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDPS },
+        { "vcmpneq_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQPS },
+        { "vcmpneqps", 9, TOKEN_INSN, 0, 0, I_VCMPNEQPS },
+        { "vcmpnlt_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USPS },
+        { "vcmpnltps", 9, TOKEN_INSN, 0, 0, I_VCMPNLTPS },
+        { "vcmpnle_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USPS },
+        { "vcmpnleps", 9, TOKEN_INSN, 0, 0, I_VCMPNLEPS },
+        { "vcmpord_qps", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QPS },
+        { "vcmpordps", 9, TOKEN_INSN, 0, 0, I_VCMPORDPS },
+        { "vcmpeq_uqps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQPS },
+        { "vcmpnge_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USPS },
+        { "vcmpngeps", 9, TOKEN_INSN, 0, 0, I_VCMPNGEPS },
+        { "vcmpngt_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USPS },
+        { "vcmpngtps", 9, TOKEN_INSN, 0, 0, I_VCMPNGTPS },
+        { "vcmpfalse_oqps", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQPS },
+        { "vcmpfalseps", 11, TOKEN_INSN, 0, 0, I_VCMPFALSEPS },
+        { "vcmpneq_oqps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQPS },
+        { "vcmpge_osps", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSPS },
+        { "vcmpgeps", 8, TOKEN_INSN, 0, 0, I_VCMPGEPS },
+        { "vcmpgt_osps", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSPS },
+        { "vcmpgtps", 8, TOKEN_INSN, 0, 0, I_VCMPGTPS },
+        { "vcmptrue_uqps", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQPS },
+        { "vcmptrueps", 10, TOKEN_INSN, 0, 0, I_VCMPTRUEPS },
+        { "vcmplt_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQPS },
+        { "vcmple_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQPS },
+        { "vcmpunord_sps", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SPS },
+        { "vcmpneq_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USPS },
+        { "vcmpnlt_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQPS },
+        { "vcmpnle_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQPS },
+        { "vcmpord_sps", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SPS },
+        { "vcmpeq_usps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USPS },
+        { "vcmpnge_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQPS },
+        { "vcmpngt_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQPS },
+        { "vcmpfalse_osps", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSPS },
+        { "vcmpneq_osps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSPS },
+        { "vcmpge_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQPS },
+        { "vcmpgt_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQPS },
+        { "vcmptrue_usps", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USPS },
+        { "vcmpps", 6, TOKEN_INSN, 0, 0, I_VCMPPS },
+        { "vcmpeq_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSSD },
+        { "vcmpeqsd", 8, TOKEN_INSN, 0, 0, I_VCMPEQSD },
+        { "vcmplt_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSSD },
+        { "vcmpltsd", 8, TOKEN_INSN, 0, 0, I_VCMPLTSD },
+        { "vcmple_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSSD },
+        { "vcmplesd", 8, TOKEN_INSN, 0, 0, I_VCMPLESD },
+        { "vcmpunord_qsd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QSD },
+        { "vcmpunordsd", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDSD },
+        { "vcmpneq_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQSD },
+        { "vcmpneqsd", 9, TOKEN_INSN, 0, 0, I_VCMPNEQSD },
+        { "vcmpnlt_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USSD },
+        { "vcmpnltsd", 9, TOKEN_INSN, 0, 0, I_VCMPNLTSD },
+        { "vcmpnle_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USSD },
+        { "vcmpnlesd", 9, TOKEN_INSN, 0, 0, I_VCMPNLESD },
+        { "vcmpord_qsd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QSD },
+        { "vcmpordsd", 9, TOKEN_INSN, 0, 0, I_VCMPORDSD },
+        { "vcmpeq_uqsd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQSD },
+        { "vcmpnge_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USSD },
+        { "vcmpngesd", 9, TOKEN_INSN, 0, 0, I_VCMPNGESD },
+        { "vcmpngt_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USSD },
+        { "vcmpngtsd", 9, TOKEN_INSN, 0, 0, I_VCMPNGTSD },
+        { "vcmpfalse_oqsd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQSD },
+        { "vcmpfalsesd", 11, TOKEN_INSN, 0, 0, I_VCMPFALSESD },
+        { "vcmpneq_oqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQSD },
+        { "vcmpge_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSSD },
+        { "vcmpgesd", 8, TOKEN_INSN, 0, 0, I_VCMPGESD },
+        { "vcmpgt_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSSD },
+        { "vcmpgtsd", 8, TOKEN_INSN, 0, 0, I_VCMPGTSD },
+        { "vcmptrue_uqsd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQSD },
+        { "vcmptruesd", 10, TOKEN_INSN, 0, 0, I_VCMPTRUESD },
+        { "vcmplt_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQSD },
+        { "vcmple_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQSD },
+        { "vcmpunord_ssd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SSD },
+        { "vcmpneq_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USSD },
+        { "vcmpnlt_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQSD },
+        { "vcmpnle_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQSD },
+        { "vcmpord_ssd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SSD },
+        { "vcmpeq_ussd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USSD },
+        { "vcmpnge_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQSD },
+        { "vcmpngt_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQSD },
+        { "vcmpfalse_ossd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSSD },
+        { "vcmpneq_ossd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSSD },
+        { "vcmpge_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQSD },
+        { "vcmpgt_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQSD },
+        { "vcmptrue_ussd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USSD },
+        { "vcmpsd", 6, TOKEN_INSN, 0, 0, I_VCMPSD },
+        { "vcmpeq_osss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSSS },
+        { "vcmpeqss", 8, TOKEN_INSN, 0, 0, I_VCMPEQSS },
+        { "vcmplt_osss", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSSS },
+        { "vcmpltss", 8, TOKEN_INSN, 0, 0, I_VCMPLTSS },
+        { "vcmple_osss", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSSS },
+        { "vcmpless", 8, TOKEN_INSN, 0, 0, I_VCMPLESS },
+        { "vcmpunord_qss", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QSS },
+        { "vcmpunordss", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDSS },
+        { "vcmpneq_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQSS },
+        { "vcmpneqss", 9, TOKEN_INSN, 0, 0, I_VCMPNEQSS },
+        { "vcmpnlt_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USSS },
+        { "vcmpnltss", 9, TOKEN_INSN, 0, 0, I_VCMPNLTSS },
+        { "vcmpnle_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USSS },
+        { "vcmpnless", 9, TOKEN_INSN, 0, 0, I_VCMPNLESS },
+        { "vcmpord_qss", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QSS },
+        { "vcmpordss", 9, TOKEN_INSN, 0, 0, I_VCMPORDSS },
+        { "vcmpeq_uqss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQSS },
+        { "vcmpnge_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USSS },
+        { "vcmpngess", 9, TOKEN_INSN, 0, 0, I_VCMPNGESS },
+        { "vcmpngt_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USSS },
+        { "vcmpngtss", 9, TOKEN_INSN, 0, 0, I_VCMPNGTSS },
+        { "vcmpfalse_oqss", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQSS },
+        { "vcmpfalsess", 11, TOKEN_INSN, 0, 0, I_VCMPFALSESS },
+        { "vcmpneq_oqss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQSS },
+        { "vcmpge_osss", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSSS },
+        { "vcmpgess", 8, TOKEN_INSN, 0, 0, I_VCMPGESS },
+        { "vcmpgt_osss", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSSS },
+        { "vcmpgtss", 8, TOKEN_INSN, 0, 0, I_VCMPGTSS },
+        { "vcmptrue_uqss", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQSS },
+        { "vcmptruess", 10, TOKEN_INSN, 0, 0, I_VCMPTRUESS },
+        { "vcmplt_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQSS },
+        { "vcmple_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQSS },
+        { "vcmpunord_sss", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SSS },
+        { "vcmpneq_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USSS },
+        { "vcmpnlt_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQSS },
+        { "vcmpnle_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQSS },
+        { "vcmpord_sss", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SSS },
+        { "vcmpeq_usss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USSS },
+        { "vcmpnge_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQSS },
+        { "vcmpngt_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQSS },
+        { "vcmpfalse_osss", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSSS },
+        { "vcmpneq_osss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSSS },
+        { "vcmpge_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQSS },
+        { "vcmpgt_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQSS },
+        { "vcmptrue_usss", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USSS },
+        { "vcmpss", 6, TOKEN_INSN, 0, 0, I_VCMPSS },
+        { "vcomisd", 7, TOKEN_INSN, 0, 0, I_VCOMISD },
+        { "vcomiss", 7, TOKEN_INSN, 0, 0, I_VCOMISS },
+        { "vcvtdq2pd", 9, TOKEN_INSN, 0, 0, I_VCVTDQ2PD },
+        { "vcvtdq2ps", 9, TOKEN_INSN, 0, 0, I_VCVTDQ2PS },
+        { "vcvtpd2dq", 9, TOKEN_INSN, 0, 0, I_VCVTPD2DQ },
+        { "vcvtpd2ps", 9, TOKEN_INSN, 0, 0, I_VCVTPD2PS },
+        { "vcvtps2dq", 9, TOKEN_INSN, 0, 0, I_VCVTPS2DQ },
+        { "vcvtps2pd", 9, TOKEN_INSN, 0, 0, I_VCVTPS2PD },
+        { "vcvtsd2si", 9, TOKEN_INSN, 0, 0, I_VCVTSD2SI },
+        { "vcvtsd2ss", 9, TOKEN_INSN, 0, 0, I_VCVTSD2SS },
+        { "vcvtsi2sd", 9, TOKEN_INSN, 0, 0, I_VCVTSI2SD },
+        { "vcvtsi2ss", 9, TOKEN_INSN, 0, 0, I_VCVTSI2SS },
+        { "vcvtss2sd", 9, TOKEN_INSN, 0, 0, I_VCVTSS2SD },
+        { "vcvtss2si", 9, TOKEN_INSN, 0, 0, I_VCVTSS2SI },
+        { "vcvttpd2dq", 10, TOKEN_INSN, 0, 0, I_VCVTTPD2DQ },
+        { "vcvttps2dq", 10, TOKEN_INSN, 0, 0, I_VCVTTPS2DQ },
+        { "vcvttsd2si", 10, TOKEN_INSN, 0, 0, I_VCVTTSD2SI },
+        { "vcvttss2si", 10, TOKEN_INSN, 0, 0, I_VCVTTSS2SI },
+        { "vdivpd", 6, TOKEN_INSN, 0, 0, I_VDIVPD },
+        { "vdivps", 6, TOKEN_INSN, 0, 0, I_VDIVPS },
+        { "vdivsd", 6, TOKEN_INSN, 0, 0, I_VDIVSD },
+        { "vdivss", 6, TOKEN_INSN, 0, 0, I_VDIVSS },
+        { "vdppd", 5, TOKEN_INSN, 0, 0, I_VDPPD },
+        { "vdpps", 5, TOKEN_INSN, 0, 0, I_VDPPS },
+        { "vextractf128", 12, TOKEN_INSN, 0, 0, I_VEXTRACTF128 },
+        { "vextractps", 10, TOKEN_INSN, 0, 0, I_VEXTRACTPS },
+        { "vhaddpd", 7, TOKEN_INSN, 0, 0, I_VHADDPD },
+        { "vhaddps", 7, TOKEN_INSN, 0, 0, I_VHADDPS },
+        { "vhsubpd", 7, TOKEN_INSN, 0, 0, I_VHSUBPD },
+        { "vhsubps", 7, TOKEN_INSN, 0, 0, I_VHSUBPS },
+        { "vinsertf128", 11, TOKEN_INSN, 0, 0, I_VINSERTF128 },
+        { "vinsertps", 9, TOKEN_INSN, 0, 0, I_VINSERTPS },
+        { "vlddqu", 6, TOKEN_INSN, 0, 0, I_VLDDQU },
+        { "vldqqu", 6, TOKEN_INSN, 0, 0, I_VLDQQU },
+        { "vldmxcsr", 8, TOKEN_INSN, 0, 0, I_VLDMXCSR },
+        { "vmaskmovdqu", 11, TOKEN_INSN, 0, 0, I_VMASKMOVDQU },
+        { "vmaskmovps", 10, TOKEN_INSN, 0, 0, I_VMASKMOVPS },
+        { "vmaskmovpd", 10, TOKEN_INSN, 0, 0, I_VMASKMOVPD },
+        { "vmaxpd", 6, TOKEN_INSN, 0, 0, I_VMAXPD },
+        { "vmaxps", 6, TOKEN_INSN, 0, 0, I_VMAXPS },
+        { "vmaxsd", 6, TOKEN_INSN, 0, 0, I_VMAXSD },
+        { "vmaxss", 6, TOKEN_INSN, 0, 0, I_VMAXSS },
+        { "vminpd", 6, TOKEN_INSN, 0, 0, I_VMINPD },
+        { "vminps", 6, TOKEN_INSN, 0, 0, I_VMINPS },
+        { "vminsd", 6, TOKEN_INSN, 0, 0, I_VMINSD },
+        { "vminss", 6, TOKEN_INSN, 0, 0, I_VMINSS },
+        { "vmovapd", 7, TOKEN_INSN, 0, 0, I_VMOVAPD },
+        { "vmovaps", 7, TOKEN_INSN, 0, 0, I_VMOVAPS },
+        { "vmovd", 5, TOKEN_INSN, 0, 0, I_VMOVD },
+        { "vmovq", 5, TOKEN_INSN, 0, 0, I_VMOVQ },
+        { "vmovddup", 8, TOKEN_INSN, 0, 0, I_VMOVDDUP },
+        { "vmovdqa", 7, TOKEN_INSN, 0, 0, I_VMOVDQA },
+        { "vmovqqa", 7, TOKEN_INSN, 0, 0, I_VMOVQQA },
+        { "vmovdqu", 7, TOKEN_INSN, 0, 0, I_VMOVDQU },
+        { "vmovqqu", 7, TOKEN_INSN, 0, 0, I_VMOVQQU },
+        { "vmovhlps", 8, TOKEN_INSN, 0, 0, I_VMOVHLPS },
+        { "vmovhpd", 7, TOKEN_INSN, 0, 0, I_VMOVHPD },
+        { "vmovhps", 7, TOKEN_INSN, 0, 0, I_VMOVHPS },
+        { "vmovlhps", 8, TOKEN_INSN, 0, 0, I_VMOVLHPS },
+        { "vmovlpd", 7, TOKEN_INSN, 0, 0, I_VMOVLPD },
+        { "vmovlps", 7, TOKEN_INSN, 0, 0, I_VMOVLPS },
+        { "vmovmskpd", 9, TOKEN_INSN, 0, 0, I_VMOVMSKPD },
+        { "vmovmskps", 9, TOKEN_INSN, 0, 0, I_VMOVMSKPS },
+        { "vmovntdq", 8, TOKEN_INSN, 0, 0, I_VMOVNTDQ },
+        { "vmovntqq", 8, TOKEN_INSN, 0, 0, I_VMOVNTQQ },
+        { "vmovntdqa", 9, TOKEN_INSN, 0, 0, I_VMOVNTDQA },
+        { "vmovntpd", 8, TOKEN_INSN, 0, 0, I_VMOVNTPD },
+        { "vmovntps", 8, TOKEN_INSN, 0, 0, I_VMOVNTPS },
+        { "vmovsd", 6, TOKEN_INSN, 0, 0, I_VMOVSD },
+        { "vmovshdup", 9, TOKEN_INSN, 0, 0, I_VMOVSHDUP },
+        { "vmovsldup", 9, TOKEN_INSN, 0, 0, I_VMOVSLDUP },
+        { "vmovss", 6, TOKEN_INSN, 0, 0, I_VMOVSS },
+        { "vmovupd", 7, TOKEN_INSN, 0, 0, I_VMOVUPD },
+        { "vmovups", 7, TOKEN_INSN, 0, 0, I_VMOVUPS },
+        { "vmpsadbw", 8, TOKEN_INSN, 0, 0, I_VMPSADBW },
+        { "vmulpd", 6, TOKEN_INSN, 0, 0, I_VMULPD },
+        { "vmulps", 6, TOKEN_INSN, 0, 0, I_VMULPS },
+        { "vmulsd", 6, TOKEN_INSN, 0, 0, I_VMULSD },
+        { "vmulss", 6, TOKEN_INSN, 0, 0, I_VMULSS },
+        { "vorpd", 5, TOKEN_INSN, 0, 0, I_VORPD },
+        { "vorps", 5, TOKEN_INSN, 0, 0, I_VORPS },
+        { "vpabsb", 6, TOKEN_INSN, 0, 0, I_VPABSB },
+        { "vpabsw", 6, TOKEN_INSN, 0, 0, I_VPABSW },
+        { "vpabsd", 6, TOKEN_INSN, 0, 0, I_VPABSD },
+        { "vpacksswb", 9, TOKEN_INSN, 0, 0, I_VPACKSSWB },
+        { "vpackssdw", 9, TOKEN_INSN, 0, 0, I_VPACKSSDW },
+        { "vpackuswb", 9, TOKEN_INSN, 0, 0, I_VPACKUSWB },
+        { "vpackusdw", 9, TOKEN_INSN, 0, 0, I_VPACKUSDW },
+        { "vpaddb", 6, TOKEN_INSN, 0, 0, I_VPADDB },
+        { "vpaddw", 6, TOKEN_INSN, 0, 0, I_VPADDW },
+        { "vpaddd", 6, TOKEN_INSN, 0, 0, I_VPADDD },
+        { "vpaddq", 6, TOKEN_INSN, 0, 0, I_VPADDQ },
+        { "vpaddsb", 7, TOKEN_INSN, 0, 0, I_VPADDSB },
+        { "vpaddsw", 7, TOKEN_INSN, 0, 0, I_VPADDSW },
+        { "vpaddusb", 8, TOKEN_INSN, 0, 0, I_VPADDUSB },
+        { "vpaddusw", 8, TOKEN_INSN, 0, 0, I_VPADDUSW },
+        { "vpalignr", 8, TOKEN_INSN, 0, 0, I_VPALIGNR },
+        { "vpand", 5, TOKEN_INSN, 0, 0, I_VPAND },
+        { "vpandn", 6, TOKEN_INSN, 0, 0, I_VPANDN },
+        { "vpavgb", 6, TOKEN_INSN, 0, 0, I_VPAVGB },
+        { "vpavgw", 6, TOKEN_INSN, 0, 0, I_VPAVGW },
+        { "vpblendvb", 9, TOKEN_INSN, 0, 0, I_VPBLENDVB },
+        { "vpblendw", 8, TOKEN_INSN, 0, 0, I_VPBLENDW },
+        { "vpcmpestri", 10, TOKEN_INSN, 0, 0, I_VPCMPESTRI },
+        { "vpcmpestrm", 10, TOKEN_INSN, 0, 0, I_VPCMPESTRM },
+        { "vpcmpistri", 10, TOKEN_INSN, 0, 0, I_VPCMPISTRI },
+        { "vpcmpistrm", 10, TOKEN_INSN, 0, 0, I_VPCMPISTRM },
+        { "vpcmpeqb", 8, TOKEN_INSN, 0, 0, I_VPCMPEQB },
+        { "vpcmpeqw", 8, TOKEN_INSN, 0, 0, I_VPCMPEQW },
+        { "vpcmpeqd", 8, TOKEN_INSN, 0, 0, I_VPCMPEQD },
+        { "vpcmpeqq", 8, TOKEN_INSN, 0, 0, I_VPCMPEQQ },
+        { "vpcmpgtb", 8, TOKEN_INSN, 0, 0, I_VPCMPGTB },
+        { "vpcmpgtw", 8, TOKEN_INSN, 0, 0, I_VPCMPGTW },
+        { "vpcmpgtd", 8, TOKEN_INSN, 0, 0, I_VPCMPGTD },
+        { "vpcmpgtq", 8, TOKEN_INSN, 0, 0, I_VPCMPGTQ },
+        { "vpermilpd", 9, TOKEN_INSN, 0, 0, I_VPERMILPD },
+        { "vpermilps", 9, TOKEN_INSN, 0, 0, I_VPERMILPS },
+        { "vperm2f128", 10, TOKEN_INSN, 0, 0, I_VPERM2F128 },
+        { "vpextrb", 7, TOKEN_INSN, 0, 0, I_VPEXTRB },
+        { "vpextrw", 7, TOKEN_INSN, 0, 0, I_VPEXTRW },
+        { "vpextrd", 7, TOKEN_INSN, 0, 0, I_VPEXTRD },
+        { "vpextrq", 7, TOKEN_INSN, 0, 0, I_VPEXTRQ },
+        { "vphaddw", 7, TOKEN_INSN, 0, 0, I_VPHADDW },
+        { "vphaddd", 7, TOKEN_INSN, 0, 0, I_VPHADDD },
+        { "vphaddsw", 8, TOKEN_INSN, 0, 0, I_VPHADDSW },
+        { "vphminposuw", 11, TOKEN_INSN, 0, 0, I_VPHMINPOSUW },
+        { "vphsubw", 7, TOKEN_INSN, 0, 0, I_VPHSUBW },
+        { "vphsubd", 7, TOKEN_INSN, 0, 0, I_VPHSUBD },
+        { "vphsubsw", 8, TOKEN_INSN, 0, 0, I_VPHSUBSW },
+        { "vpinsrb", 7, TOKEN_INSN, 0, 0, I_VPINSRB },
+        { "vpinsrw", 7, TOKEN_INSN, 0, 0, I_VPINSRW },
+        { "vpinsrd", 7, TOKEN_INSN, 0, 0, I_VPINSRD },
+        { "vpinsrq", 7, TOKEN_INSN, 0, 0, I_VPINSRQ },
+        { "vpmaddwd", 8, TOKEN_INSN, 0, 0, I_VPMADDWD },
+        { "vpmaddubsw", 10, TOKEN_INSN, 0, 0, I_VPMADDUBSW },
+        { "vpmaxsb", 7, TOKEN_INSN, 0, 0, I_VPMAXSB },
+        { "vpmaxsw", 7, TOKEN_INSN, 0, 0, I_VPMAXSW },
+        { "vpmaxsd", 7, TOKEN_INSN, 0, 0, I_VPMAXSD },
+        { "vpmaxub", 7, TOKEN_INSN, 0, 0, I_VPMAXUB },
+        { "vpmaxuw", 7, TOKEN_INSN, 0, 0, I_VPMAXUW },
+        { "vpmaxud", 7, TOKEN_INSN, 0, 0, I_VPMAXUD },
+        { "vpminsb", 7, TOKEN_INSN, 0, 0, I_VPMINSB },
+        { "vpminsw", 7, TOKEN_INSN, 0, 0, I_VPMINSW },
+        { "vpminsd", 7, TOKEN_INSN, 0, 0, I_VPMINSD },
+        { "vpminub", 7, TOKEN_INSN, 0, 0, I_VPMINUB },
+        { "vpminuw", 7, TOKEN_INSN, 0, 0, I_VPMINUW },
+        { "vpminud", 7, TOKEN_INSN, 0, 0, I_VPMINUD },
+        { "vpmovmskb", 9, TOKEN_INSN, 0, 0, I_VPMOVMSKB },
+        { "vpmovsxbw", 9, TOKEN_INSN, 0, 0, I_VPMOVSXBW },
+        { "vpmovsxbd", 9, TOKEN_INSN, 0, 0, I_VPMOVSXBD },
+        { "vpmovsxbq", 9, TOKEN_INSN, 0, 0, I_VPMOVSXBQ },
+        { "vpmovsxwd", 9, TOKEN_INSN, 0, 0, I_VPMOVSXWD },
+        { "vpmovsxwq", 9, TOKEN_INSN, 0, 0, I_VPMOVSXWQ },
+        { "vpmovsxdq", 9, TOKEN_INSN, 0, 0, I_VPMOVSXDQ },
+        { "vpmovzxbw", 9, TOKEN_INSN, 0, 0, I_VPMOVZXBW },
+        { "vpmovzxbd", 9, TOKEN_INSN, 0, 0, I_VPMOVZXBD },
+        { "vpmovzxbq", 9, TOKEN_INSN, 0, 0, I_VPMOVZXBQ },
+        { "vpmovzxwd", 9, TOKEN_INSN, 0, 0, I_VPMOVZXWD },
+        { "vpmovzxwq", 9, TOKEN_INSN, 0, 0, I_VPMOVZXWQ },
+        { "vpmovzxdq", 9, TOKEN_INSN, 0, 0, I_VPMOVZXDQ },
+        { "vpmulhuw", 8, TOKEN_INSN, 0, 0, I_VPMULHUW },
+        { "vpmulhrsw", 9, TOKEN_INSN, 0, 0, I_VPMULHRSW },
+        { "vpmulhw", 7, TOKEN_INSN, 0, 0, I_VPMULHW },
+        { "vpmullw", 7, TOKEN_INSN, 0, 0, I_VPMULLW },
+        { "vpmulld", 7, TOKEN_INSN, 0, 0, I_VPMULLD },
+        { "vpmuludq", 8, TOKEN_INSN, 0, 0, I_VPMULUDQ },
+        { "vpmuldq", 7, TOKEN_INSN, 0, 0, I_VPMULDQ },
+        { "vpor", 4, TOKEN_INSN, 0, 0, I_VPOR },
+        { "vpsadbw", 7, TOKEN_INSN, 0, 0, I_VPSADBW },
+        { "vpshufb", 7, TOKEN_INSN, 0, 0, I_VPSHUFB },
+        { "vpshufd", 7, TOKEN_INSN, 0, 0, I_VPSHUFD },
+        { "vpshufhw", 8, TOKEN_INSN, 0, 0, I_VPSHUFHW },
+        { "vpshuflw", 8, TOKEN_INSN, 0, 0, I_VPSHUFLW },
+        { "vpsignb", 7, TOKEN_INSN, 0, 0, I_VPSIGNB },
+        { "vpsignw", 7, TOKEN_INSN, 0, 0, I_VPSIGNW },
+        { "vpsignd", 7, TOKEN_INSN, 0, 0, I_VPSIGND },
+        { "vpslldq", 7, TOKEN_INSN, 0, 0, I_VPSLLDQ },
+        { "vpsrldq", 7, TOKEN_INSN, 0, 0, I_VPSRLDQ },
+        { "vpsllw", 6, TOKEN_INSN, 0, 0, I_VPSLLW },
+        { "vpslld", 6, TOKEN_INSN, 0, 0, I_VPSLLD },
+        { "vpsllq", 6, TOKEN_INSN, 0, 0, I_VPSLLQ },
+        { "vpsraw", 6, TOKEN_INSN, 0, 0, I_VPSRAW },
+        { "vpsrad", 6, TOKEN_INSN, 0, 0, I_VPSRAD },
+        { "vpsrlw", 6, TOKEN_INSN, 0, 0, I_VPSRLW },
+        { "vpsrld", 6, TOKEN_INSN, 0, 0, I_VPSRLD },
+        { "vpsrlq", 6, TOKEN_INSN, 0, 0, I_VPSRLQ },
+        { "vptest", 6, TOKEN_INSN, 0, 0, I_VPTEST },
+        { "vpsubb", 6, TOKEN_INSN, 0, 0, I_VPSUBB },
+        { "vpsubw", 6, TOKEN_INSN, 0, 0, I_VPSUBW },
+        { "vpsubd", 6, TOKEN_INSN, 0, 0, I_VPSUBD },
+        { "vpsubq", 6, TOKEN_INSN, 0, 0, I_VPSUBQ },
+        { "vpsubsb", 7, TOKEN_INSN, 0, 0, I_VPSUBSB },
+        { "vpsubsw", 7, TOKEN_INSN, 0, 0, I_VPSUBSW },
+        { "vpsubusb", 8, TOKEN_INSN, 0, 0, I_VPSUBUSB },
+        { "vpsubusw", 8, TOKEN_INSN, 0, 0, I_VPSUBUSW },
+        { "vpunpckhbw", 10, TOKEN_INSN, 0, 0, I_VPUNPCKHBW },
+        { "vpunpckhwd", 10, TOKEN_INSN, 0, 0, I_VPUNPCKHWD },
+        { "vpunpckhdq", 10, TOKEN_INSN, 0, 0, I_VPUNPCKHDQ },
+        { "vpunpckhqdq", 11, TOKEN_INSN, 0, 0, I_VPUNPCKHQDQ },
+        { "vpunpcklbw", 10, TOKEN_INSN, 0, 0, I_VPUNPCKLBW },
+        { "vpunpcklwd", 10, TOKEN_INSN, 0, 0, I_VPUNPCKLWD },
+        { "vpunpckldq", 10, TOKEN_INSN, 0, 0, I_VPUNPCKLDQ },
+        { "vpunpcklqdq", 11, TOKEN_INSN, 0, 0, I_VPUNPCKLQDQ },
+        { "vpxor", 5, TOKEN_INSN, 0, 0, I_VPXOR },
+        { "vrcpps", 6, TOKEN_INSN, 0, 0, I_VRCPPS },
+        { "vrcpss", 6, TOKEN_INSN, 0, 0, I_VRCPSS },
+        { "vrsqrtps", 8, TOKEN_INSN, 0, 0, I_VRSQRTPS },
+        { "vrsqrtss", 8, TOKEN_INSN, 0, 0, I_VRSQRTSS },
+        { "vroundpd", 8, TOKEN_INSN, 0, 0, I_VROUNDPD },
+        { "vroundps", 8, TOKEN_INSN, 0, 0, I_VROUNDPS },
+        { "vroundsd", 8, TOKEN_INSN, 0, 0, I_VROUNDSD },
+        { "vroundss", 8, TOKEN_INSN, 0, 0, I_VROUNDSS },
+        { "vshufpd", 7, TOKEN_INSN, 0, 0, I_VSHUFPD },
+        { "vshufps", 7, TOKEN_INSN, 0, 0, I_VSHUFPS },
+        { "vsqrtpd", 7, TOKEN_INSN, 0, 0, I_VSQRTPD },
+        { "vsqrtps", 7, TOKEN_INSN, 0, 0, I_VSQRTPS },
+        { "vsqrtsd", 7, TOKEN_INSN, 0, 0, I_VSQRTSD },
+        { "vsqrtss", 7, TOKEN_INSN, 0, 0, I_VSQRTSS },
+        { "vstmxcsr", 8, TOKEN_INSN, 0, 0, I_VSTMXCSR },
+        { "vsubpd", 6, TOKEN_INSN, 0, 0, I_VSUBPD },
+        { "vsubps", 6, TOKEN_INSN, 0, 0, I_VSUBPS },
+        { "vsubsd", 6, TOKEN_INSN, 0, 0, I_VSUBSD },
+        { "vsubss", 6, TOKEN_INSN, 0, 0, I_VSUBSS },
+        { "vtestps", 7, TOKEN_INSN, 0, 0, I_VTESTPS },
+        { "vtestpd", 7, TOKEN_INSN, 0, 0, I_VTESTPD },
+        { "vucomisd", 8, TOKEN_INSN, 0, 0, I_VUCOMISD },
+        { "vucomiss", 8, TOKEN_INSN, 0, 0, I_VUCOMISS },
+        { "vunpckhpd", 9, TOKEN_INSN, 0, 0, I_VUNPCKHPD },
+        { "vunpckhps", 9, TOKEN_INSN, 0, 0, I_VUNPCKHPS },
+        { "vunpcklpd", 9, TOKEN_INSN, 0, 0, I_VUNPCKLPD },
+        { "vunpcklps", 9, TOKEN_INSN, 0, 0, I_VUNPCKLPS },
+        { "vxorpd", 6, TOKEN_INSN, 0, 0, I_VXORPD },
+        { "vxorps", 6, TOKEN_INSN, 0, 0, I_VXORPS },
+        { "vzeroall", 8, TOKEN_INSN, 0, 0, I_VZEROALL },
+        { "vzeroupper", 10, TOKEN_INSN, 0, 0, I_VZEROUPPER },
+        { "pclmullqlqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULLQLQDQ },
+        { "pclmulhqlqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULHQLQDQ },
+        { "pclmullqhqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULLQHQDQ },
+        { "pclmulhqhqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULHQHQDQ },
+        { "pclmulqdq", 9, TOKEN_INSN, 0, 0, I_PCLMULQDQ },
+        { "vpclmullqlqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULLQLQDQ },
+        { "vpclmulhqlqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULHQLQDQ },
+        { "vpclmullqhqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULLQHQDQ },
+        { "vpclmulhqhqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULHQHQDQ },
+        { "vpclmulqdq", 10, TOKEN_INSN, 0, 0, I_VPCLMULQDQ },
+        { "vfmadd132ps", 11, TOKEN_INSN, 0, 0, I_VFMADD132PS },
+        { "vfmadd132pd", 11, TOKEN_INSN, 0, 0, I_VFMADD132PD },
+        { "vfmadd312ps", 11, TOKEN_INSN, 0, 0, I_VFMADD312PS },
+        { "vfmadd312pd", 11, TOKEN_INSN, 0, 0, I_VFMADD312PD },
+        { "vfmadd213ps", 11, TOKEN_INSN, 0, 0, I_VFMADD213PS },
+        { "vfmadd213pd", 11, TOKEN_INSN, 0, 0, I_VFMADD213PD },
+        { "vfmadd123ps", 11, TOKEN_INSN, 0, 0, I_VFMADD123PS },
+        { "vfmadd123pd", 11, TOKEN_INSN, 0, 0, I_VFMADD123PD },
+        { "vfmadd231ps", 11, TOKEN_INSN, 0, 0, I_VFMADD231PS },
+        { "vfmadd231pd", 11, TOKEN_INSN, 0, 0, I_VFMADD231PD },
+        { "vfmadd321ps", 11, TOKEN_INSN, 0, 0, I_VFMADD321PS },
+        { "vfmadd321pd", 11, TOKEN_INSN, 0, 0, I_VFMADD321PD },
+        { "vfmaddsub132ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB132PS },
+        { "vfmaddsub132pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB132PD },
+        { "vfmaddsub312ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB312PS },
+        { "vfmaddsub312pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB312PD },
+        { "vfmaddsub213ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB213PS },
+        { "vfmaddsub213pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB213PD },
+        { "vfmaddsub123ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB123PS },
+        { "vfmaddsub123pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB123PD },
+        { "vfmaddsub231ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB231PS },
+        { "vfmaddsub231pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB231PD },
+        { "vfmaddsub321ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB321PS },
+        { "vfmaddsub321pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB321PD },
+        { "vfmsub132ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB132PS },
+        { "vfmsub132pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB132PD },
+        { "vfmsub312ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB312PS },
+        { "vfmsub312pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB312PD },
+        { "vfmsub213ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB213PS },
+        { "vfmsub213pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB213PD },
+        { "vfmsub123ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB123PS },
+        { "vfmsub123pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB123PD },
+        { "vfmsub231ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB231PS },
+        { "vfmsub231pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB231PD },
+        { "vfmsub321ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB321PS },
+        { "vfmsub321pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB321PD },
+        { "vfmsubadd132ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD132PS },
+        { "vfmsubadd132pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD132PD },
+        { "vfmsubadd312ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD312PS },
+        { "vfmsubadd312pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD312PD },
+        { "vfmsubadd213ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD213PS },
+        { "vfmsubadd213pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD213PD },
+        { "vfmsubadd123ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD123PS },
+        { "vfmsubadd123pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD123PD },
+        { "vfmsubadd231ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD231PS },
+        { "vfmsubadd231pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD231PD },
+        { "vfmsubadd321ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD321PS },
+        { "vfmsubadd321pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD321PD },
+        { "vfnmadd132ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD132PS },
+        { "vfnmadd132pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD132PD },
+        { "vfnmadd312ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD312PS },
+        { "vfnmadd312pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD312PD },
+        { "vfnmadd213ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD213PS },
+        { "vfnmadd213pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD213PD },
+        { "vfnmadd123ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD123PS },
+        { "vfnmadd123pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD123PD },
+        { "vfnmadd231ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD231PS },
+        { "vfnmadd231pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD231PD },
+        { "vfnmadd321ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD321PS },
+        { "vfnmadd321pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD321PD },
+        { "vfnmsub132ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132PS },
+        { "vfnmsub132pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132PD },
+        { "vfnmsub312ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312PS },
+        { "vfnmsub312pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312PD },
+        { "vfnmsub213ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213PS },
+        { "vfnmsub213pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213PD },
+        { "vfnmsub123ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123PS },
+        { "vfnmsub123pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123PD },
+        { "vfnmsub231ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231PS },
+        { "vfnmsub231pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231PD },
+        { "vfnmsub321ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321PS },
+        { "vfnmsub321pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321PD },
+        { "vfmadd132ss", 11, TOKEN_INSN, 0, 0, I_VFMADD132SS },
+        { "vfmadd132sd", 11, TOKEN_INSN, 0, 0, I_VFMADD132SD },
+        { "vfmadd312ss", 11, TOKEN_INSN, 0, 0, I_VFMADD312SS },
+        { "vfmadd312sd", 11, TOKEN_INSN, 0, 0, I_VFMADD312SD },
+        { "vfmadd213ss", 11, TOKEN_INSN, 0, 0, I_VFMADD213SS },
+        { "vfmadd213sd", 11, TOKEN_INSN, 0, 0, I_VFMADD213SD },
+        { "vfmadd123ss", 11, TOKEN_INSN, 0, 0, I_VFMADD123SS },
+        { "vfmadd123sd", 11, TOKEN_INSN, 0, 0, I_VFMADD123SD },
+        { "vfmadd231ss", 11, TOKEN_INSN, 0, 0, I_VFMADD231SS },
+        { "vfmadd231sd", 11, TOKEN_INSN, 0, 0, I_VFMADD231SD },
+        { "vfmadd321ss", 11, TOKEN_INSN, 0, 0, I_VFMADD321SS },
+        { "vfmadd321sd", 11, TOKEN_INSN, 0, 0, I_VFMADD321SD },
+        { "vfmsub132ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB132SS },
+        { "vfmsub132sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB132SD },
+        { "vfmsub312ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB312SS },
+        { "vfmsub312sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB312SD },
+        { "vfmsub213ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB213SS },
+        { "vfmsub213sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB213SD },
+        { "vfmsub123ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB123SS },
+        { "vfmsub123sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB123SD },
+        { "vfmsub231ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB231SS },
+        { "vfmsub231sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB231SD },
+        { "vfmsub321ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB321SS },
+        { "vfmsub321sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB321SD },
+        { "vfnmadd132ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD132SS },
+        { "vfnmadd132sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD132SD },
+        { "vfnmadd312ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD312SS },
+        { "vfnmadd312sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD312SD },
+        { "vfnmadd213ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD213SS },
+        { "vfnmadd213sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD213SD },
+        { "vfnmadd123ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD123SS },
+        { "vfnmadd123sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD123SD },
+        { "vfnmadd231ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD231SS },
+        { "vfnmadd231sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD231SD },
+        { "vfnmadd321ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD321SS },
+        { "vfnmadd321sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD321SD },
+        { "vfnmsub132ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132SS },
+        { "vfnmsub132sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132SD },
+        { "vfnmsub312ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312SS },
+        { "vfnmsub312sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312SD },
+        { "vfnmsub213ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213SS },
+        { "vfnmsub213sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213SD },
+        { "vfnmsub123ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123SS },
+        { "vfnmsub123sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123SD },
+        { "vfnmsub231ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231SS },
+        { "vfnmsub231sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231SD },
+        { "vfnmsub321ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321SS },
+        { "vfnmsub321sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321SD },
+        { "rdfsbase", 8, TOKEN_INSN, 0, 0, I_RDFSBASE },
+        { "rdgsbase", 8, TOKEN_INSN, 0, 0, I_RDGSBASE },
+        { "rdrand", 6, TOKEN_INSN, 0, 0, I_RDRAND },
+        { "wrfsbase", 8, TOKEN_INSN, 0, 0, I_WRFSBASE },
+        { "wrgsbase", 8, TOKEN_INSN, 0, 0, I_WRGSBASE },
+        { "vcvtph2ps", 9, TOKEN_INSN, 0, 0, I_VCVTPH2PS },
+        { "vcvtps2ph", 9, TOKEN_INSN, 0, 0, I_VCVTPS2PH },
+        { "adcx", 4, TOKEN_INSN, 0, 0, I_ADCX },
+        { "adox", 4, TOKEN_INSN, 0, 0, I_ADOX },
+        { "rdseed", 6, TOKEN_INSN, 0, 0, I_RDSEED },
+        { "clac", 4, TOKEN_INSN, 0, 0, I_CLAC },
+        { "stac", 4, TOKEN_INSN, 0, 0, I_STAC },
+        { "xstore", 6, TOKEN_INSN, 0, 0, I_XSTORE },
+        { "xcryptecb", 9, TOKEN_INSN, 0, 0, I_XCRYPTECB },
+        { "xcryptcbc", 9, TOKEN_INSN, 0, 0, I_XCRYPTCBC },
+        { "xcryptctr", 9, TOKEN_INSN, 0, 0, I_XCRYPTCTR },
+        { "xcryptcfb", 9, TOKEN_INSN, 0, 0, I_XCRYPTCFB },
+        { "xcryptofb", 9, TOKEN_INSN, 0, 0, I_XCRYPTOFB },
+        { "montmul", 7, TOKEN_INSN, 0, 0, I_MONTMUL },
+        { "xsha1", 5, TOKEN_INSN, 0, 0, I_XSHA1 },
+        { "xsha256", 7, TOKEN_INSN, 0, 0, I_XSHA256 },
+        { "llwpcb", 6, TOKEN_INSN, 0, 0, I_LLWPCB },
+        { "slwpcb", 6, TOKEN_INSN, 0, 0, I_SLWPCB },
+        { "lwpval", 6, TOKEN_INSN, 0, 0, I_LWPVAL },
+        { "lwpins", 6, TOKEN_INSN, 0, 0, I_LWPINS },
+        { "vfmaddpd", 8, TOKEN_INSN, 0, 0, I_VFMADDPD },
+        { "vfmaddps", 8, TOKEN_INSN, 0, 0, I_VFMADDPS },
+        { "vfmaddsd", 8, TOKEN_INSN, 0, 0, I_VFMADDSD },
+        { "vfmaddss", 8, TOKEN_INSN, 0, 0, I_VFMADDSS },
+        { "vfmaddsubpd", 11, TOKEN_INSN, 0, 0, I_VFMADDSUBPD },
+        { "vfmaddsubps", 11, TOKEN_INSN, 0, 0, I_VFMADDSUBPS },
+        { "vfmsubaddpd", 11, TOKEN_INSN, 0, 0, I_VFMSUBADDPD },
+        { "vfmsubaddps", 11, TOKEN_INSN, 0, 0, I_VFMSUBADDPS },
+        { "vfmsubpd", 8, TOKEN_INSN, 0, 0, I_VFMSUBPD },
+        { "vfmsubps", 8, TOKEN_INSN, 0, 0, I_VFMSUBPS },
+        { "vfmsubsd", 8, TOKEN_INSN, 0, 0, I_VFMSUBSD },
+        { "vfmsubss", 8, TOKEN_INSN, 0, 0, I_VFMSUBSS },
+        { "vfnmaddpd", 9, TOKEN_INSN, 0, 0, I_VFNMADDPD },
+        { "vfnmaddps", 9, TOKEN_INSN, 0, 0, I_VFNMADDPS },
+        { "vfnmaddsd", 9, TOKEN_INSN, 0, 0, I_VFNMADDSD },
+        { "vfnmaddss", 9, TOKEN_INSN, 0, 0, I_VFNMADDSS },
+        { "vfnmsubpd", 9, TOKEN_INSN, 0, 0, I_VFNMSUBPD },
+        { "vfnmsubps", 9, TOKEN_INSN, 0, 0, I_VFNMSUBPS },
+        { "vfnmsubsd", 9, TOKEN_INSN, 0, 0, I_VFNMSUBSD },
+        { "vfnmsubss", 9, TOKEN_INSN, 0, 0, I_VFNMSUBSS },
+        { "vfrczpd", 7, TOKEN_INSN, 0, 0, I_VFRCZPD },
+        { "vfrczps", 7, TOKEN_INSN, 0, 0, I_VFRCZPS },
+        { "vfrczsd", 7, TOKEN_INSN, 0, 0, I_VFRCZSD },
+        { "vfrczss", 7, TOKEN_INSN, 0, 0, I_VFRCZSS },
+        { "vpcmov", 6, TOKEN_INSN, 0, 0, I_VPCMOV },
+        { "vpcomb", 6, TOKEN_INSN, 0, 0, I_VPCOMB },
+        { "vpcomd", 6, TOKEN_INSN, 0, 0, I_VPCOMD },
+        { "vpcomq", 6, TOKEN_INSN, 0, 0, I_VPCOMQ },
+        { "vpcomub", 7, TOKEN_INSN, 0, 0, I_VPCOMUB },
+        { "vpcomud", 7, TOKEN_INSN, 0, 0, I_VPCOMUD },
+        { "vpcomuq", 7, TOKEN_INSN, 0, 0, I_VPCOMUQ },
+        { "vpcomuw", 7, TOKEN_INSN, 0, 0, I_VPCOMUW },
+        { "vpcomw", 6, TOKEN_INSN, 0, 0, I_VPCOMW },
+        { "vphaddbd", 8, TOKEN_INSN, 0, 0, I_VPHADDBD },
+        { "vphaddbq", 8, TOKEN_INSN, 0, 0, I_VPHADDBQ },
+        { "vphaddbw", 8, TOKEN_INSN, 0, 0, I_VPHADDBW },
+        { "vphadddq", 8, TOKEN_INSN, 0, 0, I_VPHADDDQ },
+        { "vphaddubd", 9, TOKEN_INSN, 0, 0, I_VPHADDUBD },
+        { "vphaddubq", 9, TOKEN_INSN, 0, 0, I_VPHADDUBQ },
+        { "vphaddubw", 9, TOKEN_INSN, 0, 0, I_VPHADDUBW },
+        { "vphaddudq", 9, TOKEN_INSN, 0, 0, I_VPHADDUDQ },
+        { "vphadduwd", 9, TOKEN_INSN, 0, 0, I_VPHADDUWD },
+        { "vphadduwq", 9, TOKEN_INSN, 0, 0, I_VPHADDUWQ },
+        { "vphaddwd", 8, TOKEN_INSN, 0, 0, I_VPHADDWD },
+        { "vphaddwq", 8, TOKEN_INSN, 0, 0, I_VPHADDWQ },
+        { "vphsubbw", 8, TOKEN_INSN, 0, 0, I_VPHSUBBW },
+        { "vphsubdq", 8, TOKEN_INSN, 0, 0, I_VPHSUBDQ },
+        { "vphsubwd", 8, TOKEN_INSN, 0, 0, I_VPHSUBWD },
+        { "vpmacsdd", 8, TOKEN_INSN, 0, 0, I_VPMACSDD },
+        { "vpmacsdqh", 9, TOKEN_INSN, 0, 0, I_VPMACSDQH },
+        { "vpmacsdql", 9, TOKEN_INSN, 0, 0, I_VPMACSDQL },
+        { "vpmacssdd", 9, TOKEN_INSN, 0, 0, I_VPMACSSDD },
+        { "vpmacssdqh", 10, TOKEN_INSN, 0, 0, I_VPMACSSDQH },
+        { "vpmacssdql", 10, TOKEN_INSN, 0, 0, I_VPMACSSDQL },
+        { "vpmacsswd", 9, TOKEN_INSN, 0, 0, I_VPMACSSWD },
+        { "vpmacssww", 9, TOKEN_INSN, 0, 0, I_VPMACSSWW },
+        { "vpmacswd", 8, TOKEN_INSN, 0, 0, I_VPMACSWD },
+        { "vpmacsww", 8, TOKEN_INSN, 0, 0, I_VPMACSWW },
+        { "vpmadcsswd", 10, TOKEN_INSN, 0, 0, I_VPMADCSSWD },
+        { "vpmadcswd", 9, TOKEN_INSN, 0, 0, I_VPMADCSWD },
+        { "vpperm", 6, TOKEN_INSN, 0, 0, I_VPPERM },
+        { "vprotb", 6, TOKEN_INSN, 0, 0, I_VPROTB },
+        { "vprotd", 6, TOKEN_INSN, 0, 0, I_VPROTD },
+        { "vprotq", 6, TOKEN_INSN, 0, 0, I_VPROTQ },
+        { "vprotw", 6, TOKEN_INSN, 0, 0, I_VPROTW },
+        { "vpshab", 6, TOKEN_INSN, 0, 0, I_VPSHAB },
+        { "vpshad", 6, TOKEN_INSN, 0, 0, I_VPSHAD },
+        { "vpshaq", 6, TOKEN_INSN, 0, 0, I_VPSHAQ },
+        { "vpshaw", 6, TOKEN_INSN, 0, 0, I_VPSHAW },
+        { "vpshlb", 6, TOKEN_INSN, 0, 0, I_VPSHLB },
+        { "vpshld", 6, TOKEN_INSN, 0, 0, I_VPSHLD },
+        { "vpshlq", 6, TOKEN_INSN, 0, 0, I_VPSHLQ },
+        { "vpshlw", 6, TOKEN_INSN, 0, 0, I_VPSHLW },
+        { "vbroadcasti128", 14, TOKEN_INSN, 0, 0, I_VBROADCASTI128 },
+        { "vpblendd", 8, TOKEN_INSN, 0, 0, I_VPBLENDD },
+        { "vpbroadcastb", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTB },
+        { "vpbroadcastw", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTW },
+        { "vpbroadcastd", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTD },
+        { "vpbroadcastq", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTQ },
+        { "vpermd", 6, TOKEN_INSN, 0, 0, I_VPERMD },
+        { "vpermpd", 7, TOKEN_INSN, 0, 0, I_VPERMPD },
+        { "vpermps", 7, TOKEN_INSN, 0, 0, I_VPERMPS },
+        { "vpermq", 6, TOKEN_INSN, 0, 0, I_VPERMQ },
+        { "vperm2i128", 10, TOKEN_INSN, 0, 0, I_VPERM2I128 },
+        { "vextracti128", 12, TOKEN_INSN, 0, 0, I_VEXTRACTI128 },
+        { "vinserti128", 11, TOKEN_INSN, 0, 0, I_VINSERTI128 },
+        { "vpmaskmovd", 10, TOKEN_INSN, 0, 0, I_VPMASKMOVD },
+        { "vpmaskmovq", 10, TOKEN_INSN, 0, 0, I_VPMASKMOVQ },
+        { "vpsllvd", 7, TOKEN_INSN, 0, 0, I_VPSLLVD },
+        { "vpsllvq", 7, TOKEN_INSN, 0, 0, I_VPSLLVQ },
+        { "vpsravd", 7, TOKEN_INSN, 0, 0, I_VPSRAVD },
+        { "vpsrlvd", 7, TOKEN_INSN, 0, 0, I_VPSRLVD },
+        { "vpsrlvq", 7, TOKEN_INSN, 0, 0, I_VPSRLVQ },
+        { "vgatherdpd", 10, TOKEN_INSN, 0, 0, I_VGATHERDPD },
+        { "vgatherqpd", 10, TOKEN_INSN, 0, 0, I_VGATHERQPD },
+        { "vgatherdps", 10, TOKEN_INSN, 0, 0, I_VGATHERDPS },
+        { "vgatherqps", 10, TOKEN_INSN, 0, 0, I_VGATHERQPS },
+        { "vpgatherdd", 10, TOKEN_INSN, 0, 0, I_VPGATHERDD },
+        { "vpgatherqd", 10, TOKEN_INSN, 0, 0, I_VPGATHERQD },
+        { "vpgatherdq", 10, TOKEN_INSN, 0, 0, I_VPGATHERDQ },
+        { "vpgatherqq", 10, TOKEN_INSN, 0, 0, I_VPGATHERQQ },
+        { "xabort", 6, TOKEN_INSN, 0, 0, I_XABORT },
+        { "xbegin", 6, TOKEN_INSN, 0, 0, I_XBEGIN },
+        { "xend", 4, TOKEN_INSN, 0, 0, I_XEND },
+        { "xtest", 5, TOKEN_INSN, 0, 0, I_XTEST },
+        { "andn", 4, TOKEN_INSN, 0, 0, I_ANDN },
+        { "bextr", 5, TOKEN_INSN, 0, 0, I_BEXTR },
+        { "blci", 4, TOKEN_INSN, 0, 0, I_BLCI },
+        { "blcic", 5, TOKEN_INSN, 0, 0, I_BLCIC },
+        { "blsi", 4, TOKEN_INSN, 0, 0, I_BLSI },
+        { "blsic", 5, TOKEN_INSN, 0, 0, I_BLSIC },
+        { "blcfill", 7, TOKEN_INSN, 0, 0, I_BLCFILL },
+        { "blsfill", 7, TOKEN_INSN, 0, 0, I_BLSFILL },
+        { "blcmsk", 6, TOKEN_INSN, 0, 0, I_BLCMSK },
+        { "blsmsk", 6, TOKEN_INSN, 0, 0, I_BLSMSK },
+        { "blsr", 4, TOKEN_INSN, 0, 0, I_BLSR },
+        { "blcs", 4, TOKEN_INSN, 0, 0, I_BLCS },
+        { "bzhi", 4, TOKEN_INSN, 0, 0, I_BZHI },
+        { "mulx", 4, TOKEN_INSN, 0, 0, I_MULX },
+        { "pdep", 4, TOKEN_INSN, 0, 0, I_PDEP },
+        { "pext", 4, TOKEN_INSN, 0, 0, I_PEXT },
+        { "rorx", 4, TOKEN_INSN, 0, 0, I_RORX },
+        { "sarx", 4, TOKEN_INSN, 0, 0, I_SARX },
+        { "shlx", 4, TOKEN_INSN, 0, 0, I_SHLX },
+        { "shrx", 4, TOKEN_INSN, 0, 0, I_SHRX },
+        { "tzcnt", 5, TOKEN_INSN, 0, 0, I_TZCNT },
+        { "tzmsk", 5, TOKEN_INSN, 0, 0, I_TZMSK },
+        { "t1mskc", 6, TOKEN_INSN, 0, 0, I_T1MSKC },
+        { "prefetchwt1", 11, TOKEN_INSN, 0, 0, I_PREFETCHWT1 },
+        { "bndmk", 5, TOKEN_INSN, 0, 0, I_BNDMK },
+        { "bndcl", 5, TOKEN_INSN, 0, 0, I_BNDCL },
+        { "bndcu", 5, TOKEN_INSN, 0, 0, I_BNDCU },
+        { "bndcn", 5, TOKEN_INSN, 0, 0, I_BNDCN },
+        { "bndmov", 6, TOKEN_INSN, 0, 0, I_BNDMOV },
+        { "bndldx", 6, TOKEN_INSN, 0, 0, I_BNDLDX },
+        { "bndstx", 6, TOKEN_INSN, 0, 0, I_BNDSTX },
+        { "sha1msg1", 8, TOKEN_INSN, 0, 0, I_SHA1MSG1 },
+        { "sha1msg2", 8, TOKEN_INSN, 0, 0, I_SHA1MSG2 },
+        { "sha1nexte", 9, TOKEN_INSN, 0, 0, I_SHA1NEXTE },
+        { "sha1rnds4", 9, TOKEN_INSN, 0, 0, I_SHA1RNDS4 },
+        { "sha256msg1", 10, TOKEN_INSN, 0, 0, I_SHA256MSG1 },
+        { "sha256msg2", 10, TOKEN_INSN, 0, 0, I_SHA256MSG2 },
+        { "sha256rnds2", 11, TOKEN_INSN, 0, 0, I_SHA256RNDS2 },
+        { "vbcstnebf16ps", 13, TOKEN_INSN, 0, 0, I_VBCSTNEBF16PS },
+        { "vbcstnesh2ps", 12, TOKEN_INSN, 0, 0, I_VBCSTNESH2PS },
+        { "vcvtneebf162ps", 14, TOKEN_INSN, 0, 0, I_VCVTNEEBF162PS },
+        { "vcvtneeph2ps", 12, TOKEN_INSN, 0, 0, I_VCVTNEEPH2PS },
+        { "vcvtneobf162ps", 14, TOKEN_INSN, 0, 0, I_VCVTNEOBF162PS },
+        { "vcvtneoph2ps", 12, TOKEN_INSN, 0, 0, I_VCVTNEOPH2PS },
+        { "vcvtneps2bf16", 13, TOKEN_INSN, 0, 0, I_VCVTNEPS2BF16 },
+        { "vpdpbssd", 8, TOKEN_INSN, 0, 0, I_VPDPBSSD },
+        { "vpdpbssds", 9, TOKEN_INSN, 0, 0, I_VPDPBSSDS },
+        { "vpdpbsud", 8, TOKEN_INSN, 0, 0, I_VPDPBSUD },
+        { "vpdpbsuds", 9, TOKEN_INSN, 0, 0, I_VPDPBSUDS },
+        { "vpdpbuud", 8, TOKEN_INSN, 0, 0, I_VPDPBUUD },
+        { "vpdpbuuds", 9, TOKEN_INSN, 0, 0, I_VPDPBUUDS },
+        { "vpmadd52huq", 11, TOKEN_INSN, 0, 0, I_VPMADD52HUQ },
+        { "vpmadd52luq", 11, TOKEN_INSN, 0, 0, I_VPMADD52LUQ },
+        { "kaddb", 5, TOKEN_INSN, 0, 0, I_KADDB },
+        { "kaddd", 5, TOKEN_INSN, 0, 0, I_KADDD },
+        { "kaddq", 5, TOKEN_INSN, 0, 0, I_KADDQ },
+        { "kaddw", 5, TOKEN_INSN, 0, 0, I_KADDW },
+        { "kandb", 5, TOKEN_INSN, 0, 0, I_KANDB },
+        { "kandd", 5, TOKEN_INSN, 0, 0, I_KANDD },
+        { "kandnb", 6, TOKEN_INSN, 0, 0, I_KANDNB },
+        { "kandnd", 6, TOKEN_INSN, 0, 0, I_KANDND },
+        { "kandnq", 6, TOKEN_INSN, 0, 0, I_KANDNQ },
+        { "kandnw", 6, TOKEN_INSN, 0, 0, I_KANDNW },
+        { "kandq", 5, TOKEN_INSN, 0, 0, I_KANDQ },
+        { "kandw", 5, TOKEN_INSN, 0, 0, I_KANDW },
+        { "kmovb", 5, TOKEN_INSN, 0, 0, I_KMOVB },
+        { "kmovd", 5, TOKEN_INSN, 0, 0, I_KMOVD },
+        { "kmovq", 5, TOKEN_INSN, 0, 0, I_KMOVQ },
+        { "kmovw", 5, TOKEN_INSN, 0, 0, I_KMOVW },
+        { "knotb", 5, TOKEN_INSN, 0, 0, I_KNOTB },
+        { "knotd", 5, TOKEN_INSN, 0, 0, I_KNOTD },
+        { "knotq", 5, TOKEN_INSN, 0, 0, I_KNOTQ },
+        { "knotw", 5, TOKEN_INSN, 0, 0, I_KNOTW },
+        { "korb", 4, TOKEN_INSN, 0, 0, I_KORB },
+        { "kord", 4, TOKEN_INSN, 0, 0, I_KORD },
+        { "korq", 4, TOKEN_INSN, 0, 0, I_KORQ },
+        { "korw", 4, TOKEN_INSN, 0, 0, I_KORW },
+        { "kortestb", 8, TOKEN_INSN, 0, 0, I_KORTESTB },
+        { "kortestd", 8, TOKEN_INSN, 0, 0, I_KORTESTD },
+        { "kortestq", 8, TOKEN_INSN, 0, 0, I_KORTESTQ },
+        { "kortestw", 8, TOKEN_INSN, 0, 0, I_KORTESTW },
+        { "kshiftlb", 8, TOKEN_INSN, 0, 0, I_KSHIFTLB },
+        { "kshiftld", 8, TOKEN_INSN, 0, 0, I_KSHIFTLD },
+        { "kshiftlq", 8, TOKEN_INSN, 0, 0, I_KSHIFTLQ },
+        { "kshiftlw", 8, TOKEN_INSN, 0, 0, I_KSHIFTLW },
+        { "kshiftrb", 8, TOKEN_INSN, 0, 0, I_KSHIFTRB },
+        { "kshiftrd", 8, TOKEN_INSN, 0, 0, I_KSHIFTRD },
+        { "kshiftrq", 8, TOKEN_INSN, 0, 0, I_KSHIFTRQ },
+        { "kshiftrw", 8, TOKEN_INSN, 0, 0, I_KSHIFTRW },
+        { "ktestb", 6, TOKEN_INSN, 0, 0, I_KTESTB },
+        { "ktestd", 6, TOKEN_INSN, 0, 0, I_KTESTD },
+        { "ktestq", 6, TOKEN_INSN, 0, 0, I_KTESTQ },
+        { "ktestw", 6, TOKEN_INSN, 0, 0, I_KTESTW },
+        { "kunpckbw", 8, TOKEN_INSN, 0, 0, I_KUNPCKBW },
+        { "kunpckdq", 8, TOKEN_INSN, 0, 0, I_KUNPCKDQ },
+        { "kunpckwd", 8, TOKEN_INSN, 0, 0, I_KUNPCKWD },
+        { "kxnorb", 6, TOKEN_INSN, 0, 0, I_KXNORB },
+        { "kxnord", 6, TOKEN_INSN, 0, 0, I_KXNORD },
+        { "kxnorq", 6, TOKEN_INSN, 0, 0, I_KXNORQ },
+        { "kxnorw", 6, TOKEN_INSN, 0, 0, I_KXNORW },
+        { "kxorb", 5, TOKEN_INSN, 0, 0, I_KXORB },
+        { "kxord", 5, TOKEN_INSN, 0, 0, I_KXORD },
+        { "kxorq", 5, TOKEN_INSN, 0, 0, I_KXORQ },
+        { "kxorw", 5, TOKEN_INSN, 0, 0, I_KXORW },
+        { "kadd", 4, TOKEN_INSN, 0, 0, I_KADD },
+        { "kand", 4, TOKEN_INSN, 0, 0, I_KAND },
+        { "kandn", 5, TOKEN_INSN, 0, 0, I_KANDN },
+        { "kmov", 4, TOKEN_INSN, 0, 0, I_KMOV },
+        { "knot", 4, TOKEN_INSN, 0, 0, I_KNOT },
+        { "kor", 3, TOKEN_INSN, 0, 0, I_KOR },
+        { "kortest", 7, TOKEN_INSN, 0, 0, I_KORTEST },
+        { "kshiftl", 7, TOKEN_INSN, 0, 0, I_KSHIFTL },
+        { "kshiftr", 7, TOKEN_INSN, 0, 0, I_KSHIFTR },
+        { "ktest", 5, TOKEN_INSN, 0, 0, I_KTEST },
+        { "kunpck", 6, TOKEN_INSN, 0, 0, I_KUNPCK },
+        { "kxnor", 5, TOKEN_INSN, 0, 0, I_KXNOR },
+        { "kxor", 4, TOKEN_INSN, 0, 0, I_KXOR },
+        { "valignd", 7, TOKEN_INSN, 0, 0, I_VALIGND },
+        { "valignq", 7, TOKEN_INSN, 0, 0, I_VALIGNQ },
+        { "vblendmpd", 9, TOKEN_INSN, 0, 0, I_VBLENDMPD },
+        { "vblendmps", 9, TOKEN_INSN, 0, 0, I_VBLENDMPS },
+        { "vbroadcastf32x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF32X2 },
+        { "vbroadcastf32x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF32X4 },
+        { "vbroadcastf32x8", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF32X8 },
+        { "vbroadcastf64x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF64X2 },
+        { "vbroadcastf64x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF64X4 },
+        { "vbroadcasti32x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI32X2 },
+        { "vbroadcasti32x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI32X4 },
+        { "vbroadcasti32x8", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI32X8 },
+        { "vbroadcasti64x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI64X2 },
+        { "vbroadcasti64x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI64X4 },
+        { "vcmpeq_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQPD },
+        { "vcmpeq_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQPS },
+        { "vcmpeq_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQSD },
+        { "vcmpeq_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQSS },
+        { "vcompresspd", 11, TOKEN_INSN, 0, 0, I_VCOMPRESSPD },
+        { "vcompressps", 11, TOKEN_INSN, 0, 0, I_VCOMPRESSPS },
+        { "vcvtpd2qq", 9, TOKEN_INSN, 0, 0, I_VCVTPD2QQ },
+        { "vcvtpd2udq", 10, TOKEN_INSN, 0, 0, I_VCVTPD2UDQ },
+        { "vcvtpd2uqq", 10, TOKEN_INSN, 0, 0, I_VCVTPD2UQQ },
+        { "vcvtps2qq", 9, TOKEN_INSN, 0, 0, I_VCVTPS2QQ },
+        { "vcvtps2udq", 10, TOKEN_INSN, 0, 0, I_VCVTPS2UDQ },
+        { "vcvtps2uqq", 10, TOKEN_INSN, 0, 0, I_VCVTPS2UQQ },
+        { "vcvtqq2pd", 9, TOKEN_INSN, 0, 0, I_VCVTQQ2PD },
+        { "vcvtqq2ps", 9, TOKEN_INSN, 0, 0, I_VCVTQQ2PS },
+        { "vcvtsd2usi", 10, TOKEN_INSN, 0, 0, I_VCVTSD2USI },
+        { "vcvtss2usi", 10, TOKEN_INSN, 0, 0, I_VCVTSS2USI },
+        { "vcvttpd2qq", 10, TOKEN_INSN, 0, 0, I_VCVTTPD2QQ },
+        { "vcvttpd2udq", 11, TOKEN_INSN, 0, 0, I_VCVTTPD2UDQ },
+        { "vcvttpd2uqq", 11, TOKEN_INSN, 0, 0, I_VCVTTPD2UQQ },
+        { "vcvttps2qq", 10, TOKEN_INSN, 0, 0, I_VCVTTPS2QQ },
+        { "vcvttps2udq", 11, TOKEN_INSN, 0, 0, I_VCVTTPS2UDQ },
+        { "vcvttps2uqq", 11, TOKEN_INSN, 0, 0, I_VCVTTPS2UQQ },
+        { "vcvttsd2usi", 11, TOKEN_INSN, 0, 0, I_VCVTTSD2USI },
+        { "vcvttss2usi", 11, TOKEN_INSN, 0, 0, I_VCVTTSS2USI },
+        { "vcvtudq2pd", 10, TOKEN_INSN, 0, 0, I_VCVTUDQ2PD },
+        { "vcvtudq2ps", 10, TOKEN_INSN, 0, 0, I_VCVTUDQ2PS },
+        { "vcvtuqq2pd", 10, TOKEN_INSN, 0, 0, I_VCVTUQQ2PD },
+        { "vcvtuqq2ps", 10, TOKEN_INSN, 0, 0, I_VCVTUQQ2PS },
+        { "vcvtusi2sd", 10, TOKEN_INSN, 0, 0, I_VCVTUSI2SD },
+        { "vcvtusi2ss", 10, TOKEN_INSN, 0, 0, I_VCVTUSI2SS },
+        { "vdbpsadbw", 9, TOKEN_INSN, 0, 0, I_VDBPSADBW },
+        { "vexp2pd", 7, TOKEN_INSN, 0, 0, I_VEXP2PD },
+        { "vexp2ps", 7, TOKEN_INSN, 0, 0, I_VEXP2PS },
+        { "vexpandpd", 9, TOKEN_INSN, 0, 0, I_VEXPANDPD },
+        { "vexpandps", 9, TOKEN_INSN, 0, 0, I_VEXPANDPS },
+        { "vextractf32x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF32X4 },
+        { "vextractf32x8", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF32X8 },
+        { "vextractf64x2", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF64X2 },
+        { "vextractf64x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF64X4 },
+        { "vextracti32x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI32X4 },
+        { "vextracti32x8", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI32X8 },
+        { "vextracti64x2", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI64X2 },
+        { "vextracti64x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI64X4 },
+        { "vfixupimmpd", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMPD },
+        { "vfixupimmps", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMPS },
+        { "vfixupimmsd", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMSD },
+        { "vfixupimmss", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMSS },
+        { "vfpclasspd", 10, TOKEN_INSN, 0, 0, I_VFPCLASSPD },
+        { "vfpclassps", 10, TOKEN_INSN, 0, 0, I_VFPCLASSPS },
+        { "vfpclasssd", 10, TOKEN_INSN, 0, 0, I_VFPCLASSSD },
+        { "vfpclassss", 10, TOKEN_INSN, 0, 0, I_VFPCLASSSS },
+        { "vgatherpf0dpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0DPD },
+        { "vgatherpf0dps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0DPS },
+        { "vgatherpf0qpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0QPD },
+        { "vgatherpf0qps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0QPS },
+        { "vgatherpf1dpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1DPD },
+        { "vgatherpf1dps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1DPS },
+        { "vgatherpf1qpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1QPD },
+        { "vgatherpf1qps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1QPS },
+        { "vgetexppd", 9, TOKEN_INSN, 0, 0, I_VGETEXPPD },
+        { "vgetexpps", 9, TOKEN_INSN, 0, 0, I_VGETEXPPS },
+        { "vgetexpsd", 9, TOKEN_INSN, 0, 0, I_VGETEXPSD },
+        { "vgetexpss", 9, TOKEN_INSN, 0, 0, I_VGETEXPSS },
+        { "vgetmantpd", 10, TOKEN_INSN, 0, 0, I_VGETMANTPD },
+        { "vgetmantps", 10, TOKEN_INSN, 0, 0, I_VGETMANTPS },
+        { "vgetmantsd", 10, TOKEN_INSN, 0, 0, I_VGETMANTSD },
+        { "vgetmantss", 10, TOKEN_INSN, 0, 0, I_VGETMANTSS },
+        { "vinsertf32x4", 12, TOKEN_INSN, 0, 0, I_VINSERTF32X4 },
+        { "vinsertf32x8", 12, TOKEN_INSN, 0, 0, I_VINSERTF32X8 },
+        { "vinsertf64x2", 12, TOKEN_INSN, 0, 0, I_VINSERTF64X2 },
+        { "vinsertf64x4", 12, TOKEN_INSN, 0, 0, I_VINSERTF64X4 },
+        { "vinserti32x4", 12, TOKEN_INSN, 0, 0, I_VINSERTI32X4 },
+        { "vinserti32x8", 12, TOKEN_INSN, 0, 0, I_VINSERTI32X8 },
+        { "vinserti64x2", 12, TOKEN_INSN, 0, 0, I_VINSERTI64X2 },
+        { "vinserti64x4", 12, TOKEN_INSN, 0, 0, I_VINSERTI64X4 },
+        { "vmovdqa32", 9, TOKEN_INSN, 0, 0, I_VMOVDQA32 },
+        { "vmovdqa64", 9, TOKEN_INSN, 0, 0, I_VMOVDQA64 },
+        { "vmovdqu16", 9, TOKEN_INSN, 0, 0, I_VMOVDQU16 },
+        { "vmovdqu32", 9, TOKEN_INSN, 0, 0, I_VMOVDQU32 },
+        { "vmovdqu64", 9, TOKEN_INSN, 0, 0, I_VMOVDQU64 },
+        { "vmovdqu8", 8, TOKEN_INSN, 0, 0, I_VMOVDQU8 },
+        { "vpabsq", 6, TOKEN_INSN, 0, 0, I_VPABSQ },
+        { "vpandd", 6, TOKEN_INSN, 0, 0, I_VPANDD },
+        { "vpandnd", 7, TOKEN_INSN, 0, 0, I_VPANDND },
+        { "vpandnq", 7, TOKEN_INSN, 0, 0, I_VPANDNQ },
+        { "vpandq", 6, TOKEN_INSN, 0, 0, I_VPANDQ },
+        { "vpblendmb", 9, TOKEN_INSN, 0, 0, I_VPBLENDMB },
+        { "vpblendmd", 9, TOKEN_INSN, 0, 0, I_VPBLENDMD },
+        { "vpblendmq", 9, TOKEN_INSN, 0, 0, I_VPBLENDMQ },
+        { "vpblendmw", 9, TOKEN_INSN, 0, 0, I_VPBLENDMW },
+        { "vpbroadcastmb2q", 15, TOKEN_INSN, 0, 0, I_VPBROADCASTMB2Q },
+        { "vpbroadcastmw2d", 15, TOKEN_INSN, 0, 0, I_VPBROADCASTMW2D },
+        { "vpcmpequb", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUB },
+        { "vpcmpequd", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUD },
+        { "vpcmpequq", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUQ },
+        { "vpcmpequw", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUW },
+        { "vpcmpgeb", 8, TOKEN_INSN, 0, 0, I_VPCMPGEB },
+        { "vpcmpged", 8, TOKEN_INSN, 0, 0, I_VPCMPGED },
+        { "vpcmpgeq", 8, TOKEN_INSN, 0, 0, I_VPCMPGEQ },
+        { "vpcmpgeub", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUB },
+        { "vpcmpgeud", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUD },
+        { "vpcmpgeuq", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUQ },
+        { "vpcmpgeuw", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUW },
+        { "vpcmpgew", 8, TOKEN_INSN, 0, 0, I_VPCMPGEW },
+        { "vpcmpgtub", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUB },
+        { "vpcmpgtud", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUD },
+        { "vpcmpgtuq", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUQ },
+        { "vpcmpgtuw", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUW },
+        { "vpcmpleb", 8, TOKEN_INSN, 0, 0, I_VPCMPLEB },
+        { "vpcmpled", 8, TOKEN_INSN, 0, 0, I_VPCMPLED },
+        { "vpcmpleq", 8, TOKEN_INSN, 0, 0, I_VPCMPLEQ },
+        { "vpcmpleub", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUB },
+        { "vpcmpleud", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUD },
+        { "vpcmpleuq", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUQ },
+        { "vpcmpleuw", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUW },
+        { "vpcmplew", 8, TOKEN_INSN, 0, 0, I_VPCMPLEW },
+        { "vpcmpltb", 8, TOKEN_INSN, 0, 0, I_VPCMPLTB },
+        { "vpcmpltd", 8, TOKEN_INSN, 0, 0, I_VPCMPLTD },
+        { "vpcmpltq", 8, TOKEN_INSN, 0, 0, I_VPCMPLTQ },
+        { "vpcmpltub", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUB },
+        { "vpcmpltud", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUD },
+        { "vpcmpltuq", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUQ },
+        { "vpcmpltuw", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUW },
+        { "vpcmpltw", 8, TOKEN_INSN, 0, 0, I_VPCMPLTW },
+        { "vpcmpneqb", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQB },
+        { "vpcmpneqd", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQD },
+        { "vpcmpneqq", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQQ },
+        { "vpcmpnequb", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUB },
+        { "vpcmpnequd", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUD },
+        { "vpcmpnequq", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUQ },
+        { "vpcmpnequw", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUW },
+        { "vpcmpneqw", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQW },
+        { "vpcmpngtb", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTB },
+        { "vpcmpngtd", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTD },
+        { "vpcmpngtq", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTQ },
+        { "vpcmpngtub", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUB },
+        { "vpcmpngtud", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUD },
+        { "vpcmpngtuq", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUQ },
+        { "vpcmpngtuw", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUW },
+        { "vpcmpngtw", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTW },
+        { "vpcmpnleb", 9, TOKEN_INSN, 0, 0, I_VPCMPNLEB },
+        { "vpcmpnled", 9, TOKEN_INSN, 0, 0, I_VPCMPNLED },
+        { "vpcmpnleq", 9, TOKEN_INSN, 0, 0, I_VPCMPNLEQ },
+        { "vpcmpnleub", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUB },
+        { "vpcmpnleud", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUD },
+        { "vpcmpnleuq", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUQ },
+        { "vpcmpnleuw", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUW },
+        { "vpcmpnlew", 9, TOKEN_INSN, 0, 0, I_VPCMPNLEW },
+        { "vpcmpnltb", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTB },
+        { "vpcmpnltd", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTD },
+        { "vpcmpnltq", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTQ },
+        { "vpcmpnltub", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUB },
+        { "vpcmpnltud", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUD },
+        { "vpcmpnltuq", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUQ },
+        { "vpcmpnltuw", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUW },
+        { "vpcmpnltw", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTW },
+        { "vpcmpb", 6, TOKEN_INSN, 0, 0, I_VPCMPB },
+        { "vpcmpd", 6, TOKEN_INSN, 0, 0, I_VPCMPD },
+        { "vpcmpq", 6, TOKEN_INSN, 0, 0, I_VPCMPQ },
+        { "vpcmpub", 7, TOKEN_INSN, 0, 0, I_VPCMPUB },
+        { "vpcmpud", 7, TOKEN_INSN, 0, 0, I_VPCMPUD },
+        { "vpcmpuq", 7, TOKEN_INSN, 0, 0, I_VPCMPUQ },
+        { "vpcmpuw", 7, TOKEN_INSN, 0, 0, I_VPCMPUW },
+        { "vpcmpw", 6, TOKEN_INSN, 0, 0, I_VPCMPW },
+        { "vpcompressd", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSD },
+        { "vpcompressq", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSQ },
+        { "vpconflictd", 11, TOKEN_INSN, 0, 0, I_VPCONFLICTD },
+        { "vpconflictq", 11, TOKEN_INSN, 0, 0, I_VPCONFLICTQ },
+        { "vpermb", 6, TOKEN_INSN, 0, 0, I_VPERMB },
+        { "vpermi2b", 8, TOKEN_INSN, 0, 0, I_VPERMI2B },
+        { "vpermi2d", 8, TOKEN_INSN, 0, 0, I_VPERMI2D },
+        { "vpermi2pd", 9, TOKEN_INSN, 0, 0, I_VPERMI2PD },
+        { "vpermi2ps", 9, TOKEN_INSN, 0, 0, I_VPERMI2PS },
+        { "vpermi2q", 8, TOKEN_INSN, 0, 0, I_VPERMI2Q },
+        { "vpermi2w", 8, TOKEN_INSN, 0, 0, I_VPERMI2W },
+        { "vpermt2b", 8, TOKEN_INSN, 0, 0, I_VPERMT2B },
+        { "vpermt2d", 8, TOKEN_INSN, 0, 0, I_VPERMT2D },
+        { "vpermt2pd", 9, TOKEN_INSN, 0, 0, I_VPERMT2PD },
+        { "vpermt2ps", 9, TOKEN_INSN, 0, 0, I_VPERMT2PS },
+        { "vpermt2q", 8, TOKEN_INSN, 0, 0, I_VPERMT2Q },
+        { "vpermt2w", 8, TOKEN_INSN, 0, 0, I_VPERMT2W },
+        { "vpermw", 6, TOKEN_INSN, 0, 0, I_VPERMW },
+        { "vpexpandd", 9, TOKEN_INSN, 0, 0, I_VPEXPANDD },
+        { "vpexpandq", 9, TOKEN_INSN, 0, 0, I_VPEXPANDQ },
+        { "vplzcntd", 8, TOKEN_INSN, 0, 0, I_VPLZCNTD },
+        { "vplzcntq", 8, TOKEN_INSN, 0, 0, I_VPLZCNTQ },
+        { "vpmaxsq", 7, TOKEN_INSN, 0, 0, I_VPMAXSQ },
+        { "vpmaxuq", 7, TOKEN_INSN, 0, 0, I_VPMAXUQ },
+        { "vpminsq", 7, TOKEN_INSN, 0, 0, I_VPMINSQ },
+        { "vpminuq", 7, TOKEN_INSN, 0, 0, I_VPMINUQ },
+        { "vpmovb2m", 8, TOKEN_INSN, 0, 0, I_VPMOVB2M },
+        { "vpmovd2m", 8, TOKEN_INSN, 0, 0, I_VPMOVD2M },
+        { "vpmovdb", 7, TOKEN_INSN, 0, 0, I_VPMOVDB },
+        { "vpmovdw", 7, TOKEN_INSN, 0, 0, I_VPMOVDW },
+        { "vpmovm2b", 8, TOKEN_INSN, 0, 0, I_VPMOVM2B },
+        { "vpmovm2d", 8, TOKEN_INSN, 0, 0, I_VPMOVM2D },
+        { "vpmovm2q", 8, TOKEN_INSN, 0, 0, I_VPMOVM2Q },
+        { "vpmovm2w", 8, TOKEN_INSN, 0, 0, I_VPMOVM2W },
+        { "vpmovq2m", 8, TOKEN_INSN, 0, 0, I_VPMOVQ2M },
+        { "vpmovqb", 7, TOKEN_INSN, 0, 0, I_VPMOVQB },
+        { "vpmovqd", 7, TOKEN_INSN, 0, 0, I_VPMOVQD },
+        { "vpmovqw", 7, TOKEN_INSN, 0, 0, I_VPMOVQW },
+        { "vpmovsdb", 8, TOKEN_INSN, 0, 0, I_VPMOVSDB },
+        { "vpmovsdw", 8, TOKEN_INSN, 0, 0, I_VPMOVSDW },
+        { "vpmovsqb", 8, TOKEN_INSN, 0, 0, I_VPMOVSQB },
+        { "vpmovsqd", 8, TOKEN_INSN, 0, 0, I_VPMOVSQD },
+        { "vpmovsqw", 8, TOKEN_INSN, 0, 0, I_VPMOVSQW },
+        { "vpmovswb", 8, TOKEN_INSN, 0, 0, I_VPMOVSWB },
+        { "vpmovusdb", 9, TOKEN_INSN, 0, 0, I_VPMOVUSDB },
+        { "vpmovusdw", 9, TOKEN_INSN, 0, 0, I_VPMOVUSDW },
+        { "vpmovusqb", 9, TOKEN_INSN, 0, 0, I_VPMOVUSQB },
+        { "vpmovusqd", 9, TOKEN_INSN, 0, 0, I_VPMOVUSQD },
+        { "vpmovusqw", 9, TOKEN_INSN, 0, 0, I_VPMOVUSQW },
+        { "vpmovuswb", 9, TOKEN_INSN, 0, 0, I_VPMOVUSWB },
+        { "vpmovw2m", 8, TOKEN_INSN, 0, 0, I_VPMOVW2M },
+        { "vpmovwb", 7, TOKEN_INSN, 0, 0, I_VPMOVWB },
+        { "vpmullq", 7, TOKEN_INSN, 0, 0, I_VPMULLQ },
+        { "vpmultishiftqb", 14, TOKEN_INSN, 0, 0, I_VPMULTISHIFTQB },
+        { "vpord", 5, TOKEN_INSN, 0, 0, I_VPORD },
+        { "vporq", 5, TOKEN_INSN, 0, 0, I_VPORQ },
+        { "vprold", 6, TOKEN_INSN, 0, 0, I_VPROLD },
+        { "vprolq", 6, TOKEN_INSN, 0, 0, I_VPROLQ },
+        { "vprolvd", 7, TOKEN_INSN, 0, 0, I_VPROLVD },
+        { "vprolvq", 7, TOKEN_INSN, 0, 0, I_VPROLVQ },
+        { "vprord", 6, TOKEN_INSN, 0, 0, I_VPRORD },
+        { "vprorq", 6, TOKEN_INSN, 0, 0, I_VPRORQ },
+        { "vprorvd", 7, TOKEN_INSN, 0, 0, I_VPRORVD },
+        { "vprorvq", 7, TOKEN_INSN, 0, 0, I_VPRORVQ },
+        { "vpscatterdd", 11, TOKEN_INSN, 0, 0, I_VPSCATTERDD },
+        { "vpscatterdq", 11, TOKEN_INSN, 0, 0, I_VPSCATTERDQ },
+        { "vpscatterqd", 11, TOKEN_INSN, 0, 0, I_VPSCATTERQD },
+        { "vpscatterqq", 11, TOKEN_INSN, 0, 0, I_VPSCATTERQQ },
+        { "vpsllvw", 7, TOKEN_INSN, 0, 0, I_VPSLLVW },
+        { "vpsraq", 6, TOKEN_INSN, 0, 0, I_VPSRAQ },
+        { "vpsravq", 7, TOKEN_INSN, 0, 0, I_VPSRAVQ },
+        { "vpsravw", 7, TOKEN_INSN, 0, 0, I_VPSRAVW },
+        { "vpsrlvw", 7, TOKEN_INSN, 0, 0, I_VPSRLVW },
+        { "vpternlogd", 10, TOKEN_INSN, 0, 0, I_VPTERNLOGD },
+        { "vpternlogq", 10, TOKEN_INSN, 0, 0, I_VPTERNLOGQ },
+        { "vptestmb", 8, TOKEN_INSN, 0, 0, I_VPTESTMB },
+        { "vptestmd", 8, TOKEN_INSN, 0, 0, I_VPTESTMD },
+        { "vptestmq", 8, TOKEN_INSN, 0, 0, I_VPTESTMQ },
+        { "vptestmw", 8, TOKEN_INSN, 0, 0, I_VPTESTMW },
+        { "vptestnmb", 9, TOKEN_INSN, 0, 0, I_VPTESTNMB },
+        { "vptestnmd", 9, TOKEN_INSN, 0, 0, I_VPTESTNMD },
+        { "vptestnmq", 9, TOKEN_INSN, 0, 0, I_VPTESTNMQ },
+        { "vptestnmw", 9, TOKEN_INSN, 0, 0, I_VPTESTNMW },
+        { "vpxord", 6, TOKEN_INSN, 0, 0, I_VPXORD },
+        { "vpxorq", 6, TOKEN_INSN, 0, 0, I_VPXORQ },
+        { "vrangepd", 8, TOKEN_INSN, 0, 0, I_VRANGEPD },
+        { "vrangeps", 8, TOKEN_INSN, 0, 0, I_VRANGEPS },
+        { "vrangesd", 8, TOKEN_INSN, 0, 0, I_VRANGESD },
+        { "vrangess", 8, TOKEN_INSN, 0, 0, I_VRANGESS },
+        { "vrcp14pd", 8, TOKEN_INSN, 0, 0, I_VRCP14PD },
+        { "vrcp14ps", 8, TOKEN_INSN, 0, 0, I_VRCP14PS },
+        { "vrcp14sd", 8, TOKEN_INSN, 0, 0, I_VRCP14SD },
+        { "vrcp14ss", 8, TOKEN_INSN, 0, 0, I_VRCP14SS },
+        { "vrcp28pd", 8, TOKEN_INSN, 0, 0, I_VRCP28PD },
+        { "vrcp28ps", 8, TOKEN_INSN, 0, 0, I_VRCP28PS },
+        { "vrcp28sd", 8, TOKEN_INSN, 0, 0, I_VRCP28SD },
+        { "vrcp28ss", 8, TOKEN_INSN, 0, 0, I_VRCP28SS },
+        { "vreducepd", 9, TOKEN_INSN, 0, 0, I_VREDUCEPD },
+        { "vreduceps", 9, TOKEN_INSN, 0, 0, I_VREDUCEPS },
+        { "vreducesd", 9, TOKEN_INSN, 0, 0, I_VREDUCESD },
+        { "vreducess", 9, TOKEN_INSN, 0, 0, I_VREDUCESS },
+        { "vrndscalepd", 11, TOKEN_INSN, 0, 0, I_VRNDSCALEPD },
+        { "vrndscaleps", 11, TOKEN_INSN, 0, 0, I_VRNDSCALEPS },
+        { "vrndscalesd", 11, TOKEN_INSN, 0, 0, I_VRNDSCALESD },
+        { "vrndscaless", 11, TOKEN_INSN, 0, 0, I_VRNDSCALESS },
+        { "vrsqrt14pd", 10, TOKEN_INSN, 0, 0, I_VRSQRT14PD },
+        { "vrsqrt14ps", 10, TOKEN_INSN, 0, 0, I_VRSQRT14PS },
+        { "vrsqrt14sd", 10, TOKEN_INSN, 0, 0, I_VRSQRT14SD },
+        { "vrsqrt14ss", 10, TOKEN_INSN, 0, 0, I_VRSQRT14SS },
+        { "vrsqrt28pd", 10, TOKEN_INSN, 0, 0, I_VRSQRT28PD },
+        { "vrsqrt28ps", 10, TOKEN_INSN, 0, 0, I_VRSQRT28PS },
+        { "vrsqrt28sd", 10, TOKEN_INSN, 0, 0, I_VRSQRT28SD },
+        { "vrsqrt28ss", 10, TOKEN_INSN, 0, 0, I_VRSQRT28SS },
+        { "vscalefpd", 9, TOKEN_INSN, 0, 0, I_VSCALEFPD },
+        { "vscalefps", 9, TOKEN_INSN, 0, 0, I_VSCALEFPS },
+        { "vscalefsd", 9, TOKEN_INSN, 0, 0, I_VSCALEFSD },
+        { "vscalefss", 9, TOKEN_INSN, 0, 0, I_VSCALEFSS },
+        { "vscatterdpd", 11, TOKEN_INSN, 0, 0, I_VSCATTERDPD },
+        { "vscatterdps", 11, TOKEN_INSN, 0, 0, I_VSCATTERDPS },
+        { "vscatterpf0dpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0DPD },
+        { "vscatterpf0dps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0DPS },
+        { "vscatterpf0qpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0QPD },
+        { "vscatterpf0qps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0QPS },
+        { "vscatterpf1dpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1DPD },
+        { "vscatterpf1dps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1DPS },
+        { "vscatterpf1qpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1QPD },
+        { "vscatterpf1qps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1QPS },
+        { "vscatterqpd", 11, TOKEN_INSN, 0, 0, I_VSCATTERQPD },
+        { "vscatterqps", 11, TOKEN_INSN, 0, 0, I_VSCATTERQPS },
+        { "vshuff32x4", 10, TOKEN_INSN, 0, 0, I_VSHUFF32X4 },
+        { "vshuff64x2", 10, TOKEN_INSN, 0, 0, I_VSHUFF64X2 },
+        { "vshufi32x4", 10, TOKEN_INSN, 0, 0, I_VSHUFI32X4 },
+        { "vshufi64x2", 10, TOKEN_INSN, 0, 0, I_VSHUFI64X2 },
+        { "rdpkru", 6, TOKEN_INSN, 0, 0, I_RDPKRU },
+        { "wrpkru", 6, TOKEN_INSN, 0, 0, I_WRPKRU },
+        { "rdpid", 5, TOKEN_INSN, 0, 0, I_RDPID },
+        { "clflushopt", 10, TOKEN_INSN, 0, 0, I_CLFLUSHOPT },
+        { "clwb", 4, TOKEN_INSN, 0, 0, I_CLWB },
+        { "pcommit", 7, TOKEN_INSN, 0, 0, I_PCOMMIT },
+        { "clzero", 6, TOKEN_INSN, 0, 0, I_CLZERO },
+        { "ptwrite", 7, TOKEN_INSN, 0, 0, I_PTWRITE },
+        { "cldemote", 8, TOKEN_INSN, 0, 0, I_CLDEMOTE },
+        { "movdiri", 7, TOKEN_INSN, 0, 0, I_MOVDIRI },
+        { "movdir64b", 9, TOKEN_INSN, 0, 0, I_MOVDIR64B },
+        { "pconfig", 7, TOKEN_INSN, 0, 0, I_PCONFIG },
+        { "tpause", 6, TOKEN_INSN, 0, 0, I_TPAUSE },
+        { "umonitor", 8, TOKEN_INSN, 0, 0, I_UMONITOR },
+        { "umwait", 6, TOKEN_INSN, 0, 0, I_UMWAIT },
+        { "wbnoinvd", 8, TOKEN_INSN, 0, 0, I_WBNOINVD },
+        { "gf2p8affineinvqb", 16, TOKEN_INSN, 0, 0, I_GF2P8AFFINEINVQB },
+        { "vgf2p8affineinvqb", 17, TOKEN_INSN, 0, 0, I_VGF2P8AFFINEINVQB },
+        { "gf2p8affineqb", 13, TOKEN_INSN, 0, 0, I_GF2P8AFFINEQB },
+        { "vgf2p8affineqb", 14, TOKEN_INSN, 0, 0, I_VGF2P8AFFINEQB },
+        { "gf2p8mulb", 9, TOKEN_INSN, 0, 0, I_GF2P8MULB },
+        { "vgf2p8mulb", 10, TOKEN_INSN, 0, 0, I_VGF2P8MULB },
+        { "vpcompressb", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSB },
+        { "vpcompressw", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSW },
+        { "vpexpandb", 9, TOKEN_INSN, 0, 0, I_VPEXPANDB },
+        { "vpexpandw", 9, TOKEN_INSN, 0, 0, I_VPEXPANDW },
+        { "vpshldw", 7, TOKEN_INSN, 0, 0, I_VPSHLDW },
+        { "vpshldd", 7, TOKEN_INSN, 0, 0, I_VPSHLDD },
+        { "vpshldq", 7, TOKEN_INSN, 0, 0, I_VPSHLDQ },
+        { "vpshldvw", 8, TOKEN_INSN, 0, 0, I_VPSHLDVW },
+        { "vpshldvd", 8, TOKEN_INSN, 0, 0, I_VPSHLDVD },
+        { "vpshldvq", 8, TOKEN_INSN, 0, 0, I_VPSHLDVQ },
+        { "vpshrdw", 7, TOKEN_INSN, 0, 0, I_VPSHRDW },
+        { "vpshrdd", 7, TOKEN_INSN, 0, 0, I_VPSHRDD },
+        { "vpshrdq", 7, TOKEN_INSN, 0, 0, I_VPSHRDQ },
+        { "vpshrdvw", 8, TOKEN_INSN, 0, 0, I_VPSHRDVW },
+        { "vpshrdvd", 8, TOKEN_INSN, 0, 0, I_VPSHRDVD },
+        { "vpshrdvq", 8, TOKEN_INSN, 0, 0, I_VPSHRDVQ },
+        { "vpdpbusd", 8, TOKEN_INSN, 0, 0, I_VPDPBUSD },
+        { "vpdpbusds", 9, TOKEN_INSN, 0, 0, I_VPDPBUSDS },
+        { "vpdpwssd", 8, TOKEN_INSN, 0, 0, I_VPDPWSSD },
+        { "vpdpwssds", 9, TOKEN_INSN, 0, 0, I_VPDPWSSDS },
+        { "vpopcntb", 8, TOKEN_INSN, 0, 0, I_VPOPCNTB },
+        { "vpopcntw", 8, TOKEN_INSN, 0, 0, I_VPOPCNTW },
+        { "vpopcntd", 8, TOKEN_INSN, 0, 0, I_VPOPCNTD },
+        { "vpopcntq", 8, TOKEN_INSN, 0, 0, I_VPOPCNTQ },
+        { "vpshufbitqmb", 12, TOKEN_INSN, 0, 0, I_VPSHUFBITQMB },
+        { "v4fmaddps", 9, TOKEN_INSN, 0, 0, I_V4FMADDPS },
+        { "v4fnmaddps", 10, TOKEN_INSN, 0, 0, I_V4FNMADDPS },
+        { "v4fmaddss", 9, TOKEN_INSN, 0, 0, I_V4FMADDSS },
+        { "v4fnmaddss", 10, TOKEN_INSN, 0, 0, I_V4FNMADDSS },
+        { "v4dpwssds", 9, TOKEN_INSN, 0, 0, I_V4DPWSSDS },
+        { "v4dpwssd", 8, TOKEN_INSN, 0, 0, I_V4DPWSSD },
+        { "encls", 5, TOKEN_INSN, 0, 0, I_ENCLS },
+        { "enclu", 5, TOKEN_INSN, 0, 0, I_ENCLU },
+        { "enclv", 5, TOKEN_INSN, 0, 0, I_ENCLV },
+        { "clrssbsy", 8, TOKEN_INSN, 0, 0, I_CLRSSBSY },
+        { "endbr32", 7, TOKEN_INSN, 0, 0, I_ENDBR32 },
+        { "endbr64", 7, TOKEN_INSN, 0, 0, I_ENDBR64 },
+        { "incsspd", 7, TOKEN_INSN, 0, 0, I_INCSSPD },
+        { "incsspq", 7, TOKEN_INSN, 0, 0, I_INCSSPQ },
+        { "rdsspd", 6, TOKEN_INSN, 0, 0, I_RDSSPD },
+        { "rdsspq", 6, TOKEN_INSN, 0, 0, I_RDSSPQ },
+        { "rstorssp", 8, TOKEN_INSN, 0, 0, I_RSTORSSP },
+        { "saveprevssp", 11, TOKEN_INSN, 0, 0, I_SAVEPREVSSP },
+        { "setssbsy", 8, TOKEN_INSN, 0, 0, I_SETSSBSY },
+        { "wrussd", 6, TOKEN_INSN, 0, 0, I_WRUSSD },
+        { "wrussq", 6, TOKEN_INSN, 0, 0, I_WRUSSQ },
+        { "wrssd", 5, TOKEN_INSN, 0, 0, I_WRSSD },
+        { "wrssq", 5, TOKEN_INSN, 0, 0, I_WRSSQ },
+        { "enqcmd", 6, TOKEN_INSN, 0, 0, I_ENQCMD },
+        { "enqcmds", 7, TOKEN_INSN, 0, 0, I_ENQCMDS },
+        { "serialize", 9, TOKEN_INSN, 0, 0, I_SERIALIZE },
+        { "xresldtrk", 9, TOKEN_INSN, 0, 0, I_XRESLDTRK },
+        { "xsusldtrk", 9, TOKEN_INSN, 0, 0, I_XSUSLDTRK },
+        { "vcvtne2ps2bf16", 14, TOKEN_INSN, 0, 0, I_VCVTNE2PS2BF16 },
+        { "vdpbf16ps", 9, TOKEN_INSN, 0, 0, I_VDPBF16PS },
+        { "vp2intersectd", 13, TOKEN_INSN, 0, 0, I_VP2INTERSECTD },
+        { "ldtilecfg", 9, TOKEN_INSN, 0, 0, I_LDTILECFG },
+        { "sttilecfg", 9, TOKEN_INSN, 0, 0, I_STTILECFG },
+        { "tdpbf16ps", 9, TOKEN_INSN, 0, 0, I_TDPBF16PS },
+        { "tdpbssd", 7, TOKEN_INSN, 0, 0, I_TDPBSSD },
+        { "tdpbsud", 7, TOKEN_INSN, 0, 0, I_TDPBSUD },
+        { "tdpbusd", 7, TOKEN_INSN, 0, 0, I_TDPBUSD },
+        { "tdpbuud", 7, TOKEN_INSN, 0, 0, I_TDPBUUD },
+        { "tileloadd", 9, TOKEN_INSN, 0, 0, I_TILELOADD },
+        { "tileloaddt1", 11, TOKEN_INSN, 0, 0, I_TILELOADDT1 },
+        { "tilerelease", 11, TOKEN_INSN, 0, 0, I_TILERELEASE },
+        { "tilestored", 10, TOKEN_INSN, 0, 0, I_TILESTORED },
+        { "tilezero", 8, TOKEN_INSN, 0, 0, I_TILEZERO },
+        { "vaddph", 6, TOKEN_INSN, 0, 0, I_VADDPH },
+        { "vaddsh", 6, TOKEN_INSN, 0, 0, I_VADDSH },
+        { "vcmpph", 6, TOKEN_INSN, 0, 0, I_VCMPPH },
+        { "vcmpsh", 6, TOKEN_INSN, 0, 0, I_VCMPSH },
+        { "vcomish", 7, TOKEN_INSN, 0, 0, I_VCOMISH },
+        { "vcvtdq2ph", 9, TOKEN_INSN, 0, 0, I_VCVTDQ2PH },
+        { "vcvtpd2ph", 9, TOKEN_INSN, 0, 0, I_VCVTPD2PH },
+        { "vcvtph2dq", 9, TOKEN_INSN, 0, 0, I_VCVTPH2DQ },
+        { "vcvtph2pd", 9, TOKEN_INSN, 0, 0, I_VCVTPH2PD },
+        { "vcvtph2psx", 10, TOKEN_INSN, 0, 0, I_VCVTPH2PSX },
+        { "vcvtph2qq", 9, TOKEN_INSN, 0, 0, I_VCVTPH2QQ },
+        { "vcvtph2udq", 10, TOKEN_INSN, 0, 0, I_VCVTPH2UDQ },
+        { "vcvtph2uqq", 10, TOKEN_INSN, 0, 0, I_VCVTPH2UQQ },
+        { "vcvtph2uw", 9, TOKEN_INSN, 0, 0, I_VCVTPH2UW },
+        { "vcvtph2w", 8, TOKEN_INSN, 0, 0, I_VCVTPH2W },
+        { "vcvtqq2ph", 9, TOKEN_INSN, 0, 0, I_VCVTQQ2PH },
+        { "vcvtsd2sh", 9, TOKEN_INSN, 0, 0, I_VCVTSD2SH },
+        { "vcvtsh2sd", 9, TOKEN_INSN, 0, 0, I_VCVTSH2SD },
+        { "vcvtsh2si", 9, TOKEN_INSN, 0, 0, I_VCVTSH2SI },
+        { "vcvtsh2ss", 9, TOKEN_INSN, 0, 0, I_VCVTSH2SS },
+        { "vcvtsh2usi", 10, TOKEN_INSN, 0, 0, I_VCVTSH2USI },
+        { "vcvtsi2sh", 9, TOKEN_INSN, 0, 0, I_VCVTSI2SH },
+        { "vcvtss2sh", 9, TOKEN_INSN, 0, 0, I_VCVTSS2SH },
+        { "vcvttph2dq", 10, TOKEN_INSN, 0, 0, I_VCVTTPH2DQ },
+        { "vcvttph2qq", 10, TOKEN_INSN, 0, 0, I_VCVTTPH2QQ },
+        { "vcvttph2udq", 11, TOKEN_INSN, 0, 0, I_VCVTTPH2UDQ },
+        { "vcvttph2uqq", 11, TOKEN_INSN, 0, 0, I_VCVTTPH2UQQ },
+        { "vcvttph2uw", 10, TOKEN_INSN, 0, 0, I_VCVTTPH2UW },
+        { "vcvttph2w", 9, TOKEN_INSN, 0, 0, I_VCVTTPH2W },
+        { "vcvttsh2si", 10, TOKEN_INSN, 0, 0, I_VCVTTSH2SI },
+        { "vcvttsh2usi", 11, TOKEN_INSN, 0, 0, I_VCVTTSH2USI },
+        { "vcvtudq2ph", 10, TOKEN_INSN, 0, 0, I_VCVTUDQ2PH },
+        { "vcvtuqq2ph", 10, TOKEN_INSN, 0, 0, I_VCVTUQQ2PH },
+        { "vcvtusi2sh", 10, TOKEN_INSN, 0, 0, I_VCVTUSI2SH },
+        { "vcvtuw2ph", 9, TOKEN_INSN, 0, 0, I_VCVTUW2PH },
+        { "vcvtw2ph", 8, TOKEN_INSN, 0, 0, I_VCVTW2PH },
+        { "vdivph", 6, TOKEN_INSN, 0, 0, I_VDIVPH },
+        { "vdivsh", 6, TOKEN_INSN, 0, 0, I_VDIVSH },
+        { "vfcmaddcph", 10, TOKEN_INSN, 0, 0, I_VFCMADDCPH },
+        { "vfmaddcph", 9, TOKEN_INSN, 0, 0, I_VFMADDCPH },
+        { "vfcmaddcsh", 10, TOKEN_INSN, 0, 0, I_VFCMADDCSH },
+        { "vfmaddcsh", 9, TOKEN_INSN, 0, 0, I_VFMADDCSH },
+        { "vfcmulcpch", 10, TOKEN_INSN, 0, 0, I_VFCMULCPCH },
+        { "vfmulcpch", 9, TOKEN_INSN, 0, 0, I_VFMULCPCH },
+        { "vfcmulcsh", 9, TOKEN_INSN, 0, 0, I_VFCMULCSH },
+        { "vfmulcsh", 8, TOKEN_INSN, 0, 0, I_VFMULCSH },
+        { "vfmaddsub132ph", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB132PH },
+        { "vfmaddsub213ph", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB213PH },
+        { "vfmaddsub231ph", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB231PH },
+        { "vfmsubadd132ph", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD132PH },
+        { "vfmsubadd213ph", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD213PH },
+        { "vfmsubadd231ph", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD231PH },
+        { "vpmadd132ph", 11, TOKEN_INSN, 0, 0, I_VPMADD132PH },
+        { "vpmadd213ph", 11, TOKEN_INSN, 0, 0, I_VPMADD213PH },
+        { "vpmadd231ph", 11, TOKEN_INSN, 0, 0, I_VPMADD231PH },
+        { "vfmadd132ph", 11, TOKEN_INSN, 0, 0, I_VFMADD132PH },
+        { "vfmadd213ph", 11, TOKEN_INSN, 0, 0, I_VFMADD213PH },
+        { "vfmadd231ph", 11, TOKEN_INSN, 0, 0, I_VFMADD231PH },
+        { "vpmadd132sh", 11, TOKEN_INSN, 0, 0, I_VPMADD132SH },
+        { "vpmadd213sh", 11, TOKEN_INSN, 0, 0, I_VPMADD213SH },
+        { "vpmadd231sh", 11, TOKEN_INSN, 0, 0, I_VPMADD231SH },
+        { "vpnmadd132sh", 12, TOKEN_INSN, 0, 0, I_VPNMADD132SH },
+        { "vpnmadd213sh", 12, TOKEN_INSN, 0, 0, I_VPNMADD213SH },
+        { "vpnmadd231sh", 12, TOKEN_INSN, 0, 0, I_VPNMADD231SH },
+        { "vpmsub132ph", 11, TOKEN_INSN, 0, 0, I_VPMSUB132PH },
+        { "vpmsub213ph", 11, TOKEN_INSN, 0, 0, I_VPMSUB213PH },
+        { "vpmsub231ph", 11, TOKEN_INSN, 0, 0, I_VPMSUB231PH },
+        { "vfmsub132ph", 11, TOKEN_INSN, 0, 0, I_VFMSUB132PH },
+        { "vfmsub213ph", 11, TOKEN_INSN, 0, 0, I_VFMSUB213PH },
+        { "vfmsub231ph", 11, TOKEN_INSN, 0, 0, I_VFMSUB231PH },
+        { "vpmsub132sh", 11, TOKEN_INSN, 0, 0, I_VPMSUB132SH },
+        { "vpmsub213sh", 11, TOKEN_INSN, 0, 0, I_VPMSUB213SH },
+        { "vpmsub231sh", 11, TOKEN_INSN, 0, 0, I_VPMSUB231SH },
+        { "vpnmsub132sh", 12, TOKEN_INSN, 0, 0, I_VPNMSUB132SH },
+        { "vpnmsub213sh", 12, TOKEN_INSN, 0, 0, I_VPNMSUB213SH },
+        { "vpnmsub231sh", 12, TOKEN_INSN, 0, 0, I_VPNMSUB231SH },
+        { "vfpclassph", 10, TOKEN_INSN, 0, 0, I_VFPCLASSPH },
+        { "vfpclasssh", 10, TOKEN_INSN, 0, 0, I_VFPCLASSSH },
+        { "vgetexpph", 9, TOKEN_INSN, 0, 0, I_VGETEXPPH },
+        { "vgetexpsh", 9, TOKEN_INSN, 0, 0, I_VGETEXPSH },
+        { "vgetmantph", 10, TOKEN_INSN, 0, 0, I_VGETMANTPH },
+        { "vgetmantsh", 10, TOKEN_INSN, 0, 0, I_VGETMANTSH },
+        { "vgetmaxph", 9, TOKEN_INSN, 0, 0, I_VGETMAXPH },
+        { "vgetmaxsh", 9, TOKEN_INSN, 0, 0, I_VGETMAXSH },
+        { "vgetminph", 9, TOKEN_INSN, 0, 0, I_VGETMINPH },
+        { "vgetminsh", 9, TOKEN_INSN, 0, 0, I_VGETMINSH },
+        { "vmovsh", 6, TOKEN_INSN, 0, 0, I_VMOVSH },
+        { "vmovw", 5, TOKEN_INSN, 0, 0, I_VMOVW },
+        { "vmulph", 6, TOKEN_INSN, 0, 0, I_VMULPH },
+        { "vmulsh", 6, TOKEN_INSN, 0, 0, I_VMULSH },
+        { "vrcpph", 6, TOKEN_INSN, 0, 0, I_VRCPPH },
+        { "vrcpsh", 6, TOKEN_INSN, 0, 0, I_VRCPSH },
+        { "vreduceph", 9, TOKEN_INSN, 0, 0, I_VREDUCEPH },
+        { "vreducesh", 9, TOKEN_INSN, 0, 0, I_VREDUCESH },
+        { "vendscaleph", 11, TOKEN_INSN, 0, 0, I_VENDSCALEPH },
+        { "vendscalesh", 11, TOKEN_INSN, 0, 0, I_VENDSCALESH },
+        { "vrsqrtph", 8, TOKEN_INSN, 0, 0, I_VRSQRTPH },
+        { "vrsqrtsh", 8, TOKEN_INSN, 0, 0, I_VRSQRTSH },
+        { "vscalefph", 9, TOKEN_INSN, 0, 0, I_VSCALEFPH },
+        { "vscalefsh", 9, TOKEN_INSN, 0, 0, I_VSCALEFSH },
+        { "vsqrtph", 7, TOKEN_INSN, 0, 0, I_VSQRTPH },
+        { "vsqrtsh", 7, TOKEN_INSN, 0, 0, I_VSQRTSH },
+        { "vsubph", 6, TOKEN_INSN, 0, 0, I_VSUBPH },
+        { "vsubsh", 6, TOKEN_INSN, 0, 0, I_VSUBSH },
+        { "vucomish", 8, TOKEN_INSN, 0, 0, I_VUCOMISH },
+        { "aadd", 4, TOKEN_INSN, 0, 0, I_AADD },
+        { "aand", 4, TOKEN_INSN, 0, 0, I_AAND },
+        { "axor", 4, TOKEN_INSN, 0, 0, I_AXOR },
+        { "clui", 4, TOKEN_INSN, 0, 0, I_CLUI },
+        { "senduipi", 8, TOKEN_INSN, 0, 0, I_SENDUIPI },
+        { "stui", 4, TOKEN_INSN, 0, 0, I_STUI },
+        { "testui", 6, TOKEN_INSN, 0, 0, I_TESTUI },
+        { "uiret", 5, TOKEN_INSN, 0, 0, I_UIRET },
+        { "cmpaxadd", 8, TOKEN_INSN, 0, 0, I_CMPAXADD },
+        { "cmpaexadd", 9, TOKEN_INSN, 0, 0, I_CMPAEXADD },
+        { "cmpbxadd", 8, TOKEN_INSN, 0, 0, I_CMPBXADD },
+        { "cmpbexadd", 9, TOKEN_INSN, 0, 0, I_CMPBEXADD },
+        { "cmpcxadd", 8, TOKEN_INSN, 0, 0, I_CMPCXADD },
+        { "cmpexadd", 8, TOKEN_INSN, 0, 0, I_CMPEXADD },
+        { "cmpgxadd", 8, TOKEN_INSN, 0, 0, I_CMPGXADD },
+        { "cmpgexadd", 9, TOKEN_INSN, 0, 0, I_CMPGEXADD },
+        { "cmplxadd", 8, TOKEN_INSN, 0, 0, I_CMPLXADD },
+        { "cmplexadd", 9, TOKEN_INSN, 0, 0, I_CMPLEXADD },
+        { "cmpnaxadd", 9, TOKEN_INSN, 0, 0, I_CMPNAXADD },
+        { "cmpnaexadd", 10, TOKEN_INSN, 0, 0, I_CMPNAEXADD },
+        { "cmpnbxadd", 9, TOKEN_INSN, 0, 0, I_CMPNBXADD },
+        { "cmpnbexadd", 10, TOKEN_INSN, 0, 0, I_CMPNBEXADD },
+        { "cmpncxadd", 9, TOKEN_INSN, 0, 0, I_CMPNCXADD },
+        { "cmpnexadd", 9, TOKEN_INSN, 0, 0, I_CMPNEXADD },
+        { "cmpngxadd", 9, TOKEN_INSN, 0, 0, I_CMPNGXADD },
+        { "cmpngexadd", 10, TOKEN_INSN, 0, 0, I_CMPNGEXADD },
+        { "cmpnlxadd", 9, TOKEN_INSN, 0, 0, I_CMPNLXADD },
+        { "cmpnlexadd", 10, TOKEN_INSN, 0, 0, I_CMPNLEXADD },
+        { "cmpnoxadd", 9, TOKEN_INSN, 0, 0, I_CMPNOXADD },
+        { "cmpnpxadd", 9, TOKEN_INSN, 0, 0, I_CMPNPXADD },
+        { "cmpnsxadd", 9, TOKEN_INSN, 0, 0, I_CMPNSXADD },
+        { "cmpnzxadd", 9, TOKEN_INSN, 0, 0, I_CMPNZXADD },
+        { "cmpoxadd", 8, TOKEN_INSN, 0, 0, I_CMPOXADD },
+        { "cmppxadd", 8, TOKEN_INSN, 0, 0, I_CMPPXADD },
+        { "cmppexadd", 9, TOKEN_INSN, 0, 0, I_CMPPEXADD },
+        { "cmppoxadd", 9, TOKEN_INSN, 0, 0, I_CMPPOXADD },
+        { "cmpsxadd", 8, TOKEN_INSN, 0, 0, I_CMPSXADD },
+        { "cmpzxadd", 8, TOKEN_INSN, 0, 0, I_CMPZXADD },
+        { "wrmsrns", 7, TOKEN_INSN, 0, 0, I_WRMSRNS },
+        { "rdmsrlist", 9, TOKEN_INSN, 0, 0, I_RDMSRLIST },
+        { "wrmsrlist", 9, TOKEN_INSN, 0, 0, I_WRMSRLIST },
+        { "hreset", 6, TOKEN_INSN, 0, 0, I_HRESET },
+        { "hint_nop0", 9, TOKEN_INSN, 0, 0, I_HINT_NOP0 },
+        { "hint_nop1", 9, TOKEN_INSN, 0, 0, I_HINT_NOP1 },
+        { "hint_nop2", 9, TOKEN_INSN, 0, 0, I_HINT_NOP2 },
+        { "hint_nop3", 9, TOKEN_INSN, 0, 0, I_HINT_NOP3 },
+        { "hint_nop4", 9, TOKEN_INSN, 0, 0, I_HINT_NOP4 },
+        { "hint_nop5", 9, TOKEN_INSN, 0, 0, I_HINT_NOP5 },
+        { "hint_nop6", 9, TOKEN_INSN, 0, 0, I_HINT_NOP6 },
+        { "hint_nop7", 9, TOKEN_INSN, 0, 0, I_HINT_NOP7 },
+        { "hint_nop8", 9, TOKEN_INSN, 0, 0, I_HINT_NOP8 },
+        { "hint_nop9", 9, TOKEN_INSN, 0, 0, I_HINT_NOP9 },
+        { "hint_nop10", 10, TOKEN_INSN, 0, 0, I_HINT_NOP10 },
+        { "hint_nop11", 10, TOKEN_INSN, 0, 0, I_HINT_NOP11 },
+        { "hint_nop12", 10, TOKEN_INSN, 0, 0, I_HINT_NOP12 },
+        { "hint_nop13", 10, TOKEN_INSN, 0, 0, I_HINT_NOP13 },
+        { "hint_nop14", 10, TOKEN_INSN, 0, 0, I_HINT_NOP14 },
+        { "hint_nop15", 10, TOKEN_INSN, 0, 0, I_HINT_NOP15 },
+        { "hint_nop16", 10, TOKEN_INSN, 0, 0, I_HINT_NOP16 },
+        { "hint_nop17", 10, TOKEN_INSN, 0, 0, I_HINT_NOP17 },
+        { "hint_nop18", 10, TOKEN_INSN, 0, 0, I_HINT_NOP18 },
+        { "hint_nop19", 10, TOKEN_INSN, 0, 0, I_HINT_NOP19 },
+        { "hint_nop20", 10, TOKEN_INSN, 0, 0, I_HINT_NOP20 },
+        { "hint_nop21", 10, TOKEN_INSN, 0, 0, I_HINT_NOP21 },
+        { "hint_nop22", 10, TOKEN_INSN, 0, 0, I_HINT_NOP22 },
+        { "hint_nop23", 10, TOKEN_INSN, 0, 0, I_HINT_NOP23 },
+        { "hint_nop24", 10, TOKEN_INSN, 0, 0, I_HINT_NOP24 },
+        { "hint_nop25", 10, TOKEN_INSN, 0, 0, I_HINT_NOP25 },
+        { "hint_nop26", 10, TOKEN_INSN, 0, 0, I_HINT_NOP26 },
+        { "hint_nop27", 10, TOKEN_INSN, 0, 0, I_HINT_NOP27 },
+        { "hint_nop28", 10, TOKEN_INSN, 0, 0, I_HINT_NOP28 },
+        { "hint_nop29", 10, TOKEN_INSN, 0, 0, I_HINT_NOP29 },
+        { "hint_nop30", 10, TOKEN_INSN, 0, 0, I_HINT_NOP30 },
+        { "hint_nop31", 10, TOKEN_INSN, 0, 0, I_HINT_NOP31 },
+        { "hint_nop32", 10, TOKEN_INSN, 0, 0, I_HINT_NOP32 },
+        { "hint_nop33", 10, TOKEN_INSN, 0, 0, I_HINT_NOP33 },
+        { "hint_nop34", 10, TOKEN_INSN, 0, 0, I_HINT_NOP34 },
+        { "hint_nop35", 10, TOKEN_INSN, 0, 0, I_HINT_NOP35 },
+        { "hint_nop36", 10, TOKEN_INSN, 0, 0, I_HINT_NOP36 },
+        { "hint_nop37", 10, TOKEN_INSN, 0, 0, I_HINT_NOP37 },
+        { "hint_nop38", 10, TOKEN_INSN, 0, 0, I_HINT_NOP38 },
+        { "hint_nop39", 10, TOKEN_INSN, 0, 0, I_HINT_NOP39 },
+        { "hint_nop40", 10, TOKEN_INSN, 0, 0, I_HINT_NOP40 },
+        { "hint_nop41", 10, TOKEN_INSN, 0, 0, I_HINT_NOP41 },
+        { "hint_nop42", 10, TOKEN_INSN, 0, 0, I_HINT_NOP42 },
+        { "hint_nop43", 10, TOKEN_INSN, 0, 0, I_HINT_NOP43 },
+        { "hint_nop44", 10, TOKEN_INSN, 0, 0, I_HINT_NOP44 },
+        { "hint_nop45", 10, TOKEN_INSN, 0, 0, I_HINT_NOP45 },
+        { "hint_nop46", 10, TOKEN_INSN, 0, 0, I_HINT_NOP46 },
+        { "hint_nop47", 10, TOKEN_INSN, 0, 0, I_HINT_NOP47 },
+        { "hint_nop48", 10, TOKEN_INSN, 0, 0, I_HINT_NOP48 },
+        { "hint_nop49", 10, TOKEN_INSN, 0, 0, I_HINT_NOP49 },
+        { "hint_nop50", 10, TOKEN_INSN, 0, 0, I_HINT_NOP50 },
+        { "hint_nop51", 10, TOKEN_INSN, 0, 0, I_HINT_NOP51 },
+        { "hint_nop52", 10, TOKEN_INSN, 0, 0, I_HINT_NOP52 },
+        { "hint_nop53", 10, TOKEN_INSN, 0, 0, I_HINT_NOP53 },
+        { "hint_nop54", 10, TOKEN_INSN, 0, 0, I_HINT_NOP54 },
+        { "hint_nop55", 10, TOKEN_INSN, 0, 0, I_HINT_NOP55 },
+        { "hint_nop56", 10, TOKEN_INSN, 0, 0, I_HINT_NOP56 },
+        { "hint_nop57", 10, TOKEN_INSN, 0, 0, I_HINT_NOP57 },
+        { "hint_nop58", 10, TOKEN_INSN, 0, 0, I_HINT_NOP58 },
+        { "hint_nop59", 10, TOKEN_INSN, 0, 0, I_HINT_NOP59 },
+        { "hint_nop60", 10, TOKEN_INSN, 0, 0, I_HINT_NOP60 },
+        { "hint_nop61", 10, TOKEN_INSN, 0, 0, I_HINT_NOP61 },
+        { "hint_nop62", 10, TOKEN_INSN, 0, 0, I_HINT_NOP62 },
+        { "hint_nop63", 10, TOKEN_INSN, 0, 0, I_HINT_NOP63 },
+        { "al", 2, TOKEN_REG, 0, 0, R_AL },
+        { "ah", 2, TOKEN_REG, 0, 0, R_AH },
+        { "ax", 2, TOKEN_REG, 0, 0, R_AX },
+        { "eax", 3, TOKEN_REG, 0, 0, R_EAX },
+        { "rax", 3, TOKEN_REG, 0, 0, R_RAX },
+        { "bl", 2, TOKEN_REG, 0, 0, R_BL },
+        { "bh", 2, TOKEN_REG, 0, 0, R_BH },
+        { "bx", 2, TOKEN_REG, 0, 0, R_BX },
+        { "ebx", 3, TOKEN_REG, 0, 0, R_EBX },
+        { "rbx", 3, TOKEN_REG, 0, 0, R_RBX },
+        { "cl", 2, TOKEN_REG, 0, 0, R_CL },
+        { "ch", 2, TOKEN_REG, 0, 0, R_CH },
+        { "cx", 2, TOKEN_REG, 0, 0, R_CX },
+        { "ecx", 3, TOKEN_REG, 0, 0, R_ECX },
+        { "rcx", 3, TOKEN_REG, 0, 0, R_RCX },
+        { "dl", 2, TOKEN_REG, 0, 0, R_DL },
+        { "dh", 2, TOKEN_REG, 0, 0, R_DH },
+        { "dx", 2, TOKEN_REG, 0, 0, R_DX },
+        { "edx", 3, TOKEN_REG, 0, 0, R_EDX },
+        { "rdx", 3, TOKEN_REG, 0, 0, R_RDX },
+        { "spl", 3, TOKEN_REG, 0, 0, R_SPL },
+        { "sp", 2, TOKEN_REG, 0, 0, R_SP },
+        { "esp", 3, TOKEN_REG, 0, 0, R_ESP },
+        { "rsp", 3, TOKEN_REG, 0, 0, R_RSP },
+        { "bpl", 3, TOKEN_REG, 0, 0, R_BPL },
+        { "bp", 2, TOKEN_REG, 0, 0, R_BP },
+        { "ebp", 3, TOKEN_REG, 0, 0, R_EBP },
+        { "rbp", 3, TOKEN_REG, 0, 0, R_RBP },
+        { "sil", 3, TOKEN_REG, 0, 0, R_SIL },
+        { "si", 2, TOKEN_REG, 0, 0, R_SI },
+        { "esi", 3, TOKEN_REG, 0, 0, R_ESI },
+        { "rsi", 3, TOKEN_REG, 0, 0, R_RSI },
+        { "dil", 3, TOKEN_REG, 0, 0, R_DIL },
+        { "di", 2, TOKEN_REG, 0, 0, R_DI },
+        { "edi", 3, TOKEN_REG, 0, 0, R_EDI },
+        { "rdi", 3, TOKEN_REG, 0, 0, R_RDI },
+        { "r8b", 3, TOKEN_REG, 0, 0, R_R8B },
+        { "r9b", 3, TOKEN_REG, 0, 0, R_R9B },
+        { "r10b", 4, TOKEN_REG, 0, 0, R_R10B },
+        { "r11b", 4, TOKEN_REG, 0, 0, R_R11B },
+        { "r12b", 4, TOKEN_REG, 0, 0, R_R12B },
+        { "r13b", 4, TOKEN_REG, 0, 0, R_R13B },
+        { "r14b", 4, TOKEN_REG, 0, 0, R_R14B },
+        { "r15b", 4, TOKEN_REG, 0, 0, R_R15B },
+        { "r8w", 3, TOKEN_REG, 0, 0, R_R8W },
+        { "r9w", 3, TOKEN_REG, 0, 0, R_R9W },
+        { "r10w", 4, TOKEN_REG, 0, 0, R_R10W },
+        { "r11w", 4, TOKEN_REG, 0, 0, R_R11W },
+        { "r12w", 4, TOKEN_REG, 0, 0, R_R12W },
+        { "r13w", 4, TOKEN_REG, 0, 0, R_R13W },
+        { "r14w", 4, TOKEN_REG, 0, 0, R_R14W },
+        { "r15w", 4, TOKEN_REG, 0, 0, R_R15W },
+        { "r8d", 3, TOKEN_REG, 0, 0, R_R8D },
+        { "r9d", 3, TOKEN_REG, 0, 0, R_R9D },
+        { "r10d", 4, TOKEN_REG, 0, 0, R_R10D },
+        { "r11d", 4, TOKEN_REG, 0, 0, R_R11D },
+        { "r12d", 4, TOKEN_REG, 0, 0, R_R12D },
+        { "r13d", 4, TOKEN_REG, 0, 0, R_R13D },
+        { "r14d", 4, TOKEN_REG, 0, 0, R_R14D },
+        { "r15d", 4, TOKEN_REG, 0, 0, R_R15D },
+        { "r8", 2, TOKEN_REG, 0, 0, R_R8 },
+        { "r9", 2, TOKEN_REG, 0, 0, R_R9 },
+        { "r10", 3, TOKEN_REG, 0, 0, R_R10 },
+        { "r11", 3, TOKEN_REG, 0, 0, R_R11 },
+        { "r12", 3, TOKEN_REG, 0, 0, R_R12 },
+        { "r13", 3, TOKEN_REG, 0, 0, R_R13 },
+        { "r14", 3, TOKEN_REG, 0, 0, R_R14 },
+        { "r15", 3, TOKEN_REG, 0, 0, R_R15 },
+        { "es", 2, TOKEN_REG, 0, 0, R_ES },
+        { "cs", 2, TOKEN_REG, 0, 0, R_CS },
+        { "ss", 2, TOKEN_REG, 0, 0, R_SS },
+        { "ds", 2, TOKEN_REG, 0, 0, R_DS },
+        { "fs", 2, TOKEN_REG, 0, 0, R_FS },
+        { "gs", 2, TOKEN_REG, 0, 0, R_GS },
+        { "segr6", 5, TOKEN_REG, 0, 0, R_SEGR6 },
+        { "segr7", 5, TOKEN_REG, 0, 0, R_SEGR7 },
+        { "cr0", 3, TOKEN_REG, 0, 0, R_CR0 },
+        { "cr1", 3, TOKEN_REG, 0, 0, R_CR1 },
+        { "cr2", 3, TOKEN_REG, 0, 0, R_CR2 },
+        { "cr3", 3, TOKEN_REG, 0, 0, R_CR3 },
+        { "cr4", 3, TOKEN_REG, 0, 0, R_CR4 },
+        { "cr5", 3, TOKEN_REG, 0, 0, R_CR5 },
+        { "cr6", 3, TOKEN_REG, 0, 0, R_CR6 },
+        { "cr7", 3, TOKEN_REG, 0, 0, R_CR7 },
+        { "cr8", 3, TOKEN_REG, 0, 0, R_CR8 },
+        { "cr9", 3, TOKEN_REG, 0, 0, R_CR9 },
+        { "cr10", 4, TOKEN_REG, 0, 0, R_CR10 },
+        { "cr11", 4, TOKEN_REG, 0, 0, R_CR11 },
+        { "cr12", 4, TOKEN_REG, 0, 0, R_CR12 },
+        { "cr13", 4, TOKEN_REG, 0, 0, R_CR13 },
+        { "cr14", 4, TOKEN_REG, 0, 0, R_CR14 },
+        { "cr15", 4, TOKEN_REG, 0, 0, R_CR15 },
+        { "dr0", 3, TOKEN_REG, 0, 0, R_DR0 },
+        { "dr1", 3, TOKEN_REG, 0, 0, R_DR1 },
+        { "dr2", 3, TOKEN_REG, 0, 0, R_DR2 },
+        { "dr3", 3, TOKEN_REG, 0, 0, R_DR3 },
+        { "dr4", 3, TOKEN_REG, 0, 0, R_DR4 },
+        { "dr5", 3, TOKEN_REG, 0, 0, R_DR5 },
+        { "dr6", 3, TOKEN_REG, 0, 0, R_DR6 },
+        { "dr7", 3, TOKEN_REG, 0, 0, R_DR7 },
+        { "dr8", 3, TOKEN_REG, 0, 0, R_DR8 },
+        { "dr9", 3, TOKEN_REG, 0, 0, R_DR9 },
+        { "dr10", 4, TOKEN_REG, 0, 0, R_DR10 },
+        { "dr11", 4, TOKEN_REG, 0, 0, R_DR11 },
+        { "dr12", 4, TOKEN_REG, 0, 0, R_DR12 },
+        { "dr13", 4, TOKEN_REG, 0, 0, R_DR13 },
+        { "dr14", 4, TOKEN_REG, 0, 0, R_DR14 },
+        { "dr15", 4, TOKEN_REG, 0, 0, R_DR15 },
+        { "tr0", 3, TOKEN_REG, 0, 0, R_TR0 },
+        { "tr1", 3, TOKEN_REG, 0, 0, R_TR1 },
+        { "tr2", 3, TOKEN_REG, 0, 0, R_TR2 },
+        { "tr3", 3, TOKEN_REG, 0, 0, R_TR3 },
+        { "tr4", 3, TOKEN_REG, 0, 0, R_TR4 },
+        { "tr5", 3, TOKEN_REG, 0, 0, R_TR5 },
+        { "tr6", 3, TOKEN_REG, 0, 0, R_TR6 },
+        { "tr7", 3, TOKEN_REG, 0, 0, R_TR7 },
+        { "st0", 3, TOKEN_REG, 0, 0, R_ST0 },
+        { "st1", 3, TOKEN_REG, 0, 0, R_ST1 },
+        { "st2", 3, TOKEN_REG, 0, 0, R_ST2 },
+        { "st3", 3, TOKEN_REG, 0, 0, R_ST3 },
+        { "st4", 3, TOKEN_REG, 0, 0, R_ST4 },
+        { "st5", 3, TOKEN_REG, 0, 0, R_ST5 },
+        { "st6", 3, TOKEN_REG, 0, 0, R_ST6 },
+        { "st7", 3, TOKEN_REG, 0, 0, R_ST7 },
+        { "mm0", 3, TOKEN_REG, 0, 0, R_MM0 },
+        { "mm1", 3, TOKEN_REG, 0, 0, R_MM1 },
+        { "mm2", 3, TOKEN_REG, 0, 0, R_MM2 },
+        { "mm3", 3, TOKEN_REG, 0, 0, R_MM3 },
+        { "mm4", 3, TOKEN_REG, 0, 0, R_MM4 },
+        { "mm5", 3, TOKEN_REG, 0, 0, R_MM5 },
+        { "mm6", 3, TOKEN_REG, 0, 0, R_MM6 },
+        { "mm7", 3, TOKEN_REG, 0, 0, R_MM7 },
+        { "xmm0", 4, TOKEN_REG, 0, 0, R_XMM0 },
+        { "xmm1", 4, TOKEN_REG, 0, 0, R_XMM1 },
+        { "xmm2", 4, TOKEN_REG, 0, 0, R_XMM2 },
+        { "xmm3", 4, TOKEN_REG, 0, 0, R_XMM3 },
+        { "xmm4", 4, TOKEN_REG, 0, 0, R_XMM4 },
+        { "xmm5", 4, TOKEN_REG, 0, 0, R_XMM5 },
+        { "xmm6", 4, TOKEN_REG, 0, 0, R_XMM6 },
+        { "xmm7", 4, TOKEN_REG, 0, 0, R_XMM7 },
+        { "xmm8", 4, TOKEN_REG, 0, 0, R_XMM8 },
+        { "xmm9", 4, TOKEN_REG, 0, 0, R_XMM9 },
+        { "xmm10", 5, TOKEN_REG, 0, 0, R_XMM10 },
+        { "xmm11", 5, TOKEN_REG, 0, 0, R_XMM11 },
+        { "xmm12", 5, TOKEN_REG, 0, 0, R_XMM12 },
+        { "xmm13", 5, TOKEN_REG, 0, 0, R_XMM13 },
+        { "xmm14", 5, TOKEN_REG, 0, 0, R_XMM14 },
+        { "xmm15", 5, TOKEN_REG, 0, 0, R_XMM15 },
+        { "xmm16", 5, TOKEN_REG, 0, 0, R_XMM16 },
+        { "xmm17", 5, TOKEN_REG, 0, 0, R_XMM17 },
+        { "xmm18", 5, TOKEN_REG, 0, 0, R_XMM18 },
+        { "xmm19", 5, TOKEN_REG, 0, 0, R_XMM19 },
+        { "xmm20", 5, TOKEN_REG, 0, 0, R_XMM20 },
+        { "xmm21", 5, TOKEN_REG, 0, 0, R_XMM21 },
+        { "xmm22", 5, TOKEN_REG, 0, 0, R_XMM22 },
+        { "xmm23", 5, TOKEN_REG, 0, 0, R_XMM23 },
+        { "xmm24", 5, TOKEN_REG, 0, 0, R_XMM24 },
+        { "xmm25", 5, TOKEN_REG, 0, 0, R_XMM25 },
+        { "xmm26", 5, TOKEN_REG, 0, 0, R_XMM26 },
+        { "xmm27", 5, TOKEN_REG, 0, 0, R_XMM27 },
+        { "xmm28", 5, TOKEN_REG, 0, 0, R_XMM28 },
+        { "xmm29", 5, TOKEN_REG, 0, 0, R_XMM29 },
+        { "xmm30", 5, TOKEN_REG, 0, 0, R_XMM30 },
+        { "xmm31", 5, TOKEN_REG, 0, 0, R_XMM31 },
+        { "ymm0", 4, TOKEN_REG, 0, 0, R_YMM0 },
+        { "ymm1", 4, TOKEN_REG, 0, 0, R_YMM1 },
+        { "ymm2", 4, TOKEN_REG, 0, 0, R_YMM2 },
+        { "ymm3", 4, TOKEN_REG, 0, 0, R_YMM3 },
+        { "ymm4", 4, TOKEN_REG, 0, 0, R_YMM4 },
+        { "ymm5", 4, TOKEN_REG, 0, 0, R_YMM5 },
+        { "ymm6", 4, TOKEN_REG, 0, 0, R_YMM6 },
+        { "ymm7", 4, TOKEN_REG, 0, 0, R_YMM7 },
+        { "ymm8", 4, TOKEN_REG, 0, 0, R_YMM8 },
+        { "ymm9", 4, TOKEN_REG, 0, 0, R_YMM9 },
+        { "ymm10", 5, TOKEN_REG, 0, 0, R_YMM10 },
+        { "ymm11", 5, TOKEN_REG, 0, 0, R_YMM11 },
+        { "ymm12", 5, TOKEN_REG, 0, 0, R_YMM12 },
+        { "ymm13", 5, TOKEN_REG, 0, 0, R_YMM13 },
+        { "ymm14", 5, TOKEN_REG, 0, 0, R_YMM14 },
+        { "ymm15", 5, TOKEN_REG, 0, 0, R_YMM15 },
+        { "ymm16", 5, TOKEN_REG, 0, 0, R_YMM16 },
+        { "ymm17", 5, TOKEN_REG, 0, 0, R_YMM17 },
+        { "ymm18", 5, TOKEN_REG, 0, 0, R_YMM18 },
+        { "ymm19", 5, TOKEN_REG, 0, 0, R_YMM19 },
+        { "ymm20", 5, TOKEN_REG, 0, 0, R_YMM20 },
+        { "ymm21", 5, TOKEN_REG, 0, 0, R_YMM21 },
+        { "ymm22", 5, TOKEN_REG, 0, 0, R_YMM22 },
+        { "ymm23", 5, TOKEN_REG, 0, 0, R_YMM23 },
+        { "ymm24", 5, TOKEN_REG, 0, 0, R_YMM24 },
+        { "ymm25", 5, TOKEN_REG, 0, 0, R_YMM25 },
+        { "ymm26", 5, TOKEN_REG, 0, 0, R_YMM26 },
+        { "ymm27", 5, TOKEN_REG, 0, 0, R_YMM27 },
+        { "ymm28", 5, TOKEN_REG, 0, 0, R_YMM28 },
+        { "ymm29", 5, TOKEN_REG, 0, 0, R_YMM29 },
+        { "ymm30", 5, TOKEN_REG, 0, 0, R_YMM30 },
+        { "ymm31", 5, TOKEN_REG, 0, 0, R_YMM31 },
+        { "zmm0", 4, TOKEN_REG, 0, 0, R_ZMM0 },
+        { "zmm1", 4, TOKEN_REG, 0, 0, R_ZMM1 },
+        { "zmm2", 4, TOKEN_REG, 0, 0, R_ZMM2 },
+        { "zmm3", 4, TOKEN_REG, 0, 0, R_ZMM3 },
+        { "zmm4", 4, TOKEN_REG, 0, 0, R_ZMM4 },
+        { "zmm5", 4, TOKEN_REG, 0, 0, R_ZMM5 },
+        { "zmm6", 4, TOKEN_REG, 0, 0, R_ZMM6 },
+        { "zmm7", 4, TOKEN_REG, 0, 0, R_ZMM7 },
+        { "zmm8", 4, TOKEN_REG, 0, 0, R_ZMM8 },
+        { "zmm9", 4, TOKEN_REG, 0, 0, R_ZMM9 },
+        { "zmm10", 5, TOKEN_REG, 0, 0, R_ZMM10 },
+        { "zmm11", 5, TOKEN_REG, 0, 0, R_ZMM11 },
+        { "zmm12", 5, TOKEN_REG, 0, 0, R_ZMM12 },
+        { "zmm13", 5, TOKEN_REG, 0, 0, R_ZMM13 },
+        { "zmm14", 5, TOKEN_REG, 0, 0, R_ZMM14 },
+        { "zmm15", 5, TOKEN_REG, 0, 0, R_ZMM15 },
+        { "zmm16", 5, TOKEN_REG, 0, 0, R_ZMM16 },
+        { "zmm17", 5, TOKEN_REG, 0, 0, R_ZMM17 },
+        { "zmm18", 5, TOKEN_REG, 0, 0, R_ZMM18 },
+        { "zmm19", 5, TOKEN_REG, 0, 0, R_ZMM19 },
+        { "zmm20", 5, TOKEN_REG, 0, 0, R_ZMM20 },
+        { "zmm21", 5, TOKEN_REG, 0, 0, R_ZMM21 },
+        { "zmm22", 5, TOKEN_REG, 0, 0, R_ZMM22 },
+        { "zmm23", 5, TOKEN_REG, 0, 0, R_ZMM23 },
+        { "zmm24", 5, TOKEN_REG, 0, 0, R_ZMM24 },
+        { "zmm25", 5, TOKEN_REG, 0, 0, R_ZMM25 },
+        { "zmm26", 5, TOKEN_REG, 0, 0, R_ZMM26 },
+        { "zmm27", 5, TOKEN_REG, 0, 0, R_ZMM27 },
+        { "zmm28", 5, TOKEN_REG, 0, 0, R_ZMM28 },
+        { "zmm29", 5, TOKEN_REG, 0, 0, R_ZMM29 },
+        { "zmm30", 5, TOKEN_REG, 0, 0, R_ZMM30 },
+        { "zmm31", 5, TOKEN_REG, 0, 0, R_ZMM31 },
+        { "tmm0", 4, TOKEN_REG, 0, 0, R_TMM0 },
+        { "tmm1", 4, TOKEN_REG, 0, 0, R_TMM1 },
+        { "tmm2", 4, TOKEN_REG, 0, 0, R_TMM2 },
+        { "tmm3", 4, TOKEN_REG, 0, 0, R_TMM3 },
+        { "tmm4", 4, TOKEN_REG, 0, 0, R_TMM4 },
+        { "tmm5", 4, TOKEN_REG, 0, 0, R_TMM5 },
+        { "tmm6", 4, TOKEN_REG, 0, 0, R_TMM6 },
+        { "tmm7", 4, TOKEN_REG, 0, 0, R_TMM7 },
+        { "k0", 2, TOKEN_REG, 0, 0, R_K0 },
+        { "k1", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K1 },
+        { "k2", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K2 },
+        { "k3", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K3 },
+        { "k4", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K4 },
+        { "k5", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K5 },
+        { "k6", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K6 },
+        { "k7", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K7 },
+        { "bnd0", 4, TOKEN_REG, 0, 0, R_BND0 },
+        { "bnd1", 4, TOKEN_REG, 0, 0, R_BND1 },
+        { "bnd2", 4, TOKEN_REG, 0, 0, R_BND2 },
+        { "bnd3", 4, TOKEN_REG, 0, 0, R_BND3 },
+        { "?", 1, TOKEN_QMARK, 0, 0, 0 },
+        { "a16", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_A16 },
+        { "a32", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_A32 },
+        { "a64", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_A64 },
+        { "asp", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_ASP },
+        { "lock", 4, TOKEN_PREFIX, PPS_LOCK, 0, P_LOCK },
+        { "o16", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_O16 },
+        { "o32", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_O32 },
+        { "o64", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_O64 },
+        { "osp", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_OSP },
+        { "rep", 3, TOKEN_PREFIX, PPS_REP, 0, P_REP },
+        { "repe", 4, TOKEN_PREFIX, PPS_REP, 0, P_REPE },
+        { "repne", 5, TOKEN_PREFIX, PPS_REP, 0, P_REPNE },
+        { "repnz", 5, TOKEN_PREFIX, PPS_REP, 0, P_REPNZ },
+        { "repz", 4, TOKEN_PREFIX, PPS_REP, 0, P_REPZ },
+        { "xacquire", 8, TOKEN_PREFIX, PPS_REP, 0, P_XACQUIRE },
+        { "xrelease", 8, TOKEN_PREFIX, PPS_REP, 0, P_XRELEASE },
+        { "bnd", 3, TOKEN_PREFIX, PPS_REP, 0, P_BND },
+        { "nobnd", 5, TOKEN_PREFIX, PPS_REP, 0, P_NOBND },
+        { "times", 5, TOKEN_PREFIX, PPS_TIMES, 0, P_TIMES },
+        { "wait", 4, TOKEN_PREFIX, PPS_WAIT, 0, P_WAIT },
+        { "rex", 3, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_REX },
+        { "evex", 4, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_EVEX },
+        { "vex", 3, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_VEX },
+        { "vex3", 4, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_VEX3 },
+        { "vex2", 4, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_VEX2 },
+        { "byte", 4, TOKEN_SIZE, SIZE_BYTE, 0, S_BYTE },
+        { "word", 4, TOKEN_SIZE, SIZE_WORD, 0, S_WORD },
+        { "dword", 5, TOKEN_SIZE, SIZE_DWORD, 0, S_DWORD },
+        { "qword", 5, TOKEN_SIZE, SIZE_QWORD, 0, S_QWORD },
+        { "tword", 5, TOKEN_SIZE, SIZE_TWORD, 0, S_TWORD },
+        { "oword", 5, TOKEN_SIZE, SIZE_OWORD, 0, S_OWORD },
+        { "yword", 5, TOKEN_SIZE, SIZE_YWORD, 0, S_YWORD },
+        { "zword", 5, TOKEN_SIZE, SIZE_ZWORD, 0, S_ZWORD },
+        { "abs", 3, TOKEN_SPECIAL, 0, 0, S_ABS },
+        { "far", 3, TOKEN_SPECIAL, 0, 0, S_FAR },
+        { "long", 4, TOKEN_SPECIAL, 0, 0, S_LONG },
+        { "near", 4, TOKEN_SPECIAL, 0, 0, S_NEAR },
+        { "nosplit", 7, TOKEN_SPECIAL, 0, 0, S_NOSPLIT },
+        { "rel", 3, TOKEN_SPECIAL, 0, 0, S_REL },
+        { "short", 5, TOKEN_SPECIAL, 0, 0, S_SHORT },
+        { "strict", 6, TOKEN_SPECIAL, 0, 0, S_STRICT },
+        { "to", 2, TOKEN_SPECIAL, 0, 0, S_TO },
+        { "ptr", 3, TOKEN_ID, 0, TFLAG_WARN, 0 },
+        { "dup", 3, TOKEN_ID, 0, TFLAG_DUP, 0 },
+        { "__?infinity?__", 14, TOKEN_FLOAT, 0, 0, 0 },
+        { "__?nan?__", 9, TOKEN_FLOAT, 0, 0, 0 },
+        { "__?qnan?__", 10, TOKEN_FLOAT, 0, 0, 0 },
+        { "__?snan?__", 10, TOKEN_FLOAT, 0, 0, 0 },
+        { "__?float8?__", 12, TOKEN_FLOATIZE, 0, 0, FLOAT_8 },
+        { "__?float16?__", 13, TOKEN_FLOATIZE, 0, 0, FLOAT_16 },
+        { "__?float32?__", 13, TOKEN_FLOATIZE, 0, 0, FLOAT_32 },
+        { "__?float64?__", 13, TOKEN_FLOATIZE, 0, 0, FLOAT_64 },
+        { "__?float80m?__", 14, TOKEN_FLOATIZE, 0, 0, FLOAT_80M },
+        { "__?float80e?__", 14, TOKEN_FLOATIZE, 0, 0, FLOAT_80E },
+        { "__?float128l?__", 15, TOKEN_FLOATIZE, 0, 0, FLOAT_128L },
+        { "__?float128h?__", 15, TOKEN_FLOATIZE, 0, 0, FLOAT_128H },
+        { "__?bfloat16?__", 14, TOKEN_FLOATIZE, 0, 0, FLOAT_B16 },
+        { "__?utf16?__", 11, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF16 },
+        { "__?utf16le?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF16LE },
+        { "__?utf16be?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF16BE },
+        { "__?utf32?__", 11, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF32 },
+        { "__?utf32le?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF32LE },
+        { "__?utf32be?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF32BE },
+        { "__?ilog2e?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2E },
+        { "__?ilog2w?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2W },
+        { "__?ilog2f?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2F },
+        { "__?ilog2c?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2C },
+        { "seg", 3, TOKEN_SEG, 0, 0, 0 },
+        { "wrt", 3, TOKEN_WRT, 0, 0, 0 },
+        { "__?masm_ptr?__", 14, TOKEN_MASM_PTR, 0, 0, 0 },
+        { "__?masm_flat?__", 15, TOKEN_MASM_FLAT, 0, 0, 0 },
+        { "1to2", 4, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO2 },
+        { "1to4", 4, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO4 },
+        { "1to8", 4, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO8 },
+        { "1to16", 5, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO16 },
+        { "1to32", 5, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO32 },
+        { "rn-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RN },
+        { "rd-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RD },
+        { "ru-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RU },
+        { "rz-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RZ },
+        { "sae", 3, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_SAE },
+        { "z", 1, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_Z },
+        { ">>", 2, TOKEN_SHR, 0, 0, 0 },
+        { ">>>", 3, TOKEN_SAR, 0, 0, 0 },
+        { "<<", 2, TOKEN_SHL, 0, 0, 0 },
+        { "<<<", 3, TOKEN_SHL, 0, 0, 0 },
+        { "//", 2, TOKEN_SDIV, 0, 0, 0 },
+        { "%%", 2, TOKEN_SMOD, 0, 0, 0 },
+        { "==", 2, TOKEN_EQ, 0, 0, 0 },
+        { "!=", 2, TOKEN_NE, 0, 0, 0 },
+        { "<>", 2, TOKEN_NE, 0, 0, 0 },
+        { "<=", 2, TOKEN_LE, 0, 0, 0 },
+        { ">=", 2, TOKEN_GE, 0, 0, 0 },
+        { "<=>", 3, TOKEN_LEG, 0, 0, 0 },
+        { "&&", 2, TOKEN_DBL_AND, 0, 0, 0 },
+        { "||", 2, TOKEN_DBL_OR, 0, 0, 0 },
+        { "^^", 2, TOKEN_DBL_XOR, 0, 0, 0 },
+    };
+    uint32_t k1, k2;
+    uint16_t ix;
+    const struct tokendata *data;
+    char lcbuf[18];
+    const char *p = token;
+    char c, *q = lcbuf;
+    size_t len = 0;
+    uint64_t crc = UINT64_C(0x076259c3e291c26c);
+
+    while ((c = *p++)) {
+        if (++len > 17)
+            goto notfound;
+        *q++ = c = nasm_tolower(c);
+        crc = crc64_byte(crc, c);
+    };
+
+    k1 = ((uint32_t)crc & 0x3ffe) + 0;
+    k2 = ((uint32_t)(crc >> 32) & 0x3ffe) + 1;
+
+    ix = hashdata[k1] + hashdata[k2];
+    if (ix >= 2594)
+        goto notfound;
+
+    data = &tokendata[ix];
+    if (data->len != len)
+        goto notfound;
+    if (memcmp(data->string, lcbuf, len))
+        goto notfound;
+
+    tv->t_integer = data->num;
+    tv->t_inttwo  = data->aux;
+    tv->t_flag    = data->tokflag;
+    return tv->t_type = data->tokentype;
+
+notfound:
+    tv->t_integer = 0;
+    tv->t_inttwo  = 0;
+    tv->t_flag    = 0;
+    return tv->t_type = TOKEN_ID;
+}
diff --git a/vere/ext/nasm/asm/tokhash.pl b/vere/ext/nasm/asm/tokhash.pl
new file mode 100755
index 0000000..1f19647
--- /dev/null
+++ b/vere/ext/nasm/asm/tokhash.pl
@@ -0,0 +1,282 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# Generate a perfect hash for token parsing
+#
+# Usage: tokenhash.pl insns.dat regs.dat tokens.dat
+#
+
+require 'phash.ph';
+
+my($output, $insnsn_c, $regs_dat, $tokens_dat) = @ARGV;
+
+%tokens = ();
+@tokendata = ();
+
+#
+# List of condition codes
+#
+@conditions = ('a', 'ae', 'b', 'be', 'c', 'e', 'g', 'ge', 'l', 'le',
+	       'na', 'nae', 'nb', 'nbe', 'nc', 'ne', 'ng', 'nge', 'nl',
+	       'nle', 'no', 'np', 'ns', 'nz', 'o', 'p', 'pe', 'po', 's', 'z');
+
+#
+# Read insnsn.c
+#
+open(ID, '<', $insnsn_c) or die "$0: cannot open $insnsn_c: $!\n";
+while (defined($line = <ID>)) {
+    next unless ($line =~ /^\s*\"([\?\@a-z0-9_]+)\"/);
+
+    my $token = $1;
+    next if (defined($tokens{$token}));	# This should never happen
+
+    $tokens{$token} = scalar @tokendata;
+    push(@tokendata, "\"${token}\", ".length($token).
+	 ", TOKEN_INSN, 0, 0, I_\U${token}");
+}
+close(ID);
+
+#
+# Read regs.dat
+#
+open(RD, '<', $regs_dat) or die "$0: cannot open $regs_dat: $!\n";
+while (defined($line = <RD>)) {
+    if ($line =~ /^([\?\@a-z0-9_-]+)\s*\S+\s*\S+\s*[0-9]+\s*(\S*)/) {
+	$reg = $1;
+	$reg_flag = $2;
+
+	if ($reg =~ /^(.*[^0-9])([0-9]+)\-([0-9]+)(|[^0-9].*)$/) {
+	    $nregs = $3-$2+1;
+	    $reg = $1.$2.$4;
+	    $reg_nr = $2;
+	    $reg_prefix = $1;
+	    $reg_suffix = $4;
+	} else {
+	    $nregs = 1;
+	    undef $reg_prefix;
+	    undef $reg_suffix;
+	}
+
+	while ($nregs--) {
+	    if (defined($tokens{$reg})) {
+		die "Duplicate definition: $reg\n";
+	    }
+	    $tokens{$reg} = scalar @tokendata;
+	    $reg_flag = '0' if ($reg_flag eq '');
+	    push(@tokendata, "\"${reg}\", ".length($reg).", TOKEN_REG, 0, ${reg_flag}, R_\U${reg}\E");
+
+	    if (defined($reg_prefix)) {
+		$reg_nr++;
+		$reg = sprintf("%s%u%s", $reg_prefix, $reg_nr, $reg_suffix);
+	    } else {
+		# Not a dashed sequence
+		die if ($nregs);
+	    }
+	}
+    }
+}
+close(RD);
+
+#
+# Read tokens.dat
+#
+open(TD, '<', $tokens_dat) or die "$0: cannot open $tokens_dat: $!\n";
+while (defined($line = <TD>)) {
+    $line =~ s/\s*(|\#.*)$//;
+    if ($line =~ /^\%\s+(.*)$/) {
+	$pattern = $1;
+    } elsif ($line =~ /^(\S+)/) {
+	$token = $1;
+
+	if (defined($tokens{$token})) {
+	    die "Duplicate definition: $token\n";
+	}
+	$tokens{$token} = scalar @tokendata;
+
+	$data = $pattern;
+	if ($data =~ /^(.*)\{(.*)\}(.*)$/) {
+	    my $head = $1, $tail = $3;
+	    my $px = $2;
+
+	    $px =~ s/\?/\\?/g;
+	    $px =~ s/\*/(.*)/g;
+	    if ($token =~ /$px/i) {
+		$data = $head."\U$1".$tail;
+	    } else {
+		die "$0: token $token doesn't match $px\n";
+	    }
+	}
+
+	$data =~ s/\*/\U$token/g;
+	$data =~ s/\?//g;
+
+	push(@tokendata, "\"$token\", ".length($token).", $data");
+    }
+}
+close(TD);
+
+$max_len = 0;
+foreach $token (keys(%tokens)) {
+    if (length($token) > $max_len) {
+	$max_len = length($token);
+    }
+}
+
+if ($output eq 'h') {
+    #
+    # tokens.h
+    #
+
+    print "/*\n";
+    print " * This file is generated from insns.dat, regs.dat and token.dat\n";
+    print " * by tokhash.pl; do not edit.\n";
+    print " */\n";
+    print "\n";
+
+    print "#ifndef NASM_TOKENS_H\n";
+    print "#define NASM_TOKENS_H\n";
+    print "\n";
+    print "#define MAX_KEYWORD $max_len /* length of longest keyword */\n";
+    print "\n";
+    print "#endif /* NASM_TOKENS_H */\n";
+} elsif ($output eq 'c') {
+    #
+    # tokhash.c
+    #
+
+    @hashinfo = gen_perfect_hash(\%tokens);
+    if (!@hashinfo) {
+	die "$0: no hash found\n";
+    }
+
+    # Paranoia...
+    verify_hash_table(\%tokens, \@hashinfo);
+
+    ($n, $sv, $g) = @hashinfo;
+    die if ($n & ($n-1));
+    $n <<= 1;
+
+    print "/*\n";
+    print " * This file is generated from insns.dat, regs.dat and token.dat\n";
+    print " * by tokhash.pl; do not edit.\n";
+    print " */\n";
+    print "\n";
+
+    print "#include \"compiler.h\"\n";
+    print "#include \"nasm.h\"\n";
+    print "#include \"hashtbl.h\"\n";
+    print "#include \"insns.h\"\n";
+    print "#include \"stdscan.h\"\n";
+    print "\n";
+
+    # These somewhat odd sizes and ordering thereof are due to the
+    # relative ranges of the types; this makes it fit in 16 bytes on
+    # 64-bit machines and 12 bytes on 32-bit machines.
+    print "struct tokendata {\n";
+    print "    const char *string;\n";
+    print "    uint16_t len;\n";
+    print "    int16_t tokentype;\n";
+    print "    int16_t aux;\n";
+    print "    uint16_t tokflag;\n";
+    print "    int32_t num;\n";
+    print "};\n";
+    print "\n";
+
+    print "int nasm_token_hash(const char *token, struct tokenval *tv)\n";
+    print "{\n";
+
+    # Put a large value in unused slots.  This makes it extremely unlikely
+    # that any combination that involves unused slot will pass the range test.
+    # This speeds up rejection of unrecognized tokens, i.e. identifiers.
+    print "#define INVALID_HASH_ENTRY (65535/3)\n";
+
+    printf "    static const int16_t hashdata[%d] = {\n", $n;
+    for ($i = 0; $i < $n; $i++) {
+	my $h = ${$g}[$i];
+	print "        ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n";
+    }
+    print "    };\n";
+
+    printf "    static const struct tokendata tokendata[%d] = {\n",
+	scalar(@tokendata);
+    foreach $d (@tokendata) {
+	print "        { ", $d, " },\n";
+    }
+    print  "    };\n";
+
+    print  "    uint32_t k1, k2;\n";
+    # For correct overflow behavior, "ix" should be unsigned of the same
+    # width as the hash arrays.
+    print  "    uint16_t ix;\n";
+    print  "    const struct tokendata *data;\n";
+    printf "    char lcbuf[%d];\n", $max_len+1;
+    print  "    const char *p = token;\n";
+    print  "    char c, *q = lcbuf;\n";
+    print  "    size_t len = 0;\n";
+    printf "    uint64_t crc = UINT64_C(0x%08x%08x);\n", $$sv[0], $$sv[1];
+    print  "\n";
+    print  "    while ((c = *p++)) {\n";
+    printf "        if (++len > %d)\n", $max_len;
+    print  "            goto notfound;\n";
+    print  "        *q++ = c = nasm_tolower(c);\n";
+    print  "        crc = crc64_byte(crc, c);\n";
+    print  "    };\n";
+    print  "\n";
+    printf "    k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2;
+    printf "    k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2;
+    print  "\n";
+    printf "    ix = hashdata[k1] + hashdata[k2];\n",
+	$n-2, $n-2;
+    printf "    if (ix >= %d)\n", scalar(@tokendata);
+    print  "        goto notfound;\n";
+    print  "\n";
+    print  "    data = &tokendata[ix];\n";
+    print  "    if (data->len != len)\n";
+    print  "        goto notfound;\n";
+    print  "    if (memcmp(data->string, lcbuf, len))\n";
+    print  "        goto notfound;\n";
+    print  "\n";
+    print  "    tv->t_integer = data->num;\n";
+    print  "    tv->t_inttwo  = data->aux;\n";
+    print  "    tv->t_flag    = data->tokflag;\n";
+    print  "    return tv->t_type = data->tokentype;\n";
+    print  "\n";
+    print  "notfound:\n";
+    print  "    tv->t_integer = 0;\n";
+    print  "    tv->t_inttwo  = 0;\n";
+    print  "    tv->t_flag    = 0;\n";
+    print  "    return tv->t_type = TOKEN_ID;\n";
+    print  "}\n";
+}
diff --git a/vere/ext/nasm/asm/warnings.c b/vere/ext/nasm/asm/warnings.c
new file mode 100644
index 0000000..f825e0c
--- /dev/null
+++ b/vere/ext/nasm/asm/warnings.c
@@ -0,0 +1,241 @@
+#include "error.h"
+
+const char * const warning_name[53] = {
+	NULL,
+	"db-empty",
+	"ea-absolute",
+	"ea-dispsize",
+	"float-denorm",
+	"float-overflow",
+	"float-toolong",
+	"float-underflow",
+	"forward",
+	"label-orphan",
+	"label-redef",
+	"label-redef-late",
+	"number-overflow",
+	"obsolete-nop",
+	"obsolete-removed",
+	"obsolete-valid",
+	"phase",
+	"pp-else-elif",
+	"pp-else-else",
+	"pp-empty-braces",
+	"pp-environment",
+	"pp-macro-def-case-single",
+	"pp-macro-def-greedy-single",
+	"pp-macro-def-param-single",
+	"pp-macro-defaults",
+	"pp-macro-params-legacy",
+	"pp-macro-params-multi",
+	"pp-macro-params-single",
+	"pp-macro-redef-multi",
+	"pp-open-braces",
+	"pp-open-brackets",
+	"pp-open-string",
+	"pp-rep-negative",
+	"pp-sel-range",
+	"pp-trailing",
+	"pragma-bad",
+	"pragma-empty",
+	"pragma-na",
+	"pragma-unknown",
+	"prefix-bnd",
+	"prefix-hle",
+	"prefix-lock",
+	"prefix-opsize",
+	"prefix-seg",
+	"ptr",
+	"regsize",
+	"unknown-warning",
+	"user",
+	"warn-stack-empty",
+	"zeroing",
+	"zext-reloc",
+	"other",
+	"all"
+};
+
+const struct warning_alias warning_alias[68] = {
+	{ "all",                      WARN_IDX_ALL },
+	{ "bad-pragma",               WARN_IDX_PRAGMA_BAD },
+	{ "bnd",                      WARN_IDX_PREFIX_BND },
+	{ "db-empty",                 WARN_IDX_DB_EMPTY },
+	{ "ea-absolute",              WARN_IDX_EA_ABSOLUTE },
+	{ "ea-dispsize",              WARN_IDX_EA_DISPSIZE },
+	{ "environment",              WARN_IDX_PP_ENVIRONMENT },
+	{ "float-denorm",             WARN_IDX_FLOAT_DENORM },
+	{ "float-overflow",           WARN_IDX_FLOAT_OVERFLOW },
+	{ "float-toolong",            WARN_IDX_FLOAT_TOOLONG },
+	{ "float-underflow",          WARN_IDX_FLOAT_UNDERFLOW },
+	{ "forward",                  WARN_IDX_FORWARD },
+	{ "hle",                      WARN_IDX_PREFIX_HLE },
+	{ "label-orphan",             WARN_IDX_LABEL_ORPHAN },
+	{ "label-redef",              WARN_IDX_LABEL_REDEF },
+	{ "label-redef-late",         WARN_IDX_LABEL_REDEF_LATE },
+	{ "lock",                     WARN_IDX_PREFIX_LOCK },
+	{ "macro-def-case-single",    WARN_IDX_PP_MACRO_DEF_CASE_SINGLE },
+	{ "macro-def-greedy-single",  WARN_IDX_PP_MACRO_DEF_GREEDY_SINGLE },
+	{ "macro-def-param-single",   WARN_IDX_PP_MACRO_DEF_PARAM_SINGLE },
+	{ "macro-defaults",           WARN_IDX_PP_MACRO_DEFAULTS },
+	{ "macro-params-legacy",      WARN_IDX_PP_MACRO_PARAMS_LEGACY },
+	{ "macro-params-multi",       WARN_IDX_PP_MACRO_PARAMS_MULTI },
+	{ "macro-params-single",      WARN_IDX_PP_MACRO_PARAMS_SINGLE },
+	{ "negative-rep",             WARN_IDX_PP_REP_NEGATIVE },
+	{ "not-my-pragma",            WARN_IDX_PRAGMA_NA },
+	{ "number-overflow",          WARN_IDX_NUMBER_OVERFLOW },
+	{ "obsolete-nop",             WARN_IDX_OBSOLETE_NOP },
+	{ "obsolete-removed",         WARN_IDX_OBSOLETE_REMOVED },
+	{ "obsolete-valid",           WARN_IDX_OBSOLETE_VALID },
+	{ "orphan-labels",            WARN_IDX_LABEL_ORPHAN },
+	{ "other",                    WARN_IDX_OTHER },
+	{ "phase",                    WARN_IDX_PHASE },
+	{ "pp-else-elif",             WARN_IDX_PP_ELSE_ELIF },
+	{ "pp-else-else",             WARN_IDX_PP_ELSE_ELSE },
+	{ "pp-empty-braces",          WARN_IDX_PP_EMPTY_BRACES },
+	{ "pp-environment",           WARN_IDX_PP_ENVIRONMENT },
+	{ "pp-macro-def-case-single", WARN_IDX_PP_MACRO_DEF_CASE_SINGLE },
+	{ "pp-macro-def-greedy-single", WARN_IDX_PP_MACRO_DEF_GREEDY_SINGLE },
+	{ "pp-macro-def-param-single", WARN_IDX_PP_MACRO_DEF_PARAM_SINGLE },
+	{ "pp-macro-defaults",        WARN_IDX_PP_MACRO_DEFAULTS },
+	{ "pp-macro-params-legacy",   WARN_IDX_PP_MACRO_PARAMS_LEGACY },
+	{ "pp-macro-params-multi",    WARN_IDX_PP_MACRO_PARAMS_MULTI },
+	{ "pp-macro-params-single",   WARN_IDX_PP_MACRO_PARAMS_SINGLE },
+	{ "pp-macro-redef-multi",     WARN_IDX_PP_MACRO_REDEF_MULTI },
+	{ "pp-open-braces",           WARN_IDX_PP_OPEN_BRACES },
+	{ "pp-open-brackets",         WARN_IDX_PP_OPEN_BRACKETS },
+	{ "pp-open-string",           WARN_IDX_PP_OPEN_STRING },
+	{ "pp-rep-negative",          WARN_IDX_PP_REP_NEGATIVE },
+	{ "pp-sel-range",             WARN_IDX_PP_SEL_RANGE },
+	{ "pp-trailing",              WARN_IDX_PP_TRAILING },
+	{ "pragma-bad",               WARN_IDX_PRAGMA_BAD },
+	{ "pragma-empty",             WARN_IDX_PRAGMA_EMPTY },
+	{ "pragma-na",                WARN_IDX_PRAGMA_NA },
+	{ "pragma-unknown",           WARN_IDX_PRAGMA_UNKNOWN },
+	{ "prefix-bnd",               WARN_IDX_PREFIX_BND },
+	{ "prefix-hle",               WARN_IDX_PREFIX_HLE },
+	{ "prefix-lock",              WARN_IDX_PREFIX_LOCK },
+	{ "prefix-opsize",            WARN_IDX_PREFIX_OPSIZE },
+	{ "prefix-seg",               WARN_IDX_PREFIX_SEG },
+	{ "ptr",                      WARN_IDX_PTR },
+	{ "regsize",                  WARN_IDX_REGSIZE },
+	{ "unknown-pragma",           WARN_IDX_PRAGMA_UNKNOWN },
+	{ "unknown-warning",          WARN_IDX_UNKNOWN_WARNING },
+	{ "user",                     WARN_IDX_USER },
+	{ "warn-stack-empty",         WARN_IDX_WARN_STACK_EMPTY },
+	{ "zeroing",                  WARN_IDX_ZEROING },
+	{ "zext-reloc",               WARN_IDX_ZEXT_RELOC }
+};
+
+const char * const warning_help[53] = {
+	NULL,
+	"no operand for data declaration",
+	"absolute address cannot be RIP-relative",
+	"displacement size ignored on absolute address",
+	"floating point denormal",
+	"floating point overflow",
+	"too many digits in floating-point number",
+	"floating point underflow",
+	"forward reference may have unpredictable results",
+	"labels alone on lines without trailing `:\'",
+	"label redefined to an identical value",
+	"label (re)defined during code generation",
+	"numeric constant does not fit",
+	"instruction obsolete and is a noop on the target CPU",
+	"instruction obsolete and removed on the target CPU",
+	"instruction obsolete but valid on the target CPU",
+	"phase error during stabilization",
+	"%elif after %else",
+	"%else after %else",
+	"empty %{} construct",
+	"nonexistent environment variable",
+	"single-line macro defined both case sensitive and insensitive",
+	"single-line macro",
+	"single-line macro defined with and without parameters",
+	"macros with more default than optional parameters",
+	"improperly calling multi-line macro for legacy support",
+	"multi-line macro calls with wrong parameter count",
+	"single-line macro calls with wrong parameter count",
+	"redefining multi-line macro",
+	"unterminated %{...}",
+	"unterminated %[...]",
+	"unterminated string",
+	"regative %rep count",
+	"%sel() argument out of range",
+	"trailing garbage ignored",
+	"malformed %pragma",
+	"empty %pragma directive",
+	"%pragma not applicable to this compilation",
+	"unknown %pragma facility or directive",
+	"invalid BND prefix",
+	"invalid HLE prefix",
+	"LOCK prefix on unlockable instructions",
+	"invalid operand size prefix",
+	"segment prefix ignored in 64-bit mode",
+	"non-NASM keyword used in other assemblers",
+	"register size specification ignored",
+	"unknown warning in -W/-w or warning directive",
+	"%warning directives",
+	"warning stack empty",
+	"RESx in initialized section becomes zero",
+	"relocation zero-extended to match output format",
+	"any warning not specifically mentioned above",
+	"all possible warnings"
+};
+
+const uint8_t warning_default[52] = {
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_OFF,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_OFF,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_OFF,
+	WARN_INIT_ERR,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_OFF,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ERR,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_OFF,
+	WARN_INIT_OFF,
+	WARN_INIT_OFF,
+	WARN_INIT_OFF,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_OFF,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON,
+	WARN_INIT_ON
+};
+
+uint8_t warning_state[52];	/* Current state */
diff --git a/vere/ext/nasm/asm/warnings.pl b/vere/ext/nasm/asm/warnings.pl
new file mode 100755
index 0000000..599a42d
--- /dev/null
+++ b/vere/ext/nasm/asm/warnings.pl
@@ -0,0 +1,303 @@
+#!/usr/bin/perl
+
+use strict;
+use Fcntl qw(:seek);
+use File::Find;
+use File::Basename;
+
+my @warnings = ();
+my %aliases  = ();
+my %prefixes = ();
+my $err = 0;
+my $nwarn = 0;
+
+sub quote_for_c($) {
+    my $s = join('', @_);
+
+    $s =~ s/([\"\'\\])/\\$1/g;
+    return $s;
+}
+
+sub add_alias($$) {
+    my($a, $this) = @_;
+    my @comp = split(/-/, $a);
+
+    $aliases{$a} = $this;
+
+    # All names are prefixes in their own right, although we only
+    # list the ones that are either prefixes of "proper names" or
+    # the complete alias name.
+    for (my $i = ($a eq $this->{name}) ? 0 : $#comp; $i <= $#comp; $i++) {
+	my $prefix = join('-', @comp[0..$i]);
+	$prefixes{$prefix} = [] unless defined($prefixes{$prefix});
+	push(@{$prefixes{$prefix}}, $a);
+    }
+}
+
+sub find_warnings {
+    my $infile = $_;
+
+    return unless (basename($infile) =~ /^\w.*\.[ch]$/i);
+    open(my $in, '<', $infile)
+	or die "$0: cannot open input file $infile: $!\n";
+
+    my $in_comment = 0;
+    my $nline = 0;
+    my $this;
+    my @doc;
+
+    while (defined(my $l = <$in>)) {
+	$nline++;
+	chomp $l;
+
+	if (!$in_comment) {
+	    $l =~ s/^.*?\/\*.*?\*\///g; # Remove single-line comments
+
+	    if ($l =~ /^.*?(\/\*.*)$/) {
+		# Begin block comment
+		$l = $1;
+		$in_comment = 1;
+	    }
+	}
+
+	if ($in_comment) {
+	    if ($l =~ /\*\//) {
+		# End block comment
+		$in_comment = 0;
+		undef $this;
+	    } elsif ($l =~ /^\s*\/?\*\!(\-|\=|\s*)(.*?)\s*$/) {
+		my $opr = $1;
+		my $str = $2;
+
+		if ($opr eq '' && $str eq '') {
+		    next;
+		} elsif ((!defined($this) || ($opr eq '')) &&
+			 ($str =~ /^([\w\-]+)\s+\[(\w+)\]\s(.*\S)\s*$/)) {
+		    my $name = $1;
+		    my $def = $2;
+		    my $help = $3;
+
+		    my $cname = uc($name);
+		    $cname =~ s/[^A-Z0-9_]+/_/g;
+
+		    $this = {name => $name, cname => $cname,
+			     def => $def, help => $help,
+			     doc => [], file => $infile, line => $nline};
+
+		    if (defined(my $that = $aliases{$name})) {
+			# Duplicate definition?!
+			printf STDERR "%s:%s: warning %s previously defined at %s:%s\n",
+			    $infile, $nline, $name, $that->{file}, $that->{line};
+		    } else {
+			push(@warnings, $this);
+			# Every warning name is also a valid warning alias
+			add_alias($name, $this);
+			$nwarn++;
+		    }
+		} elsif ($opr eq '=') {
+		    # Alias names for warnings
+		    for my $a (split(/,+/, $str)) {
+			add_alias($a, $this);
+		    }
+		} elsif ($opr =~ /^[\-\s]/) {
+		    push(@{$this->{doc}}, "$str\n");
+		} else {
+		    print STDERR "$infile:$nline: malformed warning definition\n";
+		    print STDERR "    $l\n";
+		    $err++;
+		}
+	    } else {
+		undef $this;
+	    }
+	}
+    }
+    close($in);
+}
+
+my($what, $outfile, @indirs) = @ARGV;
+
+if (!defined($outfile)) {
+    die "$0: usage: [c|h|doc] outfile indir...\n";
+}
+
+find({ wanted => \&find_warnings, no_chdir => 1, follow => 1 }, @indirs);
+
+exit(1) if ($err);
+
+my %sort_special = ( 'other' => 1, 'all' => 2 );
+sub sort_warnings {
+    my $an = $a->{name};
+    my $bn = $b->{name};
+    return ($sort_special{$an} <=> $sort_special{$bn}) || ($an cmp $bn);
+}
+
+@warnings = sort sort_warnings @warnings;
+my @warn_noall = @warnings;
+pop @warn_noall if ($warn_noall[$#warn_noall]->{name} eq 'all');
+
+my $outdata;
+open(my $out, '>', \$outdata)
+    or die "$0: cannot create memory file: $!\n";
+
+if ($what eq 'c') {
+    print $out "#include \"error.h\"\n\n";
+    printf $out "const char * const warning_name[%d] = {\n",
+	$#warnings + 2;
+    print $out "\tNULL";
+    foreach my $warn (@warnings) {
+	print $out ",\n\t\"", $warn->{name}, "\"";
+    }
+    print $out "\n};\n\n";
+    printf $out "const struct warning_alias warning_alias[%d] = {",
+	scalar(keys %aliases);
+    my $sep = '';
+    foreach my $alias (sort { $a cmp $b } keys(%aliases)) {
+	printf $out "%s\n\t{ %-27s WARN_IDX_%s }",
+	    $sep, "\"$alias\",", $aliases{$alias}->{cname};
+	$sep = ',';
+    }
+    print $out "\n};\n\n";
+
+    printf $out "const char * const warning_help[%d] = {\n",
+	$#warnings + 2;
+    print $out "\tNULL";
+    foreach my $warn (@warnings) {
+	my $help = quote_for_c($warn->{help});
+	print $out ",\n\t\"", $help, "\"";
+    }
+    print $out "\n};\n\n";
+    printf $out "const uint8_t warning_default[%d] = {\n",
+	$#warn_noall + 2;
+    print $out "\tWARN_INIT_ON"; # for entry 0
+    foreach my $warn (@warn_noall) {
+	print $out ",\n\tWARN_INIT_", uc($warn->{def});
+    }
+    print $out "\n};\n\n";
+    printf $out "uint8_t warning_state[%d];\t/* Current state */\n",
+	$#warn_noall + 2;
+} elsif ($what eq 'h') {
+    my $filename = basename($outfile);
+    my $guard = $filename;
+    $guard =~ s/[^A-Za-z0-9_]+/_/g;
+    $guard = "NASM_\U$guard";
+
+    print $out "#ifndef $guard\n";
+    print $out "#define $guard\n";
+    print $out "\n";
+    print $out "#ifndef WARN_SHR\n";
+    print $out "# error \"$filename should only be included from within error.h\"\n";
+    print $out "#endif\n\n";
+    print $out "enum warn_index {\n";
+    printf $out "\tWARN_IDX_%-23s = %3d, /* not suppressible */\n", 'NONE', 0;
+    my $n = 1;
+    foreach my $warn (@warnings) {
+	printf $out "\tWARN_IDX_%-23s = %3d%s /* %s */\n",
+	    $warn->{cname}, $n,
+	    ($n == $#warnings + 1) ? " " : ",",
+	    $warn->{help};
+	$n++;
+    }
+    print $out "};\n\n";
+
+    print $out "enum warn_const {\n";
+    printf $out "\tWARN_%-27s = %3d << WARN_SHR", 'NONE', 0;
+    $n = 1;
+    foreach my $warn (@warn_noall) {
+	printf $out ",\n\tWARN_%-27s = %3d << WARN_SHR", $warn->{cname}, $n++;
+    }
+    print $out "\n};\n\n";
+
+    print $out "struct warning_alias {\n";
+    print $out "\tconst char *name;\n";
+    print $out "\tenum warn_index warning;\n";
+    print $out "};\n\n";
+    printf $out "#define NUM_WARNING_ALIAS %d\n", scalar(keys %aliases);
+
+    printf $out "extern const char * const warning_name[%d];\n",
+	$#warnings + 2;
+    printf $out "extern const char * const warning_help[%d];\n",
+	$#warnings + 2;
+    print $out "extern const struct warning_alias warning_alias[NUM_WARNING_ALIAS];\n";
+    printf $out "extern const uint8_t warning_default[%d];\n",
+	$#warn_noall + 2;
+    printf $out "extern uint8_t warning_state[%d];\n",
+	$#warn_noall + 2;
+    print $out "\n#endif /* $guard */\n";
+} elsif ($what eq 'doc') {
+    my %whatdef = ( 'on' => 'Enabled',
+		    'off' => 'Disabled',
+		    'err' => 'Enabled and promoted to error' );
+
+    my @indexinfo = ();
+    my @outtxt    = ();
+
+    foreach my $pfx (sort { $a cmp $b } keys(%prefixes)) {
+	my $warn = $aliases{$pfx};
+	my @doc;
+
+	if (!defined($warn)) {
+	    my @plist = sort { $a cmp $b } @{$prefixes{$pfx}};
+	    next if ( $#plist < 1 );
+
+	    @doc = ("all \\c{$pfx-} warnings\n\n",
+		    "\\> \\c{$pfx} is a group alias for all warning classes\n",
+		    "prefixed by \\c{$pfx-}; currently\n");
+	    # Just commas is bad grammar to be sure, but it is more
+	    # legible than the alternative.
+	    push(@doc, join(scalar(@plist) < 3 ? ' and ' : ', ',
+			    map { "\\c{$_}" } @plist).".\n");
+	} elsif ($pfx ne $warn->{name}) {
+	    my $awarn = $aliases{$warn->{name}};
+	    @doc = ($awarn->{help}."\n\n",
+		    "\\> \\c{$pfx} is a backwards compatibility alias for \\c{".
+		    $warn->{name}."}.\n");
+	} else {
+	    my $docdef = $whatdef{$warn->{def}};
+
+	    @doc = ($warn->{help}."\n\n",
+		    "\\> \\c{".$warn->{name}."} ");
+
+	    my $newpara = 0;
+	    foreach my $l (@{$warn->{doc}}) {
+		if ($l =~ /^\s*$/) {
+		    $newpara = 1;
+		} else {
+		    if ($newpara && $l !~ /^\\c\s+/) {
+			$l = '\> ' . $l;
+		    }
+		    $newpara = 0;
+		}
+		push(@doc, $l);
+	    }
+	    if (defined($docdef)) {
+		push(@doc, "\n", "\\> $docdef by default.\n");
+	    }
+	}
+
+	push(@indexinfo, "\\IR{w-$pfx} warning class, \\c{$pfx}\n");
+	push(@outtxt, "\\b \\I{w-$pfx} \\c{$pfx}: ", @doc, "\n");
+    }
+
+    print $out "\n", @indexinfo, "\n", @outtxt;
+}
+
+close($out);
+
+# Write data to file if and only if it has changed
+# For some systems, even if we don't write, opening for append
+# apparently touches the timestamp, so we need to read and write
+# as separate operations.
+if (open(my $out, '<', $outfile)) {
+    my $datalen = length($outdata);
+    my $oldlen = read($out, my $oldoutdata, $datalen+1);
+    close($out);
+    exit 0 if (defined($oldlen) && $oldlen == $datalen &&
+	       ($oldoutdata eq $outdata));
+}
+
+# Data changed, must rewrite
+open(my $out, '>', $outfile)
+    or die "$0: cannot open output file $outfile: $!\n";
+
+print $out $outdata;
+close($out);
diff --git a/vere/ext/nasm/build.zig b/vere/ext/nasm/build.zig
new file mode 100644
index 0000000..557a8e5
--- /dev/null
+++ b/vere/ext/nasm/build.zig
@@ -0,0 +1,830 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+pub fn build(b: *std.Build) void {
+    const target = b.graph.host;
+    const optimize = b.standardOptimizeOption(.{});
+    const t = target.result;
+
+    const exe = b.addExecutable(.{
+        .name = "nasm",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    exe.addIncludePath(b.path("include"));
+    exe.addIncludePath(b.path("asm"));
+    exe.addIncludePath(b.path("x86"));
+    exe.addIncludePath(b.path("output"));
+
+    exe.addConfigHeader(b.addConfigHeader(.{
+        .style = .blank,
+        .include_path = "version.h",
+    }, .{
+        .NASM_MAJOR_VER = 2,
+        .NASM_MINOR_VER = 16,
+        .NASM_SUBMINOR_VER = 1,
+        .NASM_PATCHLEVEL_VER = 0,
+        .NASM_VERSION_ID = 0x02100100,
+        .NASM_VER = "2.16.01",
+    }));
+
+    if (b.graph.host.result.os.tag == .windows) {
+        exe.addConfigHeader(b.addConfigHeader(.{
+            .style = .{ .autoconf = b.path("config/config.h.in") },
+            .include_path = "config/config.h",
+        }, .{
+            .ABORT_ON_PANIC = have(optimize == .Debug),
+            .AC_APPLE_UNIVERSAL_BUILD = null,
+            .CFLAGS_FDATA_SECTIONS = null,
+            .CFLAGS_FFUNCTION_SECTIONS = null,
+            .CFLAGS_FGNU89_INLINE = null,
+            .CFLAGS_FLTO = null,
+            .CFLAGS_FNO_COMMON = null,
+            .CFLAGS_FNO_OMIT_FRAME_POINTER = null,
+            .CFLAGS_FSANITIZE_ADDRESS = null,
+            .CFLAGS_FSANITIZE_UNDEFINED = null,
+            .CFLAGS_FTRIVIAL_AUTO_VAR_INIT_ZERO = null,
+            .CFLAGS_FVISIBILITY_HIDDEN = null,
+            .CFLAGS_FWRAPV = null,
+            .CFLAGS_GGDB3 = null,
+            .CFLAGS_O0 = have(optimize == .Debug),
+            .CFLAGS_PEDANTIC = null,
+            .CFLAGS_PG = null,
+            .CFLAGS_STD_C11 = null,
+            .CFLAGS_STD_C17 = 1,
+            .CFLAGS_STD_C99 = null,
+            .CFLAGS_U_STRICT_ANSI = null,
+            .CFLAGS_W = null,
+            .CFLAGS_WALL = null,
+            .CFLAGS_WC90_C99_COMPAT = null,
+            .CFLAGS_WC99_COMPAT = null,
+            .CFLAGS_WC99_EXTENSIONS = null,
+            .CFLAGS_WERROR = null,
+            .CFLAGS_WERROR_ATTRIBUTES = null,
+            .CFLAGS_WERROR_COMMENT = null,
+            .CFLAGS_WERROR_IMPLICIT = null,
+            .CFLAGS_WERROR_MISSING_BRACES = null,
+            .CFLAGS_WERROR_MISSING_DECLARATIONS = null,
+            .CFLAGS_WERROR_MISSING_PROTOTYPES = null,
+            .CFLAGS_WERROR_POINTER_ARITH = null,
+            .CFLAGS_WERROR_RETURN_TYPE = null,
+            .CFLAGS_WERROR_STRICT_PROTOTYPES = null,
+            .CFLAGS_WERROR_TRIGRAPHS = null,
+            .CFLAGS_WERROR_UNKNOWN_WARNING_OPTION = null,
+            .CFLAGS_WERROR_VLA = null,
+            .CFLAGS_WLONG_LONG = null,
+            .CFLAGS_WPEDANTIC_MS_FORMAT = null,
+            .CFLAGS_WSHIFT_NEGATIVE_VALUE = null,
+            .CFLAGS_WSTRINGOP_TRUNCATION = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_COLD = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_CONST = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_FORMAT = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_MALLOC = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_NORETURN = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_PURE = null,
+            .HAVE_ACCESS = 1,
+            .HAVE_CANONICALIZE_FILE_NAME = null,
+            .HAVE_CPU_TO_LE16 = null,
+            .HAVE_CPU_TO_LE32 = null,
+            .HAVE_CPU_TO_LE64 = null,
+            .HAVE_DECL_STRCASECMP = 1,
+            .HAVE_DECL_STRICMP = 0,
+            .HAVE_DECL_STRLCPY = null,
+            .HAVE_DECL_STRNCASECMP = 1,
+            .HAVE_DECL_STRNICMP = 0,
+            .HAVE_DECL_STRNLEN = 0,
+            .HAVE_DECL_STRRCHRNUL = 0,
+            .HAVE_DECL_STRSEP = 0,
+            .HAVE_ENDIAN_H = null,
+            .HAVE_FACCESSAT = 1,
+            .HAVE_FCNTL_H = 1,
+            .HAVE_FILENO = 1,
+            .HAVE_FSEEKO = 1,
+            .HAVE_FSTAT = 1,
+            .HAVE_FTRUNCATE = 1,
+            .HAVE_FUNC_ATTRIBUTE1_ALLOC_SIZE = 1,
+            .HAVE_FUNC_ATTRIBUTE2_ALLOC_SIZE = null,
+            .HAVE_FUNC_ATTRIBUTE3_FORMAT = 1,
+            .HAVE_FUNC_ATTRIBUTE_COLD = 1,
+            .HAVE_FUNC_ATTRIBUTE_CONST = 1,
+            .HAVE_FUNC_ATTRIBUTE_ERROR = 1,
+            .HAVE_FUNC_ATTRIBUTE_MALLOC = 1,
+            .HAVE_FUNC_ATTRIBUTE_NORETURN = 1,
+            .HAVE_FUNC_ATTRIBUTE_PURE = 1,
+            .HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL = 1,
+            .HAVE_FUNC_ATTRIBUTE_SENTINEL = 1,
+            .HAVE_FUNC_ATTRIBUTE_UNUSED = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE1_ALLOC_SIZE = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE2_ALLOC_SIZE = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE3_FORMAT = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_COLD = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_CONST = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_MALLOC = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_NORETURN = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_PURE = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_RETURNS_NONNULL = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_SENTINEL = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_UNUSED = 1,
+            .HAVE_GETGID = null,
+            .HAVE_GETPAGESIZE = null,
+            .HAVE_GETRLIMIT = null,
+            .HAVE_GETUID = null,
+            .HAVE_HTOLE16 = null,
+            .HAVE_HTOLE32 = null,
+            .HAVE_HTOLE64 = null,
+            .HAVE_INTRIN_H = 1,
+            .HAVE_INTTYPES_H = 1,
+            .HAVE_IO_H = null,
+            .HAVE_ISASCII = 1,
+            .HAVE_ISCNTRL = 1,
+            .HAVE_MACHINE_ENDIAN_H = null,
+            .HAVE_MEMPCPY = 1,
+            .HAVE_MEMPSET = null,
+            .HAVE_MINIX_CONFIG_H = null,
+            .HAVE_MMAP = null,
+            .HAVE_PATHCONF = null,
+            .HAVE_REALPATH = null,
+            .HAVE_SNPRINTF = 1,
+            .HAVE_STAT = 1,
+            .HAVE_STDARG_H = 1,
+            .HAVE_STDBOOL_H = 1,
+            .HAVE_STDC_INLINE = 1,
+            .HAVE_STDINT_H = 1,
+            .HAVE_STDIO_H = 1,
+            .HAVE_STDLIB_H = 1,
+            .HAVE_STDNORETURN_H = 1,
+            .HAVE_STRCASECMP = 1,
+            .HAVE_STRICMP = 1,
+            .HAVE_STRINGS_H = 1,
+            .HAVE_STRING_H = 1,
+            .HAVE_STRLCPY = null,
+            .HAVE_STRNCASECMP = 1,
+            .HAVE_STRNICMP = 1,
+            .HAVE_STRNLEN = 1,
+            .HAVE_STRRCHRNUL = null,
+            .HAVE_STRSEP = null,
+            .HAVE_STRUCT_STAT = null,
+            .HAVE_STRUCT__STATI64 = null,
+            .HAVE_SYSCONF = null,
+            .HAVE_SYS_ENDIAN_H = null,
+            .HAVE_SYS_MMAN_H = null,
+            .HAVE_SYS_PARAM_H = null,
+            .HAVE_SYS_RESOURCE_H = null,
+            .HAVE_SYS_STAT_H = 1,
+            .HAVE_SYS_TYPES_H = 1,
+            .HAVE_S_ISREG = null,
+            .HAVE_TYPEOF = null,
+            .HAVE_UINTPTR_T = 1,
+            .HAVE_UNISTD_H = null,
+            .HAVE_VSNPRINTF = 1,
+            .HAVE_WCHAR_H = null,
+            .HAVE__ACCESS = null,
+            .HAVE__BITSCANREVERSE = null,
+            .HAVE__BITSCANREVERSE64 = null,
+            .HAVE__BOOL = 1,
+            .HAVE__BYTESWAP_UINT64 = null,
+            .HAVE__BYTESWAP_ULONG = null,
+            .HAVE__BYTESWAP_USHORT = null,
+            .HAVE__CHSIZE = null,
+            .HAVE__CHSIZE_S = null,
+            .HAVE__FILENO = null,
+            .HAVE__FSEEKI64 = null,
+            .HAVE__FSTATI64 = null,
+            .HAVE__FULLPATH = null,
+            .HAVE__STATI64 = null,
+            .HAVE___BSWAP_16 = 1,
+            .HAVE___BSWAP_32 = 1,
+            .HAVE___BSWAP_64 = 1,
+            .HAVE___BUILTIN_BSWAP16 = 1,
+            .HAVE___BUILTIN_BSWAP32 = 1,
+            .HAVE___BUILTIN_BSWAP64 = 1,
+            .HAVE___BUILTIN_CHOOSE_EXPR = 1,
+            .HAVE___BUILTIN_CLZ = 1,
+            .HAVE___BUILTIN_CLZL = 1,
+            .HAVE___BUILTIN_CLZLL = 1,
+            .HAVE___BUILTIN_CONSTANT_P = 1,
+            .HAVE___BUILTIN_EXPECT = 1,
+            .HAVE___CPU_TO_LE16 = null,
+            .HAVE___CPU_TO_LE32 = null,
+            .HAVE___CPU_TO_LE64 = null,
+            .LDFLAGS_WL_GC_SECTIONS = null,
+            .PACKAGE_BUGREPORT = "",
+            .PACKAGE_NAME = "",
+            .PACKAGE_STRING = "",
+            .PACKAGE_TARNAME = "",
+            .PACKAGE_URL = "",
+            .PACKAGE_VERSION = "",
+            .STDC_HEADERS = 1,
+            ._ALL_SOURCE = 1,
+            ._DARWIN_C_SOURCE = 1,
+            .__EXTENSIONS__ = 1,
+            ._GNU_SOURCE = 1,
+            ._HPUX_ALT_XOPEN_SOCKET_API = 1,
+            ._MINIX = null,
+            ._NETBSD_SOURCE = 1,
+            ._OPENBSD_SOURCE = 1,
+            ._POSIX_SOURCE = null,
+            ._POSIX_1_SOURCE = null,
+            ._POSIX_PTHREAD_SEMANTICS = 1,
+            .__STDC_WANT_IEC_60559_ATTRIBS_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_BFP_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_DFP_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_FUNCS_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_TYPES_EXT__ = 1,
+            .__STDC_WANT_LIB_EXT2__ = 1,
+            .__STDC_WANT_MATH_SPEC_FUNCS__ = 1,
+            ._TANDEM_SOURCE = 1,
+            ._XOPEN_SOURCE = null,
+            .WORDS_BIGENDIAN = have(t.cpu.arch.endian() == .big),
+            .WORDS_LITTLEENDIAN = have(t.cpu.arch.endian() != .big),
+            ._FILE_OFFSET_BITS = null,
+            ._LARGEFILE_SOURCE = null,
+            ._LARGE_FILES = null,
+            .@"const" = .@"const",
+            .@"inline" = .@"inline",
+            .restrict = .restrict,
+            .size_t = null,
+            .snprintf = null,
+            .typeof = .__typeof,
+            .uintptr_t = null,
+            .vsnprintf = null,
+        }));
+    } else if (b.graph.host.result.os.tag.isDarwin()) {
+        exe.addConfigHeader(b.addConfigHeader(.{
+            .style = .{ .autoconf = b.path("config/config.h.in") },
+            .include_path = "config/config.h",
+        }, .{
+            // Define to 1 to call abort() on panics (internal errors), for debugging.
+            .ABORT_ON_PANIC = null,
+            // Define if building universal (internal helper macro)
+            .AC_APPLE_UNIVERSAL_BUILD = null,
+            // Compiler flags
+            .CFLAGS_STD_C11 = null,
+            .CFLAGS_STD_C17 = 1,
+            .CFLAGS_STD_C99 = null,
+            .CFLAGS_WC90_C99_COMPAT = null,
+            .CFLAGS_WC99_COMPAT = null,
+            .CFLAGS_WC99_EXTENSIONS = null,
+            .CFLAGS_WERROR_ATTRIBUTES = null,
+            .CFLAGS_FDATA_SECTIONS = 1,
+            .CFLAGS_FFUNCTION_SECTIONS = 1,
+            .CFLAGS_FGNU89_INLINE = null,
+            .CFLAGS_FLTO = null,
+            .CFLAGS_FNO_COMMON = 1,
+            .CFLAGS_FNO_OMIT_FRAME_POINTER = null,
+            .CFLAGS_FSANITIZE_ADDRESS = null,
+            .CFLAGS_FSANITIZE_UNDEFINED = null,
+            .CFLAGS_FTRIVIAL_AUTO_VAR_INIT_ZERO = 1,
+            .CFLAGS_FVISIBILITY_HIDDEN = 1,
+            .CFLAGS_FWRAPV = 1,
+            .CFLAGS_GGDB3 = 1,
+            .CFLAGS_O0 = have(optimize == .Debug),
+            .CFLAGS_PEDANTIC = 1,
+            .CFLAGS_PG = null,
+            .CFLAGS_U_STRICT_ANSI = 1,
+            .CFLAGS_W = 1,
+            .CFLAGS_WALL = 1,
+            .CFLAGS_WERROR = null,
+            .CFLAGS_WERROR_COMMENT = 1,
+            .CFLAGS_WERROR_IMPLICIT = 1,
+            .CFLAGS_WERROR_MISSING_BRACES = 1,
+            .CFLAGS_WERROR_MISSING_DECLARATIONS = 1,
+            .CFLAGS_WERROR_MISSING_PROTOTYPES = 1,
+            .CFLAGS_WERROR_POINTER_ARITH = 1,
+            .CFLAGS_WERROR_RETURN_TYPE = 1,
+            .CFLAGS_WERROR_STRICT_PROTOTYPES = 1,
+            .CFLAGS_WERROR_TRIGRAPHS = 1,
+            .CFLAGS_WERROR_UNKNOWN_WARNING_OPTION = 1,
+            .CFLAGS_WERROR_VLA = 1,
+            .CFLAGS_WLONG_LONG = null,
+            .CFLAGS_WPEDANTIC_MS_FORMAT = null,
+            .CFLAGS_WSHIFT_NEGATIVE_VALUE = null,
+            .CFLAGS_WSTRINGOP_TRUNCATION = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_COLD = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_CONST = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_FORMAT = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_MALLOC = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_NORETURN = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_PURE = null,
+
+            // Function availability
+            .HAVE_ACCESS = 1,
+            .HAVE_CANONICALIZE_FILE_NAME = null,
+            .HAVE_CPU_TO_LE16 = null,
+            .HAVE_CPU_TO_LE32 = null,
+            .HAVE_CPU_TO_LE64 = null,
+            .HAVE_FACCESSAT = 1,
+            .HAVE_FILENO = 1,
+            .HAVE_FSEEKO = 1,
+            .HAVE_FSTAT = 1,
+            .HAVE_FTRUNCATE = 1,
+            .HAVE_GETGID = 1,
+            .HAVE_GETPAGESIZE = 1,
+            .HAVE_GETRLIMIT = 1,
+            .HAVE_GETUID = 1,
+            .HAVE_HTOLE16 = null,
+            .HAVE_HTOLE32 = null,
+            .HAVE_HTOLE64 = null,
+            .HAVE_ISASCII = 1,
+            .HAVE_ISCNTRL = 1,
+            .HAVE_MEMPCPY = null,
+            .HAVE_MEMPSET = null,
+            .HAVE_MMAP = 1,
+            .HAVE_PATHCONF = 1,
+            .HAVE_REALPATH = 1,
+            .HAVE_SNPRINTF = 1,
+            .HAVE_STAT = 1,
+            .HAVE_STRCASECMP = 1,
+            .HAVE_STRICMP = null,
+            .HAVE_STRLCPY = 1,
+            .HAVE_STRNCASECMP = 1,
+            .HAVE_STRNICMP = null,
+            .HAVE_STRNLEN = 1,
+            .HAVE_STRRCHRNUL = null,
+            .HAVE_STRSEP = 1,
+            .HAVE_SYSCONF = 1,
+            .HAVE_S_ISREG = null,
+            .HAVE_VSNPRINTF = 1,
+            .HAVE__ACCESS = null,
+            .HAVE__BITSCANREVERSE = null,
+            .HAVE__BITSCANREVERSE64 = null,
+            .HAVE__BYTESWAP_UINT64 = null,
+            .HAVE__BYTESWAP_ULONG = null,
+            .HAVE__BYTESWAP_USHORT = null,
+            .HAVE__CHSIZE = null,
+            .HAVE__CHSIZE_S = null,
+            .HAVE__FILENO = null,
+            .HAVE__FSEEKI64 = null,
+            .HAVE__FSTATI64 = null,
+            .HAVE__FULLPATH = null,
+            .HAVE__STATI64 = null,
+
+            // Function declarations
+            .HAVE_DECL_STRCASECMP = 1,
+            .HAVE_DECL_STRICMP = 0,
+            .HAVE_DECL_STRLCPY = 1,
+            .HAVE_DECL_STRNCASECMP = 1,
+            .HAVE_DECL_STRNICMP = 0,
+            .HAVE_DECL_STRNLEN = 1,
+            .HAVE_DECL_STRRCHRNUL = 0,
+            .HAVE_DECL_STRSEP = 1,
+
+            // Header files
+            .HAVE_ENDIAN_H = null,
+            .HAVE_FCNTL_H = 1,
+            .HAVE_INTRIN_H = null,
+            .HAVE_INTTYPES_H = 1,
+            .HAVE_IO_H = null,
+            .HAVE_MACHINE_ENDIAN_H = 1,
+            .HAVE_MINIX_CONFIG_H = null,
+            .HAVE_STDARG_H = 1,
+            .HAVE_STDBOOL_H = 1,
+            .HAVE_STDINT_H = 1,
+            .HAVE_STDIO_H = 1,
+            .HAVE_STDLIB_H = 1,
+            .HAVE_STDNORETURN_H = 1,
+            .HAVE_STRINGS_H = 1,
+            .HAVE_STRING_H = 1,
+            .HAVE_SYS_ENDIAN_H = null,
+            .HAVE_SYS_MMAN_H = 1,
+            .HAVE_SYS_PARAM_H = 1,
+            .HAVE_SYS_RESOURCE_H = 1,
+            .HAVE_SYS_STAT_H = 1,
+            .HAVE_SYS_TYPES_H = 1,
+            .HAVE_UNISTD_H = 1,
+            .HAVE_WCHAR_H = 1,
+
+            // Built-in functions
+            .HAVE___BSWAP_16 = null,
+            .HAVE___BSWAP_32 = null,
+            .HAVE___BSWAP_64 = null,
+            .HAVE___BUILTIN_BSWAP16 = 1,
+            .HAVE___BUILTIN_BSWAP32 = 1,
+            .HAVE___BUILTIN_BSWAP64 = 1,
+            .HAVE___BUILTIN_CHOOSE_EXPR = 1,
+            .HAVE___BUILTIN_CLZ = 1,
+            .HAVE___BUILTIN_CLZL = 1,
+            .HAVE___BUILTIN_CLZLL = 1,
+            .HAVE___BUILTIN_CONSTANT_P = 1,
+            .HAVE___BUILTIN_EXPECT = 1,
+            .HAVE___CPU_TO_LE16 = null,
+            .HAVE___CPU_TO_LE32 = null,
+            .HAVE___CPU_TO_LE64 = null,
+
+            // Function attributes
+            .HAVE_FUNC_ATTRIBUTE1_ALLOC_SIZE = 1,
+            .HAVE_FUNC_ATTRIBUTE2_ALLOC_SIZE = 1,
+            .HAVE_FUNC_ATTRIBUTE3_FORMAT = 1,
+            .HAVE_FUNC_ATTRIBUTE_COLD = 1,
+            .HAVE_FUNC_ATTRIBUTE_CONST = 1,
+            .HAVE_FUNC_ATTRIBUTE_ERROR = 1,
+            .HAVE_FUNC_ATTRIBUTE_MALLOC = null,
+            .HAVE_FUNC_ATTRIBUTE_NORETURN = 1,
+            .HAVE_FUNC_ATTRIBUTE_PURE = 1,
+            .HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL = 1,
+            .HAVE_FUNC_ATTRIBUTE_SENTINEL = 1,
+            .HAVE_FUNC_ATTRIBUTE_UNUSED = 1,
+
+            // Function pointer attributes
+            .HAVE_FUNC_PTR_ATTRIBUTE1_ALLOC_SIZE = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE2_ALLOC_SIZE = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE3_FORMAT = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_COLD = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_CONST = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_MALLOC = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_NORETURN = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_PURE = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_RETURNS_NONNULL = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_SENTINEL = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_UNUSED = 1,
+
+            // Types and features
+            .HAVE_STDC_INLINE = 1,
+            .HAVE_STRUCT_STAT = 1,
+            .HAVE_STRUCT__STATI64 = null,
+            .HAVE_TYPEOF = 1,
+            .HAVE_UINTPTR_T = 1,
+            .HAVE__BOOL = 1,
+
+            // Linker flags
+            .LDFLAGS_WL_GC_SECTIONS = null,
+
+            // Package information
+            .PACKAGE_BUGREPORT = "",
+            .PACKAGE_NAME = "",
+            .PACKAGE_STRING = "",
+            .PACKAGE_TARNAME = "",
+            .PACKAGE_URL = "",
+            .PACKAGE_VERSION = "",
+
+            // Standard headers
+            .STDC_HEADERS = 1,
+
+            // Feature test macros
+            ._ALL_SOURCE = 1,
+            ._DARWIN_C_SOURCE = 1,
+            .__EXTENSIONS__ = 1,
+            ._GNU_SOURCE = 1,
+            ._HPUX_ALT_XOPEN_SOCKET_API = 1,
+            ._MINIX = null,
+            ._NETBSD_SOURCE = 1,
+            ._OPENBSD_SOURCE = 1,
+            ._POSIX_SOURCE = null,
+            ._POSIX_1_SOURCE = null,
+            ._POSIX_PTHREAD_SEMANTICS = 1,
+            .__STDC_WANT_IEC_60559_BFP_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_DFP_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_FUNCS_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_ATTRIBS_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_TYPES_EXT__ = 1,
+            .__STDC_WANT_LIB_EXT2__ = 1,
+            .__STDC_WANT_MATH_SPEC_FUNCS__ = 1,
+            ._TANDEM_SOURCE = 1,
+            ._XOPEN_SOURCE = null,
+
+            // Endianness
+            .WORDS_BIGENDIAN = null,
+            .WORDS_LITTLEENDIAN = 1,
+
+            // File offset bits
+            ._FILE_OFFSET_BITS = null,
+            ._LARGEFILE_SOURCE = null,
+            ._LARGE_FILES = null,
+
+            // Type definitions and replacements
+            .@"const" = null,
+            .@"inline" = null,
+            .restrict = .__restrict__,
+            .size_t = null,
+            .snprintf = null,
+            .typeof = .__typeof,
+            .uintptr_t = null,
+            .vsnprintf = null,
+        }));
+    } else if (b.graph.host.result.os.tag == .linux) {
+        exe.addConfigHeader(b.addConfigHeader(.{
+            .style = .{ .autoconf = b.path("config/config.h.in") },
+            .include_path = "config/config.h",
+        }, .{
+            .ABORT_ON_PANIC = have(optimize == .Debug),
+            .AC_APPLE_UNIVERSAL_BUILD = null,
+            .CFLAGS_FDATA_SECTIONS = null,
+            .CFLAGS_FFUNCTION_SECTIONS = null,
+            .CFLAGS_FGNU89_INLINE = null,
+            .CFLAGS_FLTO = null,
+            .CFLAGS_FNO_COMMON = null,
+            .CFLAGS_FNO_OMIT_FRAME_POINTER = null,
+            .CFLAGS_FSANITIZE_ADDRESS = null,
+            .CFLAGS_FSANITIZE_UNDEFINED = null,
+            .CFLAGS_FTRIVIAL_AUTO_VAR_INIT_ZERO = null,
+            .CFLAGS_FVISIBILITY_HIDDEN = null,
+            .CFLAGS_FWRAPV = null,
+            .CFLAGS_GGDB3 = null,
+            .CFLAGS_O0 = have(optimize == .Debug),
+            .CFLAGS_PEDANTIC = null,
+            .CFLAGS_PG = null,
+            .CFLAGS_STD_C11 = null,
+            .CFLAGS_STD_C17 = 1,
+            .CFLAGS_STD_C99 = null,
+            .CFLAGS_U_STRICT_ANSI = null,
+            .CFLAGS_W = null,
+            .CFLAGS_WALL = null,
+            .CFLAGS_WC90_C99_COMPAT = null,
+            .CFLAGS_WC99_COMPAT = null,
+            .CFLAGS_WC99_EXTENSIONS = null,
+            .CFLAGS_WERROR = null,
+            .CFLAGS_WERROR_ATTRIBUTES = null,
+            .CFLAGS_WERROR_COMMENT = null,
+            .CFLAGS_WERROR_IMPLICIT = null,
+            .CFLAGS_WERROR_MISSING_BRACES = null,
+            .CFLAGS_WERROR_MISSING_DECLARATIONS = null,
+            .CFLAGS_WERROR_MISSING_PROTOTYPES = null,
+            .CFLAGS_WERROR_POINTER_ARITH = null,
+            .CFLAGS_WERROR_RETURN_TYPE = null,
+            .CFLAGS_WERROR_STRICT_PROTOTYPES = null,
+            .CFLAGS_WERROR_TRIGRAPHS = null,
+            .CFLAGS_WERROR_UNKNOWN_WARNING_OPTION = null,
+            .CFLAGS_WERROR_VLA = null,
+            .CFLAGS_WLONG_LONG = null,
+            .CFLAGS_WPEDANTIC_MS_FORMAT = null,
+            .CFLAGS_WSHIFT_NEGATIVE_VALUE = null,
+            .CFLAGS_WSTRINGOP_TRUNCATION = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_COLD = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_CONST = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_FORMAT = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_MALLOC = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_NORETURN = null,
+            .CFLAGS_WSUGGEST_ATTRIBUTE_PURE = null,
+            .HAVE_ACCESS = 1,
+            .HAVE_CANONICALIZE_FILE_NAME = null,
+            .HAVE_CPU_TO_LE16 = null,
+            .HAVE_CPU_TO_LE32 = null,
+            .HAVE_CPU_TO_LE64 = null,
+            .HAVE_DECL_STRCASECMP = 0,
+            .HAVE_DECL_STRICMP = 0,
+            .HAVE_DECL_STRLCPY = 0,
+            .HAVE_DECL_STRNCASECMP = 0,
+            .HAVE_DECL_STRNICMP = 0,
+            .HAVE_DECL_STRNLEN = 0,
+            .HAVE_DECL_STRRCHRNUL = 0,
+            .HAVE_DECL_STRSEP = 0,
+            .HAVE_ENDIAN_H = 1,
+            .HAVE_FACCESSAT = 1,
+            .HAVE_FCNTL_H = 1,
+            .HAVE_FILENO = 1,
+            .HAVE_FSEEKO = 1,
+            .HAVE_FSTAT = 1,
+            .HAVE_FTRUNCATE = 1,
+            .HAVE_FUNC_ATTRIBUTE1_ALLOC_SIZE = 1,
+            .HAVE_FUNC_ATTRIBUTE2_ALLOC_SIZE = null,
+            .HAVE_FUNC_ATTRIBUTE3_FORMAT = 1,
+            .HAVE_FUNC_ATTRIBUTE_COLD = 1,
+            .HAVE_FUNC_ATTRIBUTE_CONST = 1,
+            .HAVE_FUNC_ATTRIBUTE_ERROR = 1,
+            .HAVE_FUNC_ATTRIBUTE_MALLOC = 1,
+            .HAVE_FUNC_ATTRIBUTE_NORETURN = 1,
+            .HAVE_FUNC_ATTRIBUTE_PURE = 1,
+            .HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL = 1,
+            .HAVE_FUNC_ATTRIBUTE_SENTINEL = 1,
+            .HAVE_FUNC_ATTRIBUTE_UNUSED = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE1_ALLOC_SIZE = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE2_ALLOC_SIZE = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE3_FORMAT = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_COLD = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_CONST = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_MALLOC = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_NORETURN = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_PURE = null,
+            .HAVE_FUNC_PTR_ATTRIBUTE_RETURNS_NONNULL = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_SENTINEL = 1,
+            .HAVE_FUNC_PTR_ATTRIBUTE_UNUSED = 1,
+            .HAVE_GETGID = null,
+            .HAVE_GETPAGESIZE = null,
+            .HAVE_GETRLIMIT = null,
+            .HAVE_GETUID = null,
+            .HAVE_HTOLE16 = null,
+            .HAVE_HTOLE32 = null,
+            .HAVE_HTOLE64 = null,
+            .HAVE_INTRIN_H = 1,
+            .HAVE_INTTYPES_H = 1,
+            .HAVE_IO_H = null,
+            .HAVE_ISASCII = 1,
+            .HAVE_ISCNTRL = 1,
+            .HAVE_MACHINE_ENDIAN_H = 1,
+            .HAVE_MEMPCPY = 1,
+            .HAVE_MEMPSET = null,
+            .HAVE_MINIX_CONFIG_H = null,
+            .HAVE_MMAP = 1,
+            .HAVE_PATHCONF = null,
+            .HAVE_REALPATH = 1,
+            .HAVE_SNPRINTF = 1,
+            .HAVE_STAT = 1,
+            .HAVE_STDARG_H = 1,
+            .HAVE_STDBOOL_H = 1,
+            .HAVE_STDC_INLINE = 1,
+            .HAVE_STDINT_H = 1,
+            .HAVE_STDIO_H = 1,
+            .HAVE_STDLIB_H = 1,
+            .HAVE_STDNORETURN_H = 1,
+            .HAVE_STRCASECMP = 1,
+            .HAVE_STRICMP = 1,
+            .HAVE_STRINGS_H = 1,
+            .HAVE_STRING_H = 1,
+            .HAVE_STRLCPY = null,
+            .HAVE_STRNCASECMP = 1,
+            .HAVE_STRNICMP = 1,
+            .HAVE_STRNLEN = 1,
+            .HAVE_STRRCHRNUL = null,
+            .HAVE_STRSEP = null,
+            .HAVE_STRUCT_STAT = null,
+            .HAVE_STRUCT__STATI64 = null,
+            .HAVE_SYSCONF = null,
+            .HAVE_SYS_ENDIAN_H = 1,
+            .HAVE_SYS_MMAN_H = 1,
+            .HAVE_SYS_PARAM_H = null,
+            .HAVE_SYS_RESOURCE_H = null,
+            .HAVE_SYS_STAT_H = 1,
+            .HAVE_SYS_TYPES_H = 1,
+            .HAVE_S_ISREG = null,
+            .HAVE_TYPEOF = null,
+            .HAVE_UINTPTR_T = 1,
+            .HAVE_UNISTD_H = null,
+            .HAVE_VSNPRINTF = null,
+            .HAVE_WCHAR_H = null,
+            .HAVE__ACCESS = null,
+            .HAVE__BITSCANREVERSE = null,
+            .HAVE__BITSCANREVERSE64 = null,
+            .HAVE__BOOL = 1,
+            .HAVE__BYTESWAP_UINT64 = null,
+            .HAVE__BYTESWAP_ULONG = null,
+            .HAVE__BYTESWAP_USHORT = null,
+            .HAVE__CHSIZE = null,
+            .HAVE__CHSIZE_S = null,
+            .HAVE__FILENO = null,
+            .HAVE__FSEEKI64 = null,
+            .HAVE__FSTATI64 = null,
+            .HAVE__FULLPATH = null,
+            .HAVE__STATI64 = null,
+            .HAVE___BSWAP_16 = 1,
+            .HAVE___BSWAP_32 = 1,
+            .HAVE___BSWAP_64 = 1,
+            .HAVE___BUILTIN_BSWAP16 = 1,
+            .HAVE___BUILTIN_BSWAP32 = 1,
+            .HAVE___BUILTIN_BSWAP64 = 1,
+            .HAVE___BUILTIN_CHOOSE_EXPR = 1,
+            .HAVE___BUILTIN_CLZ = 1,
+            .HAVE___BUILTIN_CLZL = 1,
+            .HAVE___BUILTIN_CLZLL = 1,
+            .HAVE___BUILTIN_CONSTANT_P = 1,
+            .HAVE___BUILTIN_EXPECT = 1,
+            .HAVE___CPU_TO_LE16 = null,
+            .HAVE___CPU_TO_LE32 = null,
+            .HAVE___CPU_TO_LE64 = null,
+            .LDFLAGS_WL_GC_SECTIONS = null,
+            .PACKAGE_BUGREPORT = "",
+            .PACKAGE_NAME = "",
+            .PACKAGE_STRING = "",
+            .PACKAGE_TARNAME = "",
+            .PACKAGE_URL = "",
+            .PACKAGE_VERSION = "",
+            .STDC_HEADERS = 1,
+            ._ALL_SOURCE = 1,
+            ._DARWIN_C_SOURCE = 1,
+            .__EXTENSIONS__ = 1,
+            ._GNU_SOURCE = 1,
+            ._HPUX_ALT_XOPEN_SOCKET_API = 1,
+            ._MINIX = null,
+            ._NETBSD_SOURCE = 1,
+            ._OPENBSD_SOURCE = 1,
+            ._POSIX_SOURCE = null,
+            ._POSIX_1_SOURCE = null,
+            ._POSIX_PTHREAD_SEMANTICS = 1,
+            .__STDC_WANT_IEC_60559_ATTRIBS_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_BFP_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_DFP_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_FUNCS_EXT__ = 1,
+            .__STDC_WANT_IEC_60559_TYPES_EXT__ = 1,
+            .__STDC_WANT_LIB_EXT2__ = 1,
+            .__STDC_WANT_MATH_SPEC_FUNCS__ = 1,
+            ._TANDEM_SOURCE = 1,
+            ._XOPEN_SOURCE = null,
+            .WORDS_BIGENDIAN = have(t.cpu.arch.endian() == .big),
+            .WORDS_LITTLEENDIAN = have(t.cpu.arch.endian() != .big),
+            ._FILE_OFFSET_BITS = null,
+            ._LARGEFILE_SOURCE = null,
+            ._LARGE_FILES = null,
+            .@"const" = .@"const",
+            .@"inline" = .@"inline",
+            .restrict = .restrict,
+            .size_t = null,
+            .snprintf = null,
+            .typeof = .__typeof,
+            .uintptr_t = null,
+            .vsnprintf = null,
+        }));
+    }
+
+    const files = [_][]const u8{
+        "nasmlib/alloc.c",
+        "nasmlib/asprintf.c",
+        "nasmlib/badenum.c",
+        "nasmlib/bsi.c",
+        "nasmlib/crc32.c",
+        "nasmlib/crc64.c",
+        "nasmlib/file.c",
+        "nasmlib/filename.c",
+        "nasmlib/hashtbl.c",
+        "nasmlib/ilog2.c",
+        "nasmlib/md5c.c",
+        "nasmlib/mmap.c",
+        "nasmlib/nctype.c",
+        "nasmlib/path.c",
+        "nasmlib/perfhash.c",
+        "nasmlib/raa.c",
+        "nasmlib/rbtree.c",
+        "nasmlib/readnum.c",
+        "nasmlib/realpath.c",
+        "nasmlib/rlimit.c",
+        "nasmlib/saa.c",
+        "nasmlib/string.c",
+        "nasmlib/strlist.c",
+        "nasmlib/ver.c",
+        "nasmlib/zerobuf.c",
+
+        "asm/assemble.c",
+        "asm/directbl.c",
+        "asm/directiv.c",
+        "asm/error.c",
+        "asm/eval.c",
+        "asm/exprdump.c",
+        "asm/exprlib.c",
+        "asm/floats.c",
+        "asm/labels.c",
+        "asm/listing.c",
+        "asm/nasm.c",
+        "asm/parser.c",
+        "asm/pptok.c",
+        "asm/pragma.c",
+        "asm/preproc.c",
+        "asm/quote.c",
+        "asm/rdstrnum.c",
+        "asm/segalloc.c",
+        "asm/srcfile.c",
+        "asm/stdscan.c",
+        "asm/strfunc.c",
+        "asm/tokhash.c",
+        "asm/warnings.c",
+
+        "stdlib/snprintf.c",
+        "stdlib/strlcpy.c",
+        "stdlib/strnlen.c",
+        "stdlib/strrchrnul.c",
+        "stdlib/vsnprintf.c",
+
+        "x86/disp8.c",
+        "x86/iflag.c",
+        "x86/insnsa.c",
+        "x86/insnsb.c",
+        "x86/insnsd.c",
+        "x86/insnsn.c",
+        "x86/regflags.c",
+        "x86/regs.c",
+        "x86/regvals.c",
+
+        "common/common.c",
+
+        "macros/macros.c",
+
+        "output/codeview.c",
+        "output/legacy.c",
+        "output/nulldbg.c",
+        "output/nullout.c",
+        "output/outaout.c",
+        "output/outas86.c",
+        "output/outbin.c",
+        "output/outcoff.c",
+        "output/outdbg.c",
+        "output/outelf.c",
+        "output/outform.c",
+        "output/outieee.c",
+        "output/outlib.c",
+        "output/outmacho.c",
+        "output/outobj.c",
+    };
+    const flags = [_][]const u8{
+        "-DHAVE_CONFIG_H",
+        "-std=c17",
+        "-Wno-implicit-function-declaration",
+    };
+    exe.addCSourceFiles(.{
+        .files = &files,
+        .flags = &flags,
+    });
+    exe.linkLibC();
+    b.installArtifact(exe);
+}
+
+fn have(c: bool) ?c_int {
+    return if (c) 1 else null;
+}
diff --git a/vere/ext/nasm/build.zig.zon b/vere/ext/nasm/build.zig.zon
new file mode 100644
index 0000000..b45ff77
--- /dev/null
+++ b/vere/ext/nasm/build.zig.zon
@@ -0,0 +1,25 @@
+.{
+    .name = .nasm,
+    .version = "2.16.1-4",
+    .fingerprint = 0x84b9c9eb77047d27,
+    .minimum_zig_version = "0.14.0",
+    .paths = .{
+        "LICENSE",
+        "README.md",
+        "asm",
+        "build.zig",
+        "build.zig.zon",
+        "common",
+        "config",
+        "disasm",
+        "headers",
+        "include",
+        "macros",
+        "misc",
+        "nasmlib",
+        "output",
+        "perllib",
+        "stdlib",
+        "x86",
+    },
+}
diff --git a/vere/ext/nasm/common/common.c b/vere/ext/nasm/common/common.c
new file mode 100644
index 0000000..aa77805
--- /dev/null
+++ b/vere/ext/nasm/common/common.c
@@ -0,0 +1,65 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2021 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * common.c - code common to nasm and ndisasm
+ */
+
+#include "compiler.h"
+#include "nasm.h"
+#include "nasmlib.h"
+#include "insns.h"
+
+/*
+ * The current bit size of the CPU
+ */
+int globalbits = 0;
+/*
+ * Common list of prefix names; ideally should be auto-generated
+ * from tokens.dat. This MUST match the enum in include/nasm.h.
+ */
+const char *prefix_name(int token)
+{
+    static const char *prefix_names[] = {
+        "a16", "a32", "a64", "asp", "lock", "o16", "o32", "o64", "osp",
+        "rep", "repe", "repne", "repnz", "repz", "times", "wait",
+        "xacquire", "xrelease", "bnd", "nobnd", "{rex}", "{evex}", "{vex}",
+        "{vex3}", "{vex2}"
+    };
+    unsigned int prefix = token-PREFIX_ENUM_START;
+
+    if (prefix >= ARRAY_SIZE(prefix_names))
+	return NULL;
+
+    return prefix_names[prefix];
+}
diff --git a/vere/ext/nasm/config/config.h.in b/vere/ext/nasm/config/config.h.in
new file mode 100644
index 0000000..eb99190
--- /dev/null
+++ b/vere/ext/nasm/config/config.h.in
@@ -0,0 +1,913 @@
+/* config/config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 to call abort() on panics (internal errors), for debugging. */
+#undef ABORT_ON_PANIC
+
+/* Define if building universal (internal helper macro) */
+#undef AC_APPLE_UNIVERSAL_BUILD
+
+/* Define to 1 if compiled with the `-fdata-sections' compiler flag */
+#undef CFLAGS_FDATA_SECTIONS
+
+/* Define to 1 if compiled with the `-ffunction-sections' compiler flag */
+#undef CFLAGS_FFUNCTION_SECTIONS
+
+/* Define to 1 if compiled with the `-fgnu89-inline' compiler flag */
+#undef CFLAGS_FGNU89_INLINE
+
+/* Define to 1 if compiled with the `-flto' compiler flag */
+#undef CFLAGS_FLTO
+
+/* Define to 1 if compiled with the `-fno-common' compiler flag */
+#undef CFLAGS_FNO_COMMON
+
+/* Define to 1 if compiled with the `-fno-omit-frame-pointer' compiler flag */
+#undef CFLAGS_FNO_OMIT_FRAME_POINTER
+
+/* Define to 1 if compiled with the `-fsanitize=address' compiler flag */
+#undef CFLAGS_FSANITIZE_ADDRESS
+
+/* Define to 1 if compiled with the `-fsanitize=undefined' compiler flag */
+#undef CFLAGS_FSANITIZE_UNDEFINED
+
+/* Define to 1 if compiled with the `-ftrivial-auto-var-init=zero' compiler
+   flag */
+#undef CFLAGS_FTRIVIAL_AUTO_VAR_INIT_ZERO
+
+/* Define to 1 if compiled with the `-fvisibility=hidden' compiler flag */
+#undef CFLAGS_FVISIBILITY_HIDDEN
+
+/* Define to 1 if compiled with the `-fwrapv' compiler flag */
+#undef CFLAGS_FWRAPV
+
+/* Define to 1 if compiled with the `-ggdb3' compiler flag */
+#undef CFLAGS_GGDB3
+
+/* Define to 1 if compiled with the `-O0' compiler flag */
+#undef CFLAGS_O0
+
+/* Define to 1 if compiled with the `-pedantic' compiler flag */
+#undef CFLAGS_PEDANTIC
+
+/* Define to 1 if compiled with the `-pg' compiler flag */
+#undef CFLAGS_PG
+
+/* Define to 1 if compiled with the `-std=c11' compiler flag */
+#undef CFLAGS_STD_C11
+
+/* Define to 1 if compiled with the `-std=c17' compiler flag */
+#undef CFLAGS_STD_C17
+
+/* Define to 1 if compiled with the `-std=c99' compiler flag */
+#undef CFLAGS_STD_C99
+
+/* Define to 1 if compiled with the `-U__STRICT_ANSI__' compiler flag */
+#undef CFLAGS_U_STRICT_ANSI
+
+/* Define to 1 if compiled with the `-W' compiler flag */
+#undef CFLAGS_W
+
+/* Define to 1 if compiled with the `-Wall' compiler flag */
+#undef CFLAGS_WALL
+
+/* Define to 1 if compiled with the `-Wc90-c99-compat' compiler flag */
+#undef CFLAGS_WC90_C99_COMPAT
+
+/* Define to 1 if compiled with the `-Wc99-compat' compiler flag */
+#undef CFLAGS_WC99_COMPAT
+
+/* Define to 1 if compiled with the `-Wc99-extensions' compiler flag */
+#undef CFLAGS_WC99_EXTENSIONS
+
+/* Define to 1 if compiled with the `-Werror' compiler flag */
+#undef CFLAGS_WERROR
+
+/* Define to 1 if compiled with the `-Werror=attributes' compiler flag */
+#undef CFLAGS_WERROR_ATTRIBUTES
+
+/* Define to 1 if compiled with the `-Werror=comment' compiler flag */
+#undef CFLAGS_WERROR_COMMENT
+
+/* Define to 1 if compiled with the `-Werror=implicit' compiler flag */
+#undef CFLAGS_WERROR_IMPLICIT
+
+/* Define to 1 if compiled with the `-Werror=missing-braces' compiler flag */
+#undef CFLAGS_WERROR_MISSING_BRACES
+
+/* Define to 1 if compiled with the `-Werror=missing-declarations' compiler
+   flag */
+#undef CFLAGS_WERROR_MISSING_DECLARATIONS
+
+/* Define to 1 if compiled with the `-Werror=missing-prototypes' compiler flag
+   */
+#undef CFLAGS_WERROR_MISSING_PROTOTYPES
+
+/* Define to 1 if compiled with the `-Werror=pointer-arith' compiler flag */
+#undef CFLAGS_WERROR_POINTER_ARITH
+
+/* Define to 1 if compiled with the `-Werror=return-type' compiler flag */
+#undef CFLAGS_WERROR_RETURN_TYPE
+
+/* Define to 1 if compiled with the `-Werror=strict-prototypes' compiler flag
+   */
+#undef CFLAGS_WERROR_STRICT_PROTOTYPES
+
+/* Define to 1 if compiled with the `-Werror=trigraphs' compiler flag */
+#undef CFLAGS_WERROR_TRIGRAPHS
+
+/* Define to 1 if compiled with the `-Werror=unknown-warning-option' compiler
+   flag */
+#undef CFLAGS_WERROR_UNKNOWN_WARNING_OPTION
+
+/* Define to 1 if compiled with the `-Werror=vla' compiler flag */
+#undef CFLAGS_WERROR_VLA
+
+/* Define to 1 if compiled with the `-Wlong-long' compiler flag */
+#undef CFLAGS_WLONG_LONG
+
+/* Define to 1 if compiled with the `-Wpedantic-ms-format' compiler flag */
+#undef CFLAGS_WPEDANTIC_MS_FORMAT
+
+/* Define to 1 if compiled with the `-Wshift-negative-value' compiler flag */
+#undef CFLAGS_WSHIFT_NEGATIVE_VALUE
+
+/* Define to 1 if compiled with the `-Wstringop-truncation' compiler flag */
+#undef CFLAGS_WSTRINGOP_TRUNCATION
+
+/* Define to 1 if compiled with the `-Wsuggest-attribute=cold' compiler flag
+   */
+#undef CFLAGS_WSUGGEST_ATTRIBUTE_COLD
+
+/* Define to 1 if compiled with the `-Wsuggest-attribute=const' compiler flag
+   */
+#undef CFLAGS_WSUGGEST_ATTRIBUTE_CONST
+
+/* Define to 1 if compiled with the `-Wsuggest-attribute=format' compiler flag
+   */
+#undef CFLAGS_WSUGGEST_ATTRIBUTE_FORMAT
+
+/* Define to 1 if compiled with the `-Wsuggest-attribute=malloc' compiler flag
+   */
+#undef CFLAGS_WSUGGEST_ATTRIBUTE_MALLOC
+
+/* Define to 1 if compiled with the `-Wsuggest-attribute=noreturn' compiler
+   flag */
+#undef CFLAGS_WSUGGEST_ATTRIBUTE_NORETURN
+
+/* Define to 1 if compiled with the `-Wsuggest-attribute=pure' compiler flag
+   */
+#undef CFLAGS_WSUGGEST_ATTRIBUTE_PURE
+
+/* Define to 1 if you have the `access' function. */
+#undef HAVE_ACCESS
+
+/* Define to 1 if you have the `canonicalize_file_name' function. */
+#undef HAVE_CANONICALIZE_FILE_NAME
+
+/* Define to 1 if you have the `cpu_to_le16' intrinsic function. */
+#undef HAVE_CPU_TO_LE16
+
+/* Define to 1 if you have the `cpu_to_le32' intrinsic function. */
+#undef HAVE_CPU_TO_LE32
+
+/* Define to 1 if you have the `cpu_to_le64' intrinsic function. */
+#undef HAVE_CPU_TO_LE64
+
+/* Define to 1 if you have the declaration of `strcasecmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRCASECMP
+
+/* Define to 1 if you have the declaration of `stricmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRICMP
+
+/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRLCPY
+
+/* Define to 1 if you have the declaration of `strncasecmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRNCASECMP
+
+/* Define to 1 if you have the declaration of `strnicmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRNICMP
+
+/* Define to 1 if you have the declaration of `strnlen', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRNLEN
+
+/* Define to 1 if you have the declaration of `strrchrnul', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRRCHRNUL
+
+/* Define to 1 if you have the declaration of `strsep', and to 0 if you don't.
+   */
+#undef HAVE_DECL_STRSEP
+
+/* Define to 1 if you have the <endian.h> header file. */
+#undef HAVE_ENDIAN_H
+
+/* Define to 1 if you have the `faccessat' function. */
+#undef HAVE_FACCESSAT
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#undef HAVE_FCNTL_H
+
+/* Define to 1 if you have the `fileno' function. */
+#undef HAVE_FILENO
+
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#undef HAVE_FSEEKO
+
+/* Define to 1 if you have the `fstat' function. */
+#undef HAVE_FSTAT
+
+/* Define to 1 if you have the `ftruncate' function. */
+#undef HAVE_FTRUNCATE
+
+/* Define to 1 if your compiler supports __attribute__((alloc_size)) on
+   functions */
+#undef HAVE_FUNC_ATTRIBUTE1_ALLOC_SIZE
+
+/* Define to 1 if your compiler supports __attribute__((alloc_size)) on
+   functions */
+#undef HAVE_FUNC_ATTRIBUTE2_ALLOC_SIZE
+
+/* Define to 1 if your compiler supports __attribute__((format)) on functions
+   */
+#undef HAVE_FUNC_ATTRIBUTE3_FORMAT
+
+/* Define to 1 if your compiler supports __attribute__((cold)) on functions */
+#undef HAVE_FUNC_ATTRIBUTE_COLD
+
+/* Define to 1 if your compiler supports __attribute__((const)) on functions
+   */
+#undef HAVE_FUNC_ATTRIBUTE_CONST
+
+/* Define to 1 if your compiler supports __attribute__((error)) on functions
+   */
+#undef HAVE_FUNC_ATTRIBUTE_ERROR
+
+/* Define to 1 if your compiler supports __attribute__((malloc)) on functions
+   */
+#undef HAVE_FUNC_ATTRIBUTE_MALLOC
+
+/* Define to 1 if your compiler supports __attribute__((noreturn)) on
+   functions */
+#undef HAVE_FUNC_ATTRIBUTE_NORETURN
+
+/* Define to 1 if your compiler supports __attribute__((pure)) on functions */
+#undef HAVE_FUNC_ATTRIBUTE_PURE
+
+/* Define to 1 if your compiler supports __attribute__((returns_nonnull)) on
+   functions */
+#undef HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL
+
+/* Define to 1 if your compiler supports __attribute__((sentinel)) on
+   functions */
+#undef HAVE_FUNC_ATTRIBUTE_SENTINEL
+
+/* Define to 1 if your compiler supports __attribute__((unused)) on functions
+   */
+#undef HAVE_FUNC_ATTRIBUTE_UNUSED
+
+/* Define to 1 if your compiler supports __attribute__((alloc_size)) on
+   function pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE1_ALLOC_SIZE
+
+/* Define to 1 if your compiler supports __attribute__((alloc_size)) on
+   function pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE2_ALLOC_SIZE
+
+/* Define to 1 if your compiler supports __attribute__((format)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE3_FORMAT
+
+/* Define to 1 if your compiler supports __attribute__((cold)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_COLD
+
+/* Define to 1 if your compiler supports __attribute__((const)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_CONST
+
+/* Define to 1 if your compiler supports __attribute__((malloc)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_MALLOC
+
+/* Define to 1 if your compiler supports __attribute__((noreturn)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_NORETURN
+
+/* Define to 1 if your compiler supports __attribute__((pure)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_PURE
+
+/* Define to 1 if your compiler supports __attribute__((returns_nonnull)) on
+   function pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_RETURNS_NONNULL
+
+/* Define to 1 if your compiler supports __attribute__((sentinel)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_SENTINEL
+
+/* Define to 1 if your compiler supports __attribute__((unused)) on function
+   pointers */
+#undef HAVE_FUNC_PTR_ATTRIBUTE_UNUSED
+
+/* Define to 1 if you have the `getgid' function. */
+#undef HAVE_GETGID
+
+/* Define to 1 if you have the `getpagesize' function. */
+#undef HAVE_GETPAGESIZE
+
+/* Define to 1 if you have the `getrlimit' function. */
+#undef HAVE_GETRLIMIT
+
+/* Define to 1 if you have the `getuid' function. */
+#undef HAVE_GETUID
+
+/* Define to 1 if you have the `htole16' intrinsic function. */
+#undef HAVE_HTOLE16
+
+/* Define to 1 if you have the `htole32' intrinsic function. */
+#undef HAVE_HTOLE32
+
+/* Define to 1 if you have the `htole64' intrinsic function. */
+#undef HAVE_HTOLE64
+
+/* Define to 1 if you have the <intrin.h> header file. */
+#undef HAVE_INTRIN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the <io.h> header file. */
+#undef HAVE_IO_H
+
+/* Define to 1 if you have the `isascii' function. */
+#undef HAVE_ISASCII
+
+/* Define to 1 if you have the `iscntrl' function. */
+#undef HAVE_ISCNTRL
+
+/* Define to 1 if you have the <machine/endian.h> header file. */
+#undef HAVE_MACHINE_ENDIAN_H
+
+/* Define to 1 if you have the `mempcpy' function. */
+#undef HAVE_MEMPCPY
+
+/* Define to 1 if you have the `mempset' function. */
+#undef HAVE_MEMPSET
+
+/* Define to 1 if you have the <minix/config.h> header file. */
+#undef HAVE_MINIX_CONFIG_H
+
+/* Define to 1 if you have a working `mmap' system call. */
+#undef HAVE_MMAP
+
+/* Define to 1 if you have the `pathconf' function. */
+#undef HAVE_PATHCONF
+
+/* Define to 1 if you have the `realpath' function. */
+#undef HAVE_REALPATH
+
+/* Define to 1 if you have some version of the snprintf function. */
+#undef HAVE_SNPRINTF
+
+/* Define to 1 if you have the `stat' function. */
+#undef HAVE_STAT
+
+/* Define to 1 if you have the <stdarg.h> header file. */
+#undef HAVE_STDARG_H
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#undef HAVE_STDBOOL_H
+
+/* Define to 1 if your compiler supports C99 extern inline */
+#undef HAVE_STDC_INLINE
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#undef HAVE_STDIO_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <stdnoreturn.h> header file. */
+#undef HAVE_STDNORETURN_H
+
+/* Define to 1 if you have the `strcasecmp' function. */
+#undef HAVE_STRCASECMP
+
+/* Define to 1 if you have the `stricmp' function. */
+#undef HAVE_STRICMP
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the `strlcpy' function. */
+#undef HAVE_STRLCPY
+
+/* Define to 1 if you have the `strncasecmp' function. */
+#undef HAVE_STRNCASECMP
+
+/* Define to 1 if you have the `strnicmp' function. */
+#undef HAVE_STRNICMP
+
+/* Define to 1 if you have the `strnlen' function. */
+#undef HAVE_STRNLEN
+
+/* Define to 1 if you have the `strrchrnul' function. */
+#undef HAVE_STRRCHRNUL
+
+/* Define to 1 if you have the `strsep' function. */
+#undef HAVE_STRSEP
+
+/* Define to 1 if the system has the type `struct stat'. */
+#undef HAVE_STRUCT_STAT
+
+/* Define to 1 if the system has the type `struct _stati64'. */
+#undef HAVE_STRUCT__STATI64
+
+/* Define to 1 if you have the `sysconf' function. */
+#undef HAVE_SYSCONF
+
+/* Define to 1 if you have the <sys/endian.h> header file. */
+#undef HAVE_SYS_ENDIAN_H
+
+/* Define to 1 if you have the <sys/mman.h> header file. */
+#undef HAVE_SYS_MMAN_H
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#undef HAVE_SYS_PARAM_H
+
+/* Define to 1 if you have the <sys/resource.h> header file. */
+#undef HAVE_SYS_RESOURCE_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the `S_ISREG' function. */
+#undef HAVE_S_ISREG
+
+/* Define to 1 if you have some version of the typeof operator. */
+#undef HAVE_TYPEOF
+
+/* Define to 1 if the system has the type `uintptr_t'. */
+#undef HAVE_UINTPTR_T
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if you have some version of the vsnprintf function. */
+#undef HAVE_VSNPRINTF
+
+/* Define to 1 if you have the <wchar.h> header file. */
+#undef HAVE_WCHAR_H
+
+/* Define to 1 if you have the `_access' function. */
+#undef HAVE__ACCESS
+
+/* Define to 1 if you have the `_BitScanReverse' intrinsic function. */
+#undef HAVE__BITSCANREVERSE
+
+/* Define to 1 if you have the `_BitScanReverse64' intrinsic function. */
+#undef HAVE__BITSCANREVERSE64
+
+/* Define to 1 if the system has the type `_Bool'. */
+#undef HAVE__BOOL
+
+/* Define to 1 if you have the `_byteswap_uint64' intrinsic function. */
+#undef HAVE__BYTESWAP_UINT64
+
+/* Define to 1 if you have the `_byteswap_ulong' intrinsic function. */
+#undef HAVE__BYTESWAP_ULONG
+
+/* Define to 1 if you have the `_byteswap_ushort' intrinsic function. */
+#undef HAVE__BYTESWAP_USHORT
+
+/* Define to 1 if you have the `_chsize' function. */
+#undef HAVE__CHSIZE
+
+/* Define to 1 if you have the `_chsize_s' function. */
+#undef HAVE__CHSIZE_S
+
+/* Define to 1 if you have the `_fileno' function. */
+#undef HAVE__FILENO
+
+/* Define to 1 if you have the `_fseeki64' function. */
+#undef HAVE__FSEEKI64
+
+/* Define to 1 if you have the `_fstati64' function. */
+#undef HAVE__FSTATI64
+
+/* Define to 1 if you have the `_fullpath' function. */
+#undef HAVE__FULLPATH
+
+/* Define to 1 if you have the `_stati64' function. */
+#undef HAVE__STATI64
+
+/* Define to 1 if you have the `__bswap_16' intrinsic function. */
+#undef HAVE___BSWAP_16
+
+/* Define to 1 if you have the `__bswap_32' intrinsic function. */
+#undef HAVE___BSWAP_32
+
+/* Define to 1 if you have the `__bswap_64' intrinsic function. */
+#undef HAVE___BSWAP_64
+
+/* Define to 1 if you have the `__builtin_bswap16' intrinsic function. */
+#undef HAVE___BUILTIN_BSWAP16
+
+/* Define to 1 if you have the `__builtin_bswap32' intrinsic function. */
+#undef HAVE___BUILTIN_BSWAP32
+
+/* Define to 1 if you have the `__builtin_bswap64' intrinsic function. */
+#undef HAVE___BUILTIN_BSWAP64
+
+/* Define to 1 if you have the `__builtin_choose_expr' intrinsic function. */
+#undef HAVE___BUILTIN_CHOOSE_EXPR
+
+/* Define to 1 if you have the `__builtin_clz' intrinsic function. */
+#undef HAVE___BUILTIN_CLZ
+
+/* Define to 1 if you have the `__builtin_clzl' intrinsic function. */
+#undef HAVE___BUILTIN_CLZL
+
+/* Define to 1 if you have the `__builtin_clzll' intrinsic function. */
+#undef HAVE___BUILTIN_CLZLL
+
+/* Define to 1 if you have the `__builtin_constant_p' intrinsic function. */
+#undef HAVE___BUILTIN_CONSTANT_P
+
+/* Define to 1 if you have the `__builtin_expect' intrinsic function. */
+#undef HAVE___BUILTIN_EXPECT
+
+/* Define to 1 if you have the `__cpu_to_le16' intrinsic function. */
+#undef HAVE___CPU_TO_LE16
+
+/* Define to 1 if you have the `__cpu_to_le32' intrinsic function. */
+#undef HAVE___CPU_TO_LE32
+
+/* Define to 1 if you have the `__cpu_to_le64' intrinsic function. */
+#undef HAVE___CPU_TO_LE64
+
+/* Define to 1 if compiled with the `-Wl,--gc-sections' compiler flag */
+#undef LDFLAGS_WL_GC_SECTIONS
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#undef STDC_HEADERS
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# undef _ALL_SOURCE
+#endif
+/* Enable general extensions on macOS.  */
+#ifndef _DARWIN_C_SOURCE
+# undef _DARWIN_C_SOURCE
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# undef __EXTENSIONS__
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# undef _GNU_SOURCE
+#endif
+/* Enable X/Open compliant socket functions that do not require linking
+   with -lxnet on HP-UX 11.11.  */
+#ifndef _HPUX_ALT_XOPEN_SOCKET_API
+# undef _HPUX_ALT_XOPEN_SOCKET_API
+#endif
+/* Identify the host operating system as Minix.
+   This macro does not affect the system headers' behavior.
+   A future release of Autoconf may stop defining this macro.  */
+#ifndef _MINIX
+# undef _MINIX
+#endif
+/* Enable general extensions on NetBSD.
+   Enable NetBSD compatibility extensions on Minix.  */
+#ifndef _NETBSD_SOURCE
+# undef _NETBSD_SOURCE
+#endif
+/* Enable OpenBSD compatibility extensions on NetBSD.
+   Oddly enough, this does nothing on OpenBSD.  */
+#ifndef _OPENBSD_SOURCE
+# undef _OPENBSD_SOURCE
+#endif
+/* Define to 1 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_SOURCE
+# undef _POSIX_SOURCE
+#endif
+/* Define to 2 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_1_SOURCE
+# undef _POSIX_1_SOURCE
+#endif
+/* Enable POSIX-compatible threading on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# undef _POSIX_PTHREAD_SEMANTICS
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
+#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
+# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
+#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
+# undef __STDC_WANT_IEC_60559_BFP_EXT__
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
+#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
+# undef __STDC_WANT_IEC_60559_DFP_EXT__
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
+#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
+# undef __STDC_WANT_IEC_60559_FUNCS_EXT__
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
+#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
+# undef __STDC_WANT_IEC_60559_TYPES_EXT__
+#endif
+/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
+#ifndef __STDC_WANT_LIB_EXT2__
+# undef __STDC_WANT_LIB_EXT2__
+#endif
+/* Enable extensions specified by ISO/IEC 24747:2009.  */
+#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
+# undef __STDC_WANT_MATH_SPEC_FUNCS__
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# undef _TANDEM_SOURCE
+#endif
+/* Enable X/Open extensions.  Define to 500 only if necessary
+   to make mbstate_t available.  */
+#ifndef _XOPEN_SOURCE
+# undef _XOPEN_SOURCE
+#endif
+
+
+/* Define to 1 if your processor stores words with the most significant byte
+   first (like Motorola and SPARC, unlike Intel and VAX). */
+#undef WORDS_BIGENDIAN
+
+/* Define to 1 if your processor stores words with the least significant byte
+   first (like Intel and VAX, unlike Motorola and SPARC). */
+#undef WORDS_LITTLEENDIAN
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+#undef _FILE_OFFSET_BITS
+
+/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */
+#undef _LARGEFILE_SOURCE
+
+/* Define for large files, on AIX-style hosts. */
+#undef _LARGE_FILES
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#undef const
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+#undef inline
+#endif
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported only directly.  */
+#undef restrict
+/* Work around a bug in older versions of Sun C++, which did not
+   #define __restrict__ or support _Restrict or __restrict__
+   even though the corresponding Sun C compiler ended up with
+   "#define restrict _Restrict" or "#define restrict __restrict__"
+   in the previous line.  This workaround can be removed once
+   we assume Oracle Developer Studio 12.5 (2016) or later.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT && !defined __restrict__
+# define _Restrict
+# define __restrict__
+#endif
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
+
+/* Define if your snprintf function is not named snprintf. */
+#undef snprintf
+
+/* Define if your typeof operator is not named `typeof'. */
+#undef typeof
+
+/* Define to the type of an unsigned integer type wide enough to hold a
+   pointer, if such a type exists, and if the system does not define it. */
+#undef uintptr_t
+
+/* Define if your vsnprintf function is not named vsnprintf. */
+#undef vsnprintf
+
+
+/* Begin unconfig.h */
+
+#ifndef alloc_size_func2
+# ifdef HAVE_FUNC_ATTRIBUTE2_ALLOC_SIZE
+#  define alloc_size_func2(x1,x2) __attribute__((alloc_size(x1,x2)))
+# else
+#  define alloc_size_func2(x1,x2)
+# endif
+#endif
+
+#ifndef alloc_size_func2_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE2_ALLOC_SIZE
+#  define alloc_size_func2_ptr(x1,x2) __attribute__((alloc_size(x1,x2)))
+# else
+#  define alloc_size_func2_ptr(x1,x2)
+# endif
+#endif
+
+#ifndef end_with_null
+# ifdef HAVE_FUNC_ATTRIBUTE_SENTINEL
+#  define end_with_null __attribute__((sentinel))
+# else
+#  define end_with_null
+# endif
+#endif
+
+#ifndef end_with_null_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_SENTINEL
+#  define end_with_null_ptr __attribute__((sentinel))
+# else
+#  define end_with_null_ptr
+# endif
+#endif
+
+#ifndef format_func3
+# ifdef HAVE_FUNC_ATTRIBUTE3_FORMAT
+#  define format_func3(x1,x2,x3) __attribute__((format(x1,x2,x3)))
+# else
+#  define format_func3(x1,x2,x3)
+# endif
+#endif
+
+#ifndef format_func3_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE3_FORMAT
+#  define format_func3_ptr(x1,x2,x3) __attribute__((format(x1,x2,x3)))
+# else
+#  define format_func3_ptr(x1,x2,x3)
+# endif
+#endif
+
+#ifndef const_func
+# ifdef HAVE_FUNC_ATTRIBUTE_CONST
+#  define const_func __attribute__((const))
+# else
+#  define const_func
+# endif
+#endif
+
+#ifndef const_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_CONST
+#  define const_func_ptr __attribute__((const))
+# else
+#  define const_func_ptr
+# endif
+#endif
+
+#ifndef pure_func
+# ifdef HAVE_FUNC_ATTRIBUTE_PURE
+#  define pure_func __attribute__((pure))
+# else
+#  define pure_func
+# endif
+#endif
+
+#ifndef pure_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_PURE
+#  define pure_func_ptr __attribute__((pure))
+# else
+#  define pure_func_ptr
+# endif
+#endif
+
+#ifndef noreturn_func
+# ifdef HAVE_FUNC_ATTRIBUTE_NORETURN
+#  define noreturn_func __attribute__((noreturn))
+# else
+#  define noreturn_func
+# endif
+#endif
+
+#ifndef unlikely_func
+# ifdef HAVE_FUNC_ATTRIBUTE_COLD
+#  define unlikely_func __attribute__((cold))
+# else
+#  define unlikely_func
+# endif
+#endif
+
+#ifndef unlikely_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_COLD
+#  define unlikely_func_ptr __attribute__((cold))
+# else
+#  define unlikely_func_ptr
+# endif
+#endif
+
+#ifndef unused_func
+# ifdef HAVE_FUNC_ATTRIBUTE_UNUSED
+#  define unused_func __attribute__((unused))
+# else
+#  define unused_func
+# endif
+#endif
+
+#ifndef unused_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_UNUSED
+#  define unused_func_ptr __attribute__((unused))
+# else
+#  define unused_func_ptr
+# endif
+#endif
+
+#ifndef noreturn_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_NORETURN
+#  define noreturn_func_ptr __attribute__((noreturn))
+# else
+#  define noreturn_func_ptr
+# endif
+#endif
+
+#ifndef never_null
+# ifdef HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL
+#  define never_null __attribute__((returns_nonnull))
+# else
+#  define never_null
+# endif
+#endif
+
+#ifndef never_null_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_RETURNS_NONNULL
+#  define never_null_ptr __attribute__((returns_nonnull))
+# else
+#  define never_null_ptr
+# endif
+#endif
+
+#ifndef malloc_func
+# ifdef HAVE_FUNC_ATTRIBUTE_MALLOC
+#  define malloc_func __attribute__((malloc))
+# else
+#  define malloc_func
+# endif
+#endif
+
+#ifndef malloc_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_MALLOC
+#  define malloc_func_ptr __attribute__((malloc))
+# else
+#  define malloc_func_ptr
+# endif
+#endif
+
+#ifndef alloc_size_func1
+# ifdef HAVE_FUNC_ATTRIBUTE1_ALLOC_SIZE
+#  define alloc_size_func1(x1) __attribute__((alloc_size(x1)))
+# else
+#  define alloc_size_func1(x1)
+# endif
+#endif
+
+#ifndef alloc_size_func1_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE1_ALLOC_SIZE
+#  define alloc_size_func1_ptr(x1) __attribute__((alloc_size(x1)))
+# else
+#  define alloc_size_func1_ptr(x1)
+# endif
+#endif
diff --git a/vere/ext/nasm/config/msvc.h b/vere/ext/nasm/config/msvc.h
new file mode 100644
index 0000000..7f83ace
--- /dev/null
+++ b/vere/ext/nasm/config/msvc.h
@@ -0,0 +1,196 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * config/msvc.h
+ *
+ * Compiler definitions for Microsoft Visual C++;
+ * instead of unconfig.h.  See config.h.in for the
+ * variables which can be defined here.
+ *
+ * MSDN seems to have information back to Visual Studio 2003, so aim
+ * for compatibility that far back.
+ *
+ * Relevant _MSC_VER values:
+ * 1310 - Visual Studio 2003
+ * 1400 - Visual Studio 2005
+ * 1500 - Visual Studio 2008
+ * 1600 - Visual Studio 2010
+ * 1700 - Visual Studio 2012
+ * 1800 - Visual Studio 2013
+ * 1900 - Visual Studio 2015
+ * 1910 - Visual Studio 2017
+ */
+
+#ifndef NASM_CONFIG_MSVC_H
+#define NASM_CONFIG_MSVC_H
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#if _MSC_VER >= 1800
+# define HAVE_INTTYPES_H 1
+#endif
+
+/* Define to 1 if you have the <io.h> header file. */
+#define HAVE_IO_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the `access' function. */
+#define HAVE_ACCESS 1
+#if _MSC_VER < 1400
+# define access _access
+#endif
+
+/* Define to 1 if you have the `fileno' function. */
+#define HAVE_FILENO 1
+#if _MSC_VER < 1400
+# define fileno _fileno
+#endif
+
+/* Define to 1 if you have the `snprintf' function. */
+#define HAVE_SNPRINTF 1
+#if _MSC_VER < 1900
+# define snprintf _snprintf
+#endif
+
+/* Define to 1 if you have the `_chsize' function. */
+#define HAVE__CHSIZE 1
+
+/* Define to 1 if you have the `_chsize_s' function. */
+#if _MSC_VER >= 1400
+# define HAVE__CHSIZE_S 1
+#endif
+
+/* Define to 1 if you have the `_filelengthi64' function. */
+#define HAVE__FILELENGTHI64 1
+
+/* Define to 1 if you have the `_fseeki64' function. */
+#define HAVE__FSEEKI64 1
+
+/* Define to 1 if you have the `_fullpath' function. */
+#define HAVE__FULLPATH 1
+
+/* Define to 1 if the system has the type `struct _stati64'. */
+#define HAVE_STRUCT__STATI64
+
+/* Define to 1 if you have the `_stati64' function. */
+#define HAVE__STATI64 1
+
+/* Define to 1 if you have the `_fstati64' function. */
+#define HAVE__FSTATI64 1
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#if _MSC_VER >= 1800
+# define HAVE_STDBOOL_H 1
+#endif
+
+/* Define to 1 if you have the `stricmp' function. */
+#define HAVE_STRICMP 1
+/* Define to 1 if you have the declaration of `stricmp', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRICMP 1
+#if _MSC_VER < 1400
+# define stricmp _stricmp
+#endif
+
+/* Define to 1 if you have the `strnicmp' function. */
+#define HAVE_STRNICMP 1
+/* Define to 1 if you have the declaration of `strnicmp', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRNICMP 1
+#if _MSC_VER < 1400
+# define strnicmp _strnicmp
+#endif
+
+#if _MSC_VER >= 1400
+/* Define to 1 if you have the `strnlen' function. */
+# define HAVE_STRNLEN 1
+/* Define to 1 if you have the declaration of `strnlen', and to 0 if you
+   don't. */
+# define HAVE_DECL_STRNLEN 1
+#endif
+
+/* Define to 1 if the system has the type `uintptr_t'. */
+#if _MSC_VER >= 1900
+# define HAVE_UINTPTR_T 1
+#else
+/* Define to the type of an unsigned integer type wide enough to hold a
+   pointer, if such a type exists, and if the system does not define it. */
+# define uintptr_t size_t
+#endif
+
+/* Define to 1 if you have the `vsnprintf' function. */
+#define HAVE_VSNPRINTF 1
+#if _MSC_VER < 1400
+# define vsnprint _vsnprintf
+#endif
+
+/* Define to 1 if the system has the type `_Bool'. */
+#if _MSC_VER >= 1900
+# define HAVE__BOOL 1
+#endif
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if your processor stores words with the least significant byte
+   first (like Intel and VAX, unlike Motorola and SPARC). */
+#define WORDS_LITTLEENDIAN 1
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#define inline __inline
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#if _MSC_VER >= 1700
+#define restrict __restrict
+#else
+#define restrict
+#endif
+
+#endif /* NASM_CONFIG_MSVC_H */
diff --git a/vere/ext/nasm/config/unconfig.h b/vere/ext/nasm/config/unconfig.h
new file mode 100644
index 0000000..79cb70a
--- /dev/null
+++ b/vere/ext/nasm/config/unconfig.h
@@ -0,0 +1,182 @@
+/* config/unconfig.h: autogenerated by tools/unconfig.pl */
+
+#ifndef CONFIG_UNCONFIG_H
+#define CONFIG_UNCONFIG_H
+
+#ifndef alloc_size_func2
+# ifdef HAVE_FUNC_ATTRIBUTE2_ALLOC_SIZE
+#  define alloc_size_func2(x1,x2) __attribute__((alloc_size(x1,x2)))
+# else
+#  define alloc_size_func2(x1,x2)
+# endif
+#endif
+
+#ifndef alloc_size_func2_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE2_ALLOC_SIZE
+#  define alloc_size_func2_ptr(x1,x2) __attribute__((alloc_size(x1,x2)))
+# else
+#  define alloc_size_func2_ptr(x1,x2)
+# endif
+#endif
+
+#ifndef end_with_null
+# ifdef HAVE_FUNC_ATTRIBUTE_SENTINEL
+#  define end_with_null __attribute__((sentinel))
+# else
+#  define end_with_null
+# endif
+#endif
+
+#ifndef end_with_null_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_SENTINEL
+#  define end_with_null_ptr __attribute__((sentinel))
+# else
+#  define end_with_null_ptr
+# endif
+#endif
+
+#ifndef format_func3
+# ifdef HAVE_FUNC_ATTRIBUTE3_FORMAT
+#  define format_func3(x1,x2,x3) __attribute__((format(x1,x2,x3)))
+# else
+#  define format_func3(x1,x2,x3)
+# endif
+#endif
+
+#ifndef format_func3_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE3_FORMAT
+#  define format_func3_ptr(x1,x2,x3) __attribute__((format(x1,x2,x3)))
+# else
+#  define format_func3_ptr(x1,x2,x3)
+# endif
+#endif
+
+#ifndef const_func
+# ifdef HAVE_FUNC_ATTRIBUTE_CONST
+#  define const_func __attribute__((const))
+# else
+#  define const_func
+# endif
+#endif
+
+#ifndef const_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_CONST
+#  define const_func_ptr __attribute__((const))
+# else
+#  define const_func_ptr
+# endif
+#endif
+
+#ifndef pure_func
+# ifdef HAVE_FUNC_ATTRIBUTE_PURE
+#  define pure_func __attribute__((pure))
+# else
+#  define pure_func
+# endif
+#endif
+
+#ifndef pure_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_PURE
+#  define pure_func_ptr __attribute__((pure))
+# else
+#  define pure_func_ptr
+# endif
+#endif
+
+#ifndef noreturn_func
+# ifdef HAVE_FUNC_ATTRIBUTE_NORETURN
+#  define noreturn_func __attribute__((noreturn))
+# else
+#  define noreturn_func
+# endif
+#endif
+
+#ifndef unlikely_func
+# ifdef HAVE_FUNC_ATTRIBUTE_COLD
+#  define unlikely_func __attribute__((cold))
+# else
+#  define unlikely_func
+# endif
+#endif
+
+#ifndef unlikely_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_COLD
+#  define unlikely_func_ptr __attribute__((cold))
+# else
+#  define unlikely_func_ptr
+# endif
+#endif
+
+#ifndef unused_func
+# ifdef HAVE_FUNC_ATTRIBUTE_UNUSED
+#  define unused_func __attribute__((unused))
+# else
+#  define unused_func
+# endif
+#endif
+
+#ifndef unused_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_UNUSED
+#  define unused_func_ptr __attribute__((unused))
+# else
+#  define unused_func_ptr
+# endif
+#endif
+
+#ifndef noreturn_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_NORETURN
+#  define noreturn_func_ptr __attribute__((noreturn))
+# else
+#  define noreturn_func_ptr
+# endif
+#endif
+
+#ifndef never_null
+# ifdef HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL
+#  define never_null __attribute__((returns_nonnull))
+# else
+#  define never_null
+# endif
+#endif
+
+#ifndef never_null_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_RETURNS_NONNULL
+#  define never_null_ptr __attribute__((returns_nonnull))
+# else
+#  define never_null_ptr
+# endif
+#endif
+
+#ifndef malloc_func
+# ifdef HAVE_FUNC_ATTRIBUTE_MALLOC
+#  define malloc_func __attribute__((malloc))
+# else
+#  define malloc_func
+# endif
+#endif
+
+#ifndef malloc_func_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE_MALLOC
+#  define malloc_func_ptr __attribute__((malloc))
+# else
+#  define malloc_func_ptr
+# endif
+#endif
+
+#ifndef alloc_size_func1
+# ifdef HAVE_FUNC_ATTRIBUTE1_ALLOC_SIZE
+#  define alloc_size_func1(x1) __attribute__((alloc_size(x1)))
+# else
+#  define alloc_size_func1(x1)
+# endif
+#endif
+
+#ifndef alloc_size_func1_ptr
+# ifdef HAVE_FUNC_PTR_ATTRIBUTE1_ALLOC_SIZE
+#  define alloc_size_func1_ptr(x1) __attribute__((alloc_size(x1)))
+# else
+#  define alloc_size_func1_ptr(x1)
+# endif
+#endif
+
+#endif /* CONFIG_UNCONFIG_H */
diff --git a/vere/ext/nasm/config/unknown.h b/vere/ext/nasm/config/unknown.h
new file mode 100644
index 0000000..d3cbe49
--- /dev/null
+++ b/vere/ext/nasm/config/unknown.h
@@ -0,0 +1,51 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * config/unknown.h
+ *
+ * Compiler definitions for an unknown compiler.  Assume the worst.
+ */
+
+#ifndef NASM_CONFIG_UNKNOWN_H
+#define NASM_CONFIG_UNKNOWN_H
+
+/* Assume these don't exist */
+#ifndef inline
+# define inline
+#endif
+#ifndef restrict
+# define restrict
+#endif
+
+#endif /* NASM_CONFIG_UNKNOWN_H */
diff --git a/vere/ext/nasm/config/watcom.h b/vere/ext/nasm/config/watcom.h
new file mode 100644
index 0000000..8d49026
--- /dev/null
+++ b/vere/ext/nasm/config/watcom.h
@@ -0,0 +1,105 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * config/watcom.h
+ *
+ * Compiler definitions for OpenWatcom instead of config.h.in.
+ *  See config.h.in for the variables which can be defined here.
+ *
+ * This was taken from openwcom.mak and needs to be actually validated.
+ */
+
+#ifndef NASM_CONFIG_WATCOM_H
+#define NASM_CONFIG_WATCOM_H
+
+#define HAVE_DECL_STRCASECMP 1
+#define HAVE_DECL_STRICMP 1
+#define HAVE_DECL_STRLCPY 1
+#define HAVE_DECL_STRNCASECMP 1
+#define HAVE_DECL_STRNICMP 1
+#ifndef __LINUX__
+#define HAVE_IO_H 1
+#endif
+#define HAVE_LIMITS_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_SNPRINTF 1
+#if (__WATCOMC__ >= 1230)
+#undef HAVE__BOOL /* need stdbool.h */
+#define HAVE_STDBOOL_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_UINTPTR_T 1
+#endif
+#define HAVE_STDLIB_H 1
+#define HAVE_STRCSPN 1
+#define HAVE_STRICMP 1
+#define HAVE_STRNICMP 1
+#define HAVE_STRSPN 1
+#define HAVE_STRING_H 1
+#if (__WATCOMC__ >= 1240)
+#define HAVE_STRCASECMP 1
+#define HAVE_STRNCASECMP 1
+#define HAVE_STRLCPY 1
+#define HAVE_STRINGS_H 1
+#endif
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_FCNTL_H 1
+#define HAVE_UNISTD_H 1
+#define HAVE_VSNPRINTF 1
+#define STDC_HEADERS 1
+
+#define HAVE__FULLPATH 1
+#define HAVE_ACCESS
+#define HAVE_STRUCT_STAT
+#define HAVE_STAT
+#define HAVE_FSTAT
+#define HAVE_FILENO
+#ifdef __LINUX__
+#define HAVE_FTRUNCATE
+#else
+#define HAVE_CHSIZE
+#define HAVE__CHSIZE
+#endif
+#define HAVE_ISASCII
+#define HAVE_ISCNTRL
+
+#if (__WATCOMC__ >= 1250)
+#define restrict __restrict
+#else
+#define restrict
+#endif
+#define inline __inline
+
+#endif /* NASM_CONFIG_WATCOM_H */
diff --git a/vere/ext/nasm/disasm/disasm.c b/vere/ext/nasm/disasm/disasm.c
new file mode 100644
index 0000000..ac2dc97
--- /dev/null
+++ b/vere/ext/nasm/disasm/disasm.c
@@ -0,0 +1,1762 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * disasm.c   where all the _work_ gets done in the Netwide Disassembler
+ */
+
+#include "compiler.h"
+
+
+#include "nasm.h"
+#include "disasm.h"
+#include "sync.h"
+#include "insns.h"
+#include "tables.h"
+#include "regdis.h"
+#include "disp8.h"
+
+#define fetch_safe(_start, _ptr, _size, _need, _op)         \
+    do {                                                    \
+        if (((_ptr) - (_start)) >= ((_size) - (_need)))     \
+            _op;                                            \
+    } while (0)
+
+#define fetch_or_return(_start, _ptr, _size, _need)         \
+    fetch_safe(_start, _ptr, _size, _need, return 0)
+
+/*
+ * Flags that go into the `segment' field of `insn' structures
+ * during disassembly.
+ */
+#define SEG_RELATIVE    1
+#define SEG_32BIT       2
+#define SEG_RMREG       4
+#define SEG_DISP8       8
+#define SEG_DISP16     16
+#define SEG_DISP32     32
+#define SEG_NODISP     64
+#define SEG_SIGNED    128
+#define SEG_64BIT     256
+
+/*
+ * Prefix information
+ */
+struct prefix_info {
+    uint8_t osize;      /* Operand size */
+    uint8_t asize;      /* Address size */
+    uint8_t osp;        /* Operand size prefix present */
+    uint8_t asp;        /* Address size prefix present */
+    uint8_t rep;        /* Rep prefix present */
+    uint8_t seg;        /* Segment override prefix present */
+    uint8_t wait;       /* WAIT "prefix" present */
+    uint8_t lock;       /* Lock prefix present */
+    uint8_t vex[3];     /* VEX prefix present */
+    uint8_t vex_c;      /* VEX "class" (VEX, XOP, ...) */
+    uint8_t vex_m;      /* VEX.M field */
+    uint8_t vex_v;
+    uint8_t vex_lp;     /* VEX.LP fields */
+    uint32_t rex;       /* REX prefix present */
+    uint8_t evex[3];    /* EVEX prefix present */
+};
+
+#define getu8(x) (*(uint8_t *)(x))
+#if X86_MEMORY
+/* Littleendian CPU which can handle unaligned references */
+#define getu16(x) (*(uint16_t *)(x))
+#define getu32(x) (*(uint32_t *)(x))
+#define getu64(x) (*(uint64_t *)(x))
+#else
+static uint16_t getu16(uint8_t *data)
+{
+    return (uint16_t)data[0] + ((uint16_t)data[1] << 8);
+}
+static uint32_t getu32(uint8_t *data)
+{
+    return (uint32_t)getu16(data) + ((uint32_t)getu16(data+2) << 16);
+}
+static uint64_t getu64(uint8_t *data)
+{
+    return (uint64_t)getu32(data) + ((uint64_t)getu32(data+4) << 32);
+}
+#endif
+
+#define gets8(x) ((int8_t)getu8(x))
+#define gets16(x) ((int16_t)getu16(x))
+#define gets32(x) ((int32_t)getu32(x))
+#define gets64(x) ((int64_t)getu64(x))
+
+/* Important: regval must already have been adjusted for rex extensions */
+static enum reg_enum whichreg(opflags_t regflags, int regval, int rex)
+{
+    size_t i;
+
+    static const struct {
+        opflags_t       flags;
+        enum reg_enum   reg;
+    } specific_registers[] = {
+        {REG_AL,  R_AL},
+        {REG_AX,  R_AX},
+        {REG_EAX, R_EAX},
+        {REG_RAX, R_RAX},
+        {REG_DL,  R_DL},
+        {REG_DX,  R_DX},
+        {REG_EDX, R_EDX},
+        {REG_RDX, R_RDX},
+        {REG_CL,  R_CL},
+        {REG_CX,  R_CX},
+        {REG_ECX, R_ECX},
+        {REG_RCX, R_RCX},
+        {FPU0,    R_ST0},
+        {XMM0,    R_XMM0},
+        {YMM0,    R_YMM0},
+        {ZMM0,    R_ZMM0},
+        {REG_ES,  R_ES},
+        {REG_CS,  R_CS},
+        {REG_SS,  R_SS},
+        {REG_DS,  R_DS},
+        {REG_FS,  R_FS},
+        {REG_GS,  R_GS},
+        {OPMASK0, R_K0},
+    };
+
+    if (!(regflags & (REGISTER|REGMEM)))
+        return 0;        /* Registers not permissible?! */
+
+    regflags |= REGISTER;
+
+    for (i = 0; i < ARRAY_SIZE(specific_registers); i++)
+        if (!(specific_registers[i].flags & ~regflags))
+            return specific_registers[i].reg;
+
+    /* All the entries below look up regval in an 16-entry array */
+    if (regval < 0 || regval > (rex & REX_EV ? 31 : 15))
+        return 0;
+
+#define GET_REGISTER(__array, __index)                      \
+    ((size_t)(__index) < (size_t)ARRAY_SIZE(__array) ? __array[(__index)] : 0)
+
+    if (!(REG8 & ~regflags)) {
+        if (rex & (REX_P|REX_NH))
+            return GET_REGISTER(nasm_rd_reg8_rex, regval);
+        else
+            return GET_REGISTER(nasm_rd_reg8, regval);
+    }
+    if (!(REG16 & ~regflags))
+        return GET_REGISTER(nasm_rd_reg16, regval);
+    if (!(REG32 & ~regflags))
+        return GET_REGISTER(nasm_rd_reg32, regval);
+    if (!(REG64 & ~regflags))
+        return GET_REGISTER(nasm_rd_reg64, regval);
+    if (!(REG_SREG & ~regflags))
+        return GET_REGISTER(nasm_rd_sreg, regval & 7); /* Ignore REX */
+    if (!(REG_CREG & ~regflags))
+        return GET_REGISTER(nasm_rd_creg, regval);
+    if (!(REG_DREG & ~regflags))
+        return GET_REGISTER(nasm_rd_dreg, regval);
+    if (!(REG_TREG & ~regflags)) {
+        if (regval > 7)
+            return 0;        /* TR registers are ill-defined with rex */
+        return GET_REGISTER(nasm_rd_treg, regval);
+    }
+    if (!(FPUREG & ~regflags))
+        return GET_REGISTER(nasm_rd_fpureg, regval & 7); /* Ignore REX */
+    if (!(MMXREG & ~regflags))
+        return GET_REGISTER(nasm_rd_mmxreg, regval & 7); /* Ignore REX */
+    if (!(XMMREG & ~regflags))
+        return GET_REGISTER(nasm_rd_xmmreg, regval);
+    if (!(YMMREG & ~regflags))
+        return GET_REGISTER(nasm_rd_ymmreg, regval);
+    if (!(ZMMREG & ~regflags))
+        return GET_REGISTER(nasm_rd_zmmreg, regval);
+    if (!(OPMASKREG & ~regflags))
+        return GET_REGISTER(nasm_rd_opmaskreg, regval);
+    if (!(BNDREG & ~regflags))
+        return GET_REGISTER(nasm_rd_bndreg, regval);
+    if (!(TMMREG & ~regflags))
+        return GET_REGISTER(nasm_rd_tmmreg, regval);
+
+#undef GET_REGISTER
+    return 0;
+}
+
+static uint32_t append_evex_reg_deco(char *buf, uint32_t num,
+                                    decoflags_t deco, uint8_t *evex)
+{
+    const char * const er_names[] = {"rn-sae", "rd-sae", "ru-sae", "rz-sae"};
+    uint32_t num_chars = 0;
+
+    if ((deco & MASK) && (evex[2] & EVEX_P2AAA)) {
+        enum reg_enum opmasknum = nasm_rd_opmaskreg[evex[2] & EVEX_P2AAA];
+        const char * regname = nasm_reg_names[opmasknum - EXPR_REG_START];
+
+        num_chars += snprintf(buf + num_chars, num - num_chars,
+                              "{%s}", regname);
+
+        if ((deco & Z) && (evex[2] & EVEX_P2Z)) {
+            num_chars += snprintf(buf + num_chars, num - num_chars,
+                                  "{z}");
+        }
+    }
+
+    if (evex[2] & EVEX_P2B) {
+        if (deco & ER) {
+            uint8_t er_type = (evex[2] & EVEX_P2LL) >> 5;
+            num_chars += snprintf(buf + num_chars, num - num_chars,
+                                  ",{%s}", er_names[er_type]);
+        } else if (deco & SAE) {
+            num_chars += snprintf(buf + num_chars, num - num_chars,
+                                  ",{sae}");
+        }
+    }
+
+    return num_chars;
+}
+
+static uint32_t append_evex_mem_deco(char *buf, uint32_t num, opflags_t type,
+                                     decoflags_t deco, uint8_t *evex)
+{
+    uint32_t num_chars = 0;
+
+    if ((evex[2] & EVEX_P2B) && (deco & BRDCAST_MASK)) {
+        decoflags_t deco_brsize = deco & BRSIZE_MASK;
+        opflags_t template_opsize = brsize_to_size(deco_brsize);
+        unsigned int br_num = (type & SIZE_MASK) / BITS128 *
+            BITS64 / template_opsize * 2;
+
+        num_chars += snprintf(buf + num_chars, num - num_chars,
+                              "{1to%d}", br_num);
+    }
+
+    if ((deco & MASK) && (evex[2] & EVEX_P2AAA)) {
+        enum reg_enum opmasknum = nasm_rd_opmaskreg[evex[2] & EVEX_P2AAA];
+        const char * regname = nasm_reg_names[opmasknum - EXPR_REG_START];
+
+        num_chars += snprintf(buf + num_chars, num - num_chars,
+                              "{%s}", regname);
+
+        if ((deco & Z) && (evex[2] & EVEX_P2Z)) {
+            num_chars += snprintf(buf + num_chars, num - num_chars,
+                                  "{z}");
+        }
+    }
+
+
+    return num_chars;
+}
+
+/*
+ * Process an effective address (ModRM) specification.
+ */
+static uint8_t *do_ea(uint8_t *data, int modrm, int asize,
+                      int segsize, enum ea_type type,
+                      operand *op, insn *ins)
+{
+    int mod, rm, scale, index, base;
+    int rex;
+    uint8_t *evex;
+    uint8_t sib = 0;
+    bool is_evex = !!(ins->rex & REX_EV);
+
+    mod = (modrm >> 6) & 03;
+    rm = modrm & 07;
+
+    if (mod != 3 && asize != 16 && rm == 4)
+        sib = *data++;
+
+    rex  = ins->rex;
+    evex = ins->evex_p;
+
+    if (mod == 3) {             /* pure register version */
+        op->basereg = rm+(rex & REX_B ? 8 : 0);
+        op->segment |= SEG_RMREG;
+        if (is_evex && segsize == 64) {
+            op->basereg += (evex[0] & EVEX_P0X ? 0 : 16);
+        }
+        return data;
+    }
+
+    op->disp_size = 0;
+    op->eaflags = 0;
+
+    if (asize == 16) {
+        /*
+         * <mod> specifies the displacement size (none, byte or
+         * word), and <rm> specifies the register combination.
+         * Exception: mod=0,rm=6 does not specify [BP] as one might
+         * expect, but instead specifies [disp16].
+         */
+
+        if (type != EA_SCALAR)
+            return NULL;
+
+        op->indexreg = op->basereg = -1;
+        op->scale = 1;          /* always, in 16 bits */
+        switch (rm) {
+        case 0:
+            op->basereg = R_BX;
+            op->indexreg = R_SI;
+            break;
+        case 1:
+            op->basereg = R_BX;
+            op->indexreg = R_DI;
+            break;
+        case 2:
+            op->basereg = R_BP;
+            op->indexreg = R_SI;
+            break;
+        case 3:
+            op->basereg = R_BP;
+            op->indexreg = R_DI;
+            break;
+        case 4:
+            op->basereg = R_SI;
+            break;
+        case 5:
+            op->basereg = R_DI;
+            break;
+        case 6:
+            op->basereg = R_BP;
+            break;
+        case 7:
+            op->basereg = R_BX;
+            break;
+        }
+        if (rm == 6 && mod == 0) {      /* special case */
+            op->basereg = -1;
+            if (segsize != 16)
+                op->disp_size = 16;
+            mod = 2;            /* fake disp16 */
+        }
+        switch (mod) {
+        case 0:
+            op->segment |= SEG_NODISP;
+            break;
+        case 1:
+            op->segment |= SEG_DISP8;
+            if (ins->evex_tuple != 0) {
+                op->offset = gets8(data) * get_disp8N(ins);
+            } else {
+                op->offset = gets8(data);
+            }
+            data++;
+            break;
+        case 2:
+            op->segment |= SEG_DISP16;
+            op->offset = *data++;
+            op->offset |= ((unsigned)*data++) << 8;
+            break;
+        }
+        return data;
+    } else {
+        /*
+         * Once again, <mod> specifies displacement size (this time
+         * none, byte or *dword*), while <rm> specifies the base
+         * register. Again, [EBP] is missing, replaced by a pure
+         * disp32 (this time that's mod=0,rm=*5*) in 32-bit mode,
+         * and RIP-relative addressing in 64-bit mode.
+         *
+         * However, rm=4
+         * indicates not a single base register, but instead the
+         * presence of a SIB byte...
+         */
+        int a64 = asize == 64;
+
+        op->indexreg = -1;
+
+        if (a64)
+            op->basereg = nasm_rd_reg64[rm | ((rex & REX_B) ? 8 : 0)];
+        else
+            op->basereg = nasm_rd_reg32[rm | ((rex & REX_B) ? 8 : 0)];
+
+        if (rm == 5 && mod == 0) {
+            if (segsize == 64) {
+                op->eaflags |= EAF_REL;
+                op->segment |= SEG_RELATIVE;
+            }
+
+            if (asize != 64)
+                op->disp_size = asize;
+
+            op->basereg = -1;
+            mod = 2;            /* fake disp32 */
+        }
+
+
+        if (rm == 4) {          /* process SIB */
+            uint8_t vsib_hi = 0;
+            scale = (sib >> 6) & 03;
+            index = (sib >> 3) & 07;
+            base = sib & 07;
+
+            op->scale = 1 << scale;
+
+            if (segsize == 64) {
+                vsib_hi = (rex & REX_X ? 8 : 0) |
+                          (evex[2] & EVEX_P2VP ? 0 : 16);
+            }
+
+            if (type == EA_XMMVSIB)
+                op->indexreg = nasm_rd_xmmreg[index | vsib_hi];
+            else if (type == EA_YMMVSIB)
+                op->indexreg = nasm_rd_ymmreg[index | vsib_hi];
+            else if (type == EA_ZMMVSIB)
+                op->indexreg = nasm_rd_zmmreg[index | vsib_hi];
+            else if (index == 4 && !(rex & REX_X))
+                op->indexreg = -1; /* ESP/RSP cannot be an index */
+            else if (a64)
+                op->indexreg = nasm_rd_reg64[index | ((rex & REX_X) ? 8 : 0)];
+            else
+                op->indexreg = nasm_rd_reg32[index | ((rex & REX_X) ? 8 : 0)];
+
+            if (base == 5 && mod == 0) {
+                op->basereg = -1;
+                mod = 2;    /* Fake disp32 */
+            } else if (a64)
+                op->basereg = nasm_rd_reg64[base | ((rex & REX_B) ? 8 : 0)];
+            else
+                op->basereg = nasm_rd_reg32[base | ((rex & REX_B) ? 8 : 0)];
+
+            if (segsize == 16)
+                op->disp_size = 32;
+        } else if (type != EA_SCALAR) {
+            /* Can't have VSIB without SIB */
+            return NULL;
+        }
+
+        switch (mod) {
+        case 0:
+            op->segment |= SEG_NODISP;
+            break;
+        case 1:
+            op->segment |= SEG_DISP8;
+            if (ins->evex_tuple != 0) {
+                op->offset = gets8(data) * get_disp8N(ins);
+            } else {
+                op->offset = gets8(data);
+            }
+            data++;
+            break;
+        case 2:
+            op->segment |= SEG_DISP32;
+            op->offset = gets32(data);
+            data += 4;
+            break;
+        }
+        return data;
+    }
+}
+
+/*
+ * Determine whether the instruction template in t corresponds to the data
+ * stream in data. Return the number of bytes matched if so.
+ */
+#define case4(x) case (x): case (x)+1: case (x)+2: case (x)+3
+
+static int matches(const struct itemplate *t, uint8_t *data,
+                   const struct prefix_info *prefix, int segsize, insn *ins)
+{
+    uint8_t *r = (uint8_t *)(t->code);
+    uint8_t *origdata = data;
+    bool a_used = false, o_used = false;
+    enum prefixes drep = 0;
+    enum prefixes dwait = 0;
+    uint8_t lock = prefix->lock;
+    int osize = prefix->osize;
+    int asize = prefix->asize;
+    int i, c;
+    int op1, op2;
+    struct operand *opx, *opy;
+    uint8_t opex = 0;
+    bool vex_ok = false;
+    int regmask = (segsize == 64) ? 15 : 7;
+    enum ea_type eat = EA_SCALAR;
+
+    for (i = 0; i < MAX_OPERANDS; i++) {
+        ins->oprs[i].segment = ins->oprs[i].disp_size =
+            (segsize == 64 ? SEG_64BIT : segsize == 32 ? SEG_32BIT : 0);
+    }
+    ins->evex_tuple = 0;
+    ins->rex = prefix->rex;
+    memset(ins->prefixes, 0, sizeof ins->prefixes);
+
+    if (itemp_has(t, (segsize == 64 ? IF_NOLONG : IF_LONG)))
+        return 0;
+
+    if (prefix->rep == 0xF2)
+        drep = (itemp_has(t, IF_BND) ? P_BND : P_REPNE);
+    else if (prefix->rep == 0xF3)
+        drep = P_REP;
+
+    dwait = prefix->wait ? P_WAIT : 0;
+
+    while ((c = *r++) != 0) {
+        op1 = (c & 3) + ((opex & 1) << 2);
+        op2 = ((c >> 3) & 3) + ((opex & 2) << 1);
+        opx = &ins->oprs[op1];
+        opy = &ins->oprs[op2];
+        opex = 0;
+
+        switch (c) {
+        case 01:
+        case 02:
+        case 03:
+        case 04:
+            while (c--)
+                if (*r++ != *data++)
+                    return 0;
+            break;
+
+        case 05:
+        case 06:
+        case 07:
+            opex = c;
+            break;
+
+        case4(010):
+        {
+            int t = *r++, d = *data++;
+            if (d < t || d > t + 7)
+                return 0;
+            else {
+                opx->basereg = (d-t)+
+                    (ins->rex & REX_B ? 8 : 0);
+                opx->segment |= SEG_RMREG;
+            }
+            break;
+        }
+
+        case4(014):
+            /* this is an separate index reg position of MIB operand (ICC) */
+            /* Disassembler uses NASM's split EA form only                 */
+            break;
+
+        case4(0274):
+            opx->offset = (int8_t)*data++;
+            opx->segment |= SEG_SIGNED;
+            break;
+
+        case4(020):
+            opx->offset = *data++;
+            break;
+
+        case4(024):
+            opx->offset = *data++;
+            break;
+
+        case4(030):
+            opx->offset = getu16(data);
+            data += 2;
+            break;
+
+        case4(034):
+            if (osize == 32) {
+                opx->offset = getu32(data);
+                data += 4;
+            } else {
+                opx->offset = getu16(data);
+                data += 2;
+            }
+            if (segsize != asize)
+                opx->disp_size = asize;
+            break;
+
+        case4(040):
+            opx->offset = getu32(data);
+            data += 4;
+            break;
+
+        case4(0254):
+            opx->offset = gets32(data);
+            data += 4;
+            break;
+
+        case4(044):
+            switch (asize) {
+            case 16:
+                opx->offset = getu16(data);
+                data += 2;
+                if (segsize != 16)
+                    opx->disp_size = 16;
+                break;
+            case 32:
+                opx->offset = getu32(data);
+                data += 4;
+                if (segsize == 16)
+                    opx->disp_size = 32;
+                break;
+            case 64:
+                opx->offset = getu64(data);
+                opx->disp_size = 64;
+                data += 8;
+                break;
+            }
+            break;
+
+        case4(050):
+            opx->offset = gets8(data++);
+            opx->segment |= SEG_RELATIVE;
+            break;
+
+        case4(054):
+            opx->offset = getu64(data);
+            data += 8;
+            break;
+
+        case4(060):
+            opx->offset = gets16(data);
+            data += 2;
+            opx->segment |= SEG_RELATIVE;
+            opx->segment &= ~SEG_32BIT;
+            break;
+
+        case4(064):  /* rel */
+            opx->segment |= SEG_RELATIVE;
+            /* In long mode rel is always 32 bits, sign extended. */
+            if (segsize == 64 || osize == 32) {
+                opx->offset = gets32(data);
+                data += 4;
+                if (segsize != 64)
+                    opx->segment |= SEG_32BIT;
+                opx->type = (opx->type & ~SIZE_MASK)
+                    | (segsize == 64 ? BITS64 : BITS32);
+            } else {
+                opx->offset = gets16(data);
+                data += 2;
+                opx->segment &= ~SEG_32BIT;
+                opx->type = (opx->type & ~SIZE_MASK) | BITS16;
+            }
+            break;
+
+        case4(070):
+            opx->offset = gets32(data);
+            data += 4;
+            opx->segment |= SEG_32BIT | SEG_RELATIVE;
+            break;
+
+        case4(0100):
+        case4(0110):
+        case4(0120):
+        case4(0130):
+        {
+            int modrm = *data++;
+            opx->segment |= SEG_RMREG;
+            data = do_ea(data, modrm, asize, segsize, eat, opy, ins);
+            if (!data)
+                return 0;
+            opx->basereg = ((modrm >> 3) & 7) + (ins->rex & REX_R ? 8 : 0);
+            if ((ins->rex & REX_EV) && (segsize == 64))
+                opx->basereg += (ins->evex_p[0] & EVEX_P0RP ? 0 : 16);
+            break;
+        }
+
+        case 0171:
+        {
+            uint8_t t = *r++;
+            uint8_t d = *data++;
+            if ((d ^ t) & ~070) {
+                return 0;
+            } else {
+                op2 = (op2 & ~3) | ((t >> 3) & 3);
+                opy = &ins->oprs[op2];
+                opy->basereg = ((d >> 3) & 7) +
+                    (ins->rex & REX_R ? 8 : 0);
+                opy->segment |= SEG_RMREG;
+            }
+            break;
+        }
+
+        case 0172:
+            {
+                uint8_t ximm = *data++;
+                c = *r++;
+                ins->oprs[c >> 3].basereg = (ximm >> 4) & regmask;
+                ins->oprs[c >> 3].segment |= SEG_RMREG;
+                ins->oprs[c & 7].offset = ximm & 15;
+            }
+            break;
+
+        case 0173:
+            {
+                uint8_t ximm = *data++;
+                c = *r++;
+
+                if ((c ^ ximm) & 15)
+                    return 0;
+
+                ins->oprs[c >> 4].basereg = (ximm >> 4) & regmask;
+                ins->oprs[c >> 4].segment |= SEG_RMREG;
+            }
+            break;
+
+        case4(0174):
+            {
+                uint8_t ximm = *data++;
+
+                opx->basereg = (ximm >> 4) & regmask;
+                opx->segment |= SEG_RMREG;
+            }
+            break;
+
+        case4(0200):
+        case4(0204):
+        case4(0210):
+        case4(0214):
+        case4(0220):
+        case4(0224):
+        case4(0230):
+        case4(0234):
+        {
+            int modrm = *data++;
+            if (((modrm >> 3) & 07) != (c & 07))
+                return 0;   /* spare field doesn't match up */
+            data = do_ea(data, modrm, asize, segsize, eat, opy, ins);
+            if (!data)
+                return 0;
+            break;
+        }
+
+        case4(0240):
+        case 0250:
+        {
+            uint8_t evexm   = *r++;
+            uint8_t evexwlp = *r++;
+            uint8_t modrm, valid_mask;
+            ins->evex_tuple = *r++ - 0300;
+            modrm = *(origdata + 1);
+
+            ins->rex |= REX_EV;
+            if ((prefix->rex & (REX_EV|REX_V|REX_P)) != REX_EV)
+                return 0;
+
+            if ((evexm & 0x1f) != prefix->vex_m)
+                return 0;
+
+            switch (evexwlp & 060) {
+            case 000:
+                if (prefix->rex & REX_W)
+                    return 0;
+                break;
+            case 020:
+                if (!(prefix->rex & REX_W))
+                    return 0;
+                ins->rex |= REX_W;
+                break;
+            case 040:        /* VEX.W is a don't care */
+                ins->rex &= ~REX_W;
+                break;
+            case 060:
+                break;
+            }
+
+            /* If EVEX.b is set with reg-reg op,
+             * EVEX.L'L contains embedded rounding control info
+             */
+            if ((prefix->evex[2] & EVEX_P2B) && ((modrm >> 6) == 3)) {
+                valid_mask = 0x3;   /* prefix only */
+            } else {
+                valid_mask = 0xf;   /* vector length and prefix */
+            }
+            if ((evexwlp ^ prefix->vex_lp) & valid_mask)
+                return 0;
+
+            if (c == 0250) {
+                if ((prefix->vex_v != 0) ||
+                    (!(prefix->evex[2] & EVEX_P2VP) &&
+                     ((eat < EA_XMMVSIB) || (eat > EA_ZMMVSIB))))
+                    return 0;
+            } else {
+                opx->segment |= SEG_RMREG;
+                opx->basereg = ((~prefix->evex[2] & EVEX_P2VP) << (4 - 3) ) |
+                                prefix->vex_v;
+            }
+            vex_ok = true;
+            memcpy(ins->evex_p, prefix->evex, 3);
+            break;
+        }
+
+        case4(0260):
+        case 0270:
+        {
+            int vexm   = *r++;
+            int vexwlp = *r++;
+
+            ins->rex |= REX_V;
+            if ((prefix->rex & (REX_V|REX_P)) != REX_V)
+                return 0;
+
+            if ((vexm & 0x1f) != prefix->vex_m)
+                return 0;
+
+            switch (vexwlp & 060) {
+            case 000:
+                if (prefix->rex & REX_W)
+                    return 0;
+                break;
+            case 020:
+                if (!(prefix->rex & REX_W))
+                    return 0;
+                ins->rex &= ~REX_W;
+                break;
+            case 040:        /* VEX.W is a don't care */
+                ins->rex &= ~REX_W;
+                break;
+            case 060:
+                break;
+            }
+
+            /* The 010 bit of vexwlp is set if VEX.L is ignored */
+            if ((vexwlp ^ prefix->vex_lp) & ((vexwlp & 010) ? 03 : 07))
+                return 0;
+
+            if (c == 0270) {
+                if (prefix->vex_v != 0)
+                    return 0;
+            } else {
+                opx->segment |= SEG_RMREG;
+                opx->basereg = prefix->vex_v;
+            }
+            vex_ok = true;
+            break;
+        }
+
+        case 0271:
+            if (prefix->rep == 0xF3)
+                drep = P_XRELEASE;
+            break;
+
+        case 0272:
+            if (prefix->rep == 0xF2)
+                drep = P_XACQUIRE;
+            else if (prefix->rep == 0xF3)
+                drep = P_XRELEASE;
+            break;
+
+        case 0273:
+            if (prefix->lock == 0xF0) {
+                if (prefix->rep == 0xF2)
+                    drep = P_XACQUIRE;
+                else if (prefix->rep == 0xF3)
+                    drep = P_XRELEASE;
+            }
+            break;
+
+        case 0310:
+            if (asize != 16)
+                return 0;
+            else
+                a_used = true;
+            break;
+
+        case 0311:
+            if (asize != 32)
+                return 0;
+            else
+                a_used = true;
+            break;
+
+        case 0312:
+            if (asize != segsize)
+                return 0;
+            else
+                a_used = true;
+            break;
+
+        case 0313:
+            if (asize != 64)
+                return 0;
+            else
+                a_used = true;
+            break;
+
+        case 0314:
+            if (prefix->rex & REX_B)
+                return 0;
+            break;
+
+        case 0315:
+            if (prefix->rex & REX_X)
+                return 0;
+            break;
+
+        case 0316:
+            if (prefix->rex & REX_R)
+                return 0;
+            break;
+
+        case 0317:
+            if (prefix->rex & REX_W)
+                return 0;
+            break;
+
+        case 0320:
+            if (osize != 16)
+                return 0;
+            else
+                o_used = true;
+            break;
+
+        case 0321:
+            if (osize != 32)
+                return 0;
+            else
+                o_used = true;
+            break;
+
+        case 0322:
+            if (osize != (segsize == 16 ? 16 : 32))
+                return 0;
+            else
+                o_used = true;
+            break;
+
+        case 0323:
+            ins->rex |= REX_W;    /* 64-bit only instruction */
+            osize = 64;
+            o_used = true;
+            break;
+
+        case 0324:
+            if (osize != 64)
+                return 0;
+            o_used = true;
+            break;
+
+        case 0325:
+            ins->rex |= REX_NH;
+            break;
+
+        case 0326:
+            if (prefix->rep == 0xF3)
+                return 0;
+            break;
+
+        case 0331:
+            if (prefix->rep)
+                return 0;
+            break;
+
+        case 0332:
+            if (prefix->rep != 0xF2)
+                return 0;
+            drep = 0;
+            break;
+
+        case 0333:
+            if (prefix->rep != 0xF3)
+                return 0;
+            drep = 0;
+            break;
+
+        case 0334:
+            if (lock) {
+                ins->rex |= REX_R;
+                lock = 0;
+            }
+            break;
+
+        case 0335:
+            if (drep == P_REP)
+                drep = P_REPE;
+            break;
+
+        case 0336:
+        case 0337:
+            break;
+
+        case 0340:
+            return 0;
+
+        case 0341:
+            if (prefix->wait != 0x9B)
+                return 0;
+            dwait = 0;
+            break;
+
+        case 0360:
+            if (prefix->osp || prefix->rep)
+                return 0;
+            break;
+
+        case 0361:
+            if (!prefix->osp || prefix->rep)
+                return 0;
+            o_used = true;
+            break;
+
+        case 0364:
+            if (prefix->osp)
+                return 0;
+            break;
+
+        case 0365:
+            if (prefix->asp)
+                return 0;
+            break;
+
+        case 0366:
+            if (!prefix->osp)
+                return 0;
+            o_used = true;
+            break;
+
+        case 0367:
+            if (!prefix->asp)
+                return 0;
+            a_used = true;
+            break;
+
+        case 0370:
+        case 0371:
+            break;
+
+        case 0374:
+            eat = EA_XMMVSIB;
+            break;
+
+        case 0375:
+            eat = EA_YMMVSIB;
+            break;
+
+        case 0376:
+            eat = EA_ZMMVSIB;
+            break;
+
+        default:
+            return 0;    /* Unknown code */
+        }
+    }
+
+    if (!vex_ok && (ins->rex & (REX_V | REX_EV)))
+        return 0;
+
+    /* REX cannot be combined with VEX */
+    if ((ins->rex & REX_V) && (prefix->rex & REX_P))
+        return 0;
+
+    /*
+     * Check for unused rep or a/o prefixes.
+     */
+    for (i = 0; i < t->operands; i++) {
+        if (ins->oprs[i].segment != SEG_RMREG)
+            a_used = true;
+    }
+
+    if (lock) {
+        if (ins->prefixes[PPS_LOCK])
+            return 0;
+        ins->prefixes[PPS_LOCK] = P_LOCK;
+    }
+    if (drep) {
+        if (ins->prefixes[PPS_REP])
+            return 0;
+        ins->prefixes[PPS_REP] = drep;
+    }
+    ins->prefixes[PPS_WAIT] = dwait;
+    if (!o_used) {
+        if (osize != ((segsize == 16) ? 16 : 32)) {
+            enum prefixes pfx = 0;
+
+            switch (osize) {
+            case 16:
+                pfx = P_O16;
+                break;
+            case 32:
+                pfx = P_O32;
+                break;
+            case 64:
+                pfx = P_O64;
+                break;
+            }
+
+            if (ins->prefixes[PPS_OSIZE])
+                return 0;
+            ins->prefixes[PPS_OSIZE] = pfx;
+        }
+    }
+    if (!a_used && asize != segsize) {
+        if (ins->prefixes[PPS_ASIZE])
+            return 0;
+        ins->prefixes[PPS_ASIZE] = asize == 16 ? P_A16 : P_A32;
+    }
+
+    /* Fix: check for redundant REX prefixes */
+
+    return data - origdata;
+}
+
+int32_t disasm(uint8_t *data, int32_t data_size, char *output, int outbufsize, int segsize,
+               int64_t offset, int autosync, iflag_t *prefer)
+{
+    const struct itemplate * const *p, * const *best_p;
+    const struct disasm_index *ix;
+    uint8_t *dp;
+    int length, best_length = 0;
+    char *segover;
+    int i, slen, colon, n;
+    uint8_t *origdata;
+    int works;
+    insn tmp_ins, ins;
+    iflag_t goodness, best;
+    int best_pref;
+    struct prefix_info prefix;
+    bool end_prefix;
+    bool is_evex;
+
+    memset(&ins, 0, sizeof ins);
+
+    /*
+     * Scan for prefixes.
+     */
+    memset(&prefix, 0, sizeof prefix);
+    prefix.asize = segsize;
+    prefix.osize = (segsize == 64) ? 32 : segsize;
+    segover = NULL;
+    origdata = data;
+
+    ix = itable;
+
+    end_prefix = false;
+    while (!end_prefix) {
+        switch (*data) {
+        case 0xF2:
+        case 0xF3:
+            fetch_or_return(origdata, data, data_size, 1);
+            prefix.rep = *data++;
+            break;
+
+        case 0x9B:
+            fetch_or_return(origdata, data, data_size, 1);
+            prefix.wait = *data++;
+            break;
+
+        case 0xF0:
+            fetch_or_return(origdata, data, data_size, 1);
+            prefix.lock = *data++;
+            break;
+
+        case 0x2E:
+            fetch_or_return(origdata, data, data_size, 1);
+            segover = "cs", prefix.seg = *data++;
+            break;
+        case 0x36:
+            fetch_or_return(origdata, data, data_size, 1);
+            segover = "ss", prefix.seg = *data++;
+            break;
+        case 0x3E:
+            fetch_or_return(origdata, data, data_size, 1);
+            segover = "ds", prefix.seg = *data++;
+            break;
+        case 0x26:
+            fetch_or_return(origdata, data, data_size, 1);
+            segover = "es", prefix.seg = *data++;
+            break;
+        case 0x64:
+            fetch_or_return(origdata, data, data_size, 1);
+            segover = "fs", prefix.seg = *data++;
+            break;
+        case 0x65:
+            fetch_or_return(origdata, data, data_size, 1);
+            segover = "gs", prefix.seg = *data++;
+            break;
+
+        case 0x66:
+            fetch_or_return(origdata, data, data_size, 1);
+            prefix.osize = (segsize == 16) ? 32 : 16;
+            prefix.osp = *data++;
+            break;
+        case 0x67:
+            fetch_or_return(origdata, data, data_size, 1);
+            prefix.asize = (segsize == 32) ? 16 : 32;
+            prefix.asp = *data++;
+            break;
+
+        case 0xC4:
+        case 0xC5:
+            if (segsize == 64 || (data[1] & 0xc0) == 0xc0) {
+                fetch_or_return(origdata, data, data_size, 2);
+                prefix.vex[0] = *data++;
+                prefix.vex[1] = *data++;
+
+                prefix.rex = REX_V;
+                prefix.vex_c = RV_VEX;
+
+                if (prefix.vex[0] == 0xc4) {
+                    fetch_or_return(origdata, data, data_size, 1);
+                    prefix.vex[2] = *data++;
+                    prefix.rex |= (~prefix.vex[1] >> 5) & 7; /* REX_RXB */
+                    prefix.rex |= (prefix.vex[2] >> (7-3)) & REX_W;
+                    prefix.vex_m = prefix.vex[1] & 0x1f;
+                    prefix.vex_v = (~prefix.vex[2] >> 3) & 15;
+                    prefix.vex_lp = prefix.vex[2] & 7;
+                } else {
+                    prefix.rex |= (~prefix.vex[1] >> (7-2)) & REX_R;
+                    prefix.vex_m = 1;
+                    prefix.vex_v = (~prefix.vex[1] >> 3) & 15;
+                    prefix.vex_lp = prefix.vex[1] & 7;
+                }
+
+                ix = itable_vex[RV_VEX][prefix.vex_m][prefix.vex_lp & 3];
+            }
+            end_prefix = true;
+            break;
+
+        case 0x62:
+        {
+            if (segsize == 64 || ((data[1] & 0xc0) == 0xc0)) {
+                fetch_or_return(origdata, data, data_size, 4);
+                data++;        /* 62h EVEX prefix */
+                prefix.evex[0] = *data++;
+                prefix.evex[1] = *data++;
+                prefix.evex[2] = *data++;
+
+                prefix.rex    = REX_EV;
+                prefix.vex_c  = RV_EVEX;
+                prefix.rex   |= (~prefix.evex[0] >> 5) & 7; /* REX_RXB */
+                prefix.rex   |= (prefix.evex[1] >> (7-3)) & REX_W;
+                prefix.vex_m  = prefix.evex[0] & EVEX_P0MM;
+                prefix.vex_v  = (~prefix.evex[1] & EVEX_P1VVVV) >> 3;
+                prefix.vex_lp = ((prefix.evex[2] & EVEX_P2LL) >> (5-2)) |
+                                (prefix.evex[1] & EVEX_P1PP);
+
+                ix = itable_vex[prefix.vex_c][prefix.vex_m][prefix.vex_lp & 3];
+            }
+            end_prefix = true;
+            break;
+        }
+
+        case 0x8F:
+            if ((data[1] & 030) != 0 &&
+                    (segsize == 64 || (data[1] & 0xc0) == 0xc0)) {
+                fetch_or_return(origdata, data, data_size, 3);
+                prefix.vex[0] = *data++;
+                prefix.vex[1] = *data++;
+                prefix.vex[2] = *data++;
+
+                prefix.rex = REX_V;
+                prefix.vex_c = RV_XOP;
+
+                prefix.rex |= (~prefix.vex[1] >> 5) & 7; /* REX_RXB */
+                prefix.rex |= (prefix.vex[2] >> (7-3)) & REX_W;
+                prefix.vex_m = prefix.vex[1] & 0x1f;
+                prefix.vex_v = (~prefix.vex[2] >> 3) & 15;
+                prefix.vex_lp = prefix.vex[2] & 7;
+
+                ix = itable_vex[RV_XOP][prefix.vex_m][prefix.vex_lp & 3];
+            }
+            end_prefix = true;
+            break;
+
+        case REX_P + 0x0:
+        case REX_P + 0x1:
+        case REX_P + 0x2:
+        case REX_P + 0x3:
+        case REX_P + 0x4:
+        case REX_P + 0x5:
+        case REX_P + 0x6:
+        case REX_P + 0x7:
+        case REX_P + 0x8:
+        case REX_P + 0x9:
+        case REX_P + 0xA:
+        case REX_P + 0xB:
+        case REX_P + 0xC:
+        case REX_P + 0xD:
+        case REX_P + 0xE:
+        case REX_P + 0xF:
+            if (segsize == 64) {
+                fetch_or_return(origdata, data, data_size, 1);
+                prefix.rex = *data++;
+                if (prefix.rex & REX_W)
+                    prefix.osize = 64;
+            }
+            end_prefix = true;
+            break;
+
+        default:
+            end_prefix = true;
+            break;
+        }
+    }
+
+    iflag_set_all(&best); /* Worst possible */
+    best_p = NULL;
+    best_pref = INT_MAX;
+
+    if (!ix)
+        return 0;        /* No instruction table at all... */
+
+    dp = data;
+    fetch_or_return(origdata, dp, data_size, 1);
+    ix += *dp++;
+    while (ix->n == -1) {
+        fetch_or_return(origdata, dp, data_size, 1);
+        ix = (const struct disasm_index *)ix->p + *dp++;
+    }
+
+    p = (const struct itemplate * const *)ix->p;
+    for (n = ix->n; n; n--, p++) {
+        if ((length = matches(*p, data, &prefix, segsize, &tmp_ins))) {
+            works = true;
+            /*
+             * Final check to make sure the types of r/m match up.
+             * XXX: Need to make sure this is actually correct.
+             */
+            for (i = 0; i < (*p)->operands; i++) {
+                if (
+                        /* If it's a mem-only EA but we have a
+                           register, die. */
+                        ((tmp_ins.oprs[i].segment & SEG_RMREG) &&
+                         is_class(MEMORY, (*p)->opd[i])) ||
+                        /* If it's a reg-only EA but we have a memory
+                           ref, die. */
+                        (!(tmp_ins.oprs[i].segment & SEG_RMREG) &&
+                         !(REG_EA & ~(*p)->opd[i]) &&
+                         !((*p)->opd[i] & REG_SMASK)) ||
+                        /* Register type mismatch (eg FS vs REG_DESS):
+                           die. */
+                        ((((*p)->opd[i] & (REGISTER | FPUREG)) ||
+                          (tmp_ins.oprs[i].segment & SEG_RMREG)) &&
+                         !whichreg((*p)->opd[i],
+                             tmp_ins.oprs[i].basereg, tmp_ins.rex))
+                   ) {
+                    works = false;
+                    break;
+                }
+            }
+
+            /*
+             * Note: we always prefer instructions which incorporate
+             * prefixes in the instructions themselves.  This is to allow
+             * e.g. PAUSE to be preferred to REP NOP, and deal with
+             * MMX/SSE instructions where prefixes are used to select
+             * between MMX and SSE register sets or outright opcode
+             * selection.
+             */
+            if (works) {
+                int i, nprefix;
+                goodness = iflag_pfmask(*p);
+                goodness = iflag_xor(&goodness, prefer);
+		nprefix = 0;
+		for (i = 0; i < MAXPREFIX; i++)
+		    if (tmp_ins.prefixes[i])
+			nprefix++;
+                if (nprefix < best_pref ||
+		    (nprefix == best_pref &&
+                     iflag_cmp(&goodness, &best) < 0)) {
+                    /* This is the best one found so far */
+                    best = goodness;
+                    best_p = p;
+                    best_pref = nprefix;
+                    best_length = length;
+                    ins = tmp_ins;
+                }
+            }
+        }
+    }
+
+    if (!best_p)
+        return 0;               /* no instruction was matched */
+
+    /* Pick the best match */
+    p = best_p;
+    length = best_length;
+
+    slen = 0;
+
+    /* TODO: snprintf returns the value that the string would have if
+     *      the buffer were long enough, and not the actual length of
+     *      the returned string, so each instance of using the return
+     *      value of snprintf should actually be checked to assure that
+     *      the return value is "sane."  Maybe a macro wrapper could
+     *      be used for that purpose.
+     */
+    for (i = 0; i < MAXPREFIX; i++) {
+        const char *prefix = prefix_name(ins.prefixes[i]);
+        if (prefix)
+            slen += snprintf(output+slen, outbufsize-slen, "%s ", prefix);
+    }
+
+    i = (*p)->opcode;
+    slen += snprintf(output + slen, outbufsize - slen, "%s",
+                     nasm_insn_names[i]);
+
+    colon = false;
+    is_evex = !!(ins.rex & REX_EV);
+    length += data - origdata;  /* fix up for prefixes */
+    for (i = 0; i < (*p)->operands; i++) {
+        opflags_t t = (*p)->opd[i];
+        decoflags_t deco = (*p)->deco[i];
+        const operand *o = &ins.oprs[i];
+        int64_t offs;
+
+        output[slen++] = (colon ? ':' : i == 0 ? ' ' : ',');
+
+        offs = o->offset;
+        if (o->segment & SEG_RELATIVE) {
+            offs += offset + length;
+            /*
+             * sort out wraparound
+             */
+            if (!(o->segment & (SEG_32BIT|SEG_64BIT)))
+                offs &= 0xffff;
+            else if (segsize != 64)
+                offs &= 0xffffffff;
+
+            /*
+             * add sync marker, if autosync is on
+             */
+            if (autosync)
+                add_sync(offs, 0L);
+        }
+
+        if (t & COLON)
+            colon = true;
+        else
+            colon = false;
+
+        if ((t & (REGISTER | FPUREG)) ||
+                (o->segment & SEG_RMREG)) {
+            enum reg_enum reg;
+            reg = whichreg(t, o->basereg, ins.rex);
+            if (t & TO)
+                slen += snprintf(output + slen, outbufsize - slen, "to ");
+            slen += snprintf(output + slen, outbufsize - slen, "%s",
+                    nasm_reg_names[reg-EXPR_REG_START]);
+            if (t & REGSET_MASK)
+                slen += snprintf(output + slen, outbufsize - slen, "+%d",
+                                 (int)((t & REGSET_MASK) >> (REGSET_SHIFT-1))-1);
+            if (is_evex && deco)
+                slen += append_evex_reg_deco(output + slen, outbufsize - slen,
+                                             deco, ins.evex_p);
+        } else if (!(UNITY & ~t)) {
+            output[slen++] = '1';
+        } else if (t & IMMEDIATE) {
+            if (t & BITS8) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "byte ");
+                if (o->segment & SEG_SIGNED) {
+                    if (offs < 0) {
+                        offs *= -1;
+                        output[slen++] = '-';
+                    } else
+                        output[slen++] = '+';
+                }
+            } else if (t & BITS16) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "word ");
+            } else if (t & BITS32) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "dword ");
+            } else if (t & BITS64) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "qword ");
+            } else if (t & NEAR) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "near ");
+            } else if (t & SHORT) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "short ");
+            }
+            slen +=
+                snprintf(output + slen, outbufsize - slen, "0x%"PRIx64"",
+                        offs);
+        } else if (!(MEM_OFFS & ~t)) {
+            slen +=
+                snprintf(output + slen, outbufsize - slen,
+                        "[%s%s%s0x%"PRIx64"]",
+                        (segover ? segover : ""),
+                        (segover ? ":" : ""),
+                        (o->disp_size == 64 ? "qword " :
+                         o->disp_size == 32 ? "dword " :
+                         o->disp_size == 16 ? "word " : ""), offs);
+            segover = NULL;
+        } else if (is_class(REGMEM, t)) {
+            int started = false;
+            if (t & BITS8)
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "byte ");
+            if (t & BITS16)
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "word ");
+            if (t & BITS32)
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "dword ");
+            if (t & BITS64)
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "qword ");
+            if (t & BITS80)
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "tword ");
+            if ((ins.evex_p[2] & EVEX_P2B) && (deco & BRDCAST_MASK)) {
+                /* when broadcasting, each element size should be used */
+                if (deco & BR_BITS16)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "word ");
+                else if (deco & BR_BITS32)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "dword ");
+                else if (deco & BR_BITS64)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "qword ");
+            } else {
+                if (t & BITS128)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "oword ");
+                if (t & BITS256)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "yword ");
+                if (t & BITS512)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "zword ");
+            }
+            if (t & FAR)
+                slen += snprintf(output + slen, outbufsize - slen, "far ");
+            if (t & NEAR)
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "near ");
+            output[slen++] = '[';
+            if (o->disp_size)
+                slen += snprintf(output + slen, outbufsize - slen, "%s",
+                        (o->disp_size == 64 ? "qword " :
+                         o->disp_size == 32 ? "dword " :
+                         o->disp_size == 16 ? "word " :
+                         ""));
+            if (o->eaflags & EAF_REL)
+                slen += snprintf(output + slen, outbufsize - slen, "rel ");
+            if (segover) {
+                slen +=
+                    snprintf(output + slen, outbufsize - slen, "%s:",
+                            segover);
+                segover = NULL;
+            }
+            if (o->basereg != -1) {
+                slen += snprintf(output + slen, outbufsize - slen, "%s",
+                        nasm_reg_names[(o->basereg-EXPR_REG_START)]);
+                started = true;
+            }
+            if (o->indexreg != -1 && !itemp_has(*best_p, IF_MIB)) {
+                if (started)
+                    output[slen++] = '+';
+                slen += snprintf(output + slen, outbufsize - slen, "%s",
+                        nasm_reg_names[(o->indexreg-EXPR_REG_START)]);
+                if (o->scale > 1)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "*%d",
+                                o->scale);
+                started = true;
+            }
+
+
+            if (o->segment & SEG_DISP8) {
+                if (is_evex) {
+                    const char *prefix;
+                    uint32_t offset = offs;
+                    if ((int32_t)offset < 0) {
+                        prefix = "-";
+                        offset = -offset;
+                    } else {
+                        prefix = "+";
+                    }
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx32"",
+                                prefix, offset);
+                } else {
+                    const char *prefix;
+                    uint8_t offset = offs;
+                    if ((int8_t)offset < 0) {
+                        prefix = "-";
+                        offset = -offset;
+                    } else {
+                        prefix = "+";
+                    }
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx8"",
+                                prefix, offset);
+                }
+            } else if (o->segment & SEG_DISP16) {
+                const char *prefix;
+                uint16_t offset = offs;
+                if ((int16_t)offset < 0 && started) {
+                    offset = -offset;
+                    prefix = "-";
+                } else {
+                    prefix = started ? "+" : "";
+                }
+                slen +=
+                    snprintf(output + slen, outbufsize - slen,
+                            "%s0x%"PRIx16"", prefix, offset);
+            } else if (o->segment & SEG_DISP32) {
+                if (prefix.asize == 64) {
+                    const char *prefix;
+                    uint64_t offset = offs;
+                    if ((int32_t)offs < 0 && started) {
+                        offset = -offset;
+                        prefix = "-";
+                    } else {
+                        prefix = started ? "+" : "";
+                    }
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen,
+                                "%s0x%"PRIx64"", prefix, offset);
+                } else {
+                    const char *prefix;
+                    uint32_t offset = offs;
+                    if ((int32_t) offset < 0 && started) {
+                        offset = -offset;
+                        prefix = "-";
+                    } else {
+                        prefix = started ? "+" : "";
+                    }
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen,
+                                "%s0x%"PRIx32"", prefix, offset);
+                }
+            }
+
+            if (o->indexreg != -1 && itemp_has(*best_p, IF_MIB)) {
+                output[slen++] = ',';
+                slen += snprintf(output + slen, outbufsize - slen, "%s",
+                        nasm_reg_names[(o->indexreg-EXPR_REG_START)]);
+                if (o->scale > 1)
+                    slen +=
+                        snprintf(output + slen, outbufsize - slen, "*%d",
+                                o->scale);
+                started = true;
+            }
+
+            output[slen++] = ']';
+
+            if (is_evex && deco)
+                slen += append_evex_mem_deco(output + slen, outbufsize - slen,
+                                             t, deco, ins.evex_p);
+        } else {
+            slen +=
+                snprintf(output + slen, outbufsize - slen, "<operand%d>",
+                        i);
+        }
+    }
+    output[slen] = '\0';
+    if (segover) {              /* unused segment override */
+        char *p = output;
+        int count = slen + 1;
+        while (count--)
+            p[count + 3] = p[count];
+        strncpy(output, segover, 2);
+        output[2] = ' ';
+    }
+    return length;
+}
+
+/*
+ * This is called when we don't have a complete instruction.  If it
+ * is a standalone *single-byte* prefix show it as such, otherwise
+ * print it as a literal.
+ */
+int32_t eatbyte(uint8_t *data, char *output, int outbufsize, int segsize)
+{
+    uint8_t byte = *data;
+    const char *str = NULL;
+
+    switch (byte) {
+    case 0xF2:
+        str = "repne";
+        break;
+    case 0xF3:
+        str = "rep";
+        break;
+    case 0x9B:
+        str = "wait";
+        break;
+    case 0xF0:
+        str = "lock";
+        break;
+    case 0x2E:
+        str = "cs";
+        break;
+    case 0x36:
+        str = "ss";
+        break;
+    case 0x3E:
+        str = "ds";
+        break;
+    case 0x26:
+        str = "es";
+        break;
+    case 0x64:
+        str = "fs";
+        break;
+    case 0x65:
+        str = "gs";
+        break;
+    case 0x66:
+        str = (segsize == 16) ? "o32" : "o16";
+        break;
+    case 0x67:
+        str = (segsize == 32) ? "a16" : "a32";
+        break;
+    case REX_P + 0x0:
+    case REX_P + 0x1:
+    case REX_P + 0x2:
+    case REX_P + 0x3:
+    case REX_P + 0x4:
+    case REX_P + 0x5:
+    case REX_P + 0x6:
+    case REX_P + 0x7:
+    case REX_P + 0x8:
+    case REX_P + 0x9:
+    case REX_P + 0xA:
+    case REX_P + 0xB:
+    case REX_P + 0xC:
+    case REX_P + 0xD:
+    case REX_P + 0xE:
+    case REX_P + 0xF:
+        if (segsize == 64) {
+            snprintf(output, outbufsize, "rex%s%s%s%s%s",
+                    (byte == REX_P) ? "" : ".",
+                    (byte & REX_W) ? "w" : "",
+                    (byte & REX_R) ? "r" : "",
+                    (byte & REX_X) ? "x" : "",
+                    (byte & REX_B) ? "b" : "");
+            break;
+        }
+        /* else fall through */
+    default:
+        snprintf(output, outbufsize, "db 0x%02x", byte);
+        break;
+    }
+
+    if (str)
+        snprintf(output, outbufsize, "%s", str);
+
+    return 1;
+}
diff --git a/vere/ext/nasm/disasm/disasm.h b/vere/ext/nasm/disasm/disasm.h
new file mode 100644
index 0000000..053474d
--- /dev/null
+++ b/vere/ext/nasm/disasm/disasm.h
@@ -0,0 +1,49 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * disasm.h   header file for disasm.c
+ */
+
+#ifndef NASM_DISASM_H
+#define NASM_DISASM_H
+
+#include "iflag.h"
+
+#define INSN_MAX 32             /* one instruction can't be longer than this */
+
+int32_t disasm(uint8_t *data, int32_t data_size, char *output, int outbufsize, int segsize,
+               int64_t offset, int autosync, iflag_t *prefer);
+int32_t eatbyte(uint8_t *data, char *output, int outbufsize, int segsize);
+
+#endif
diff --git a/vere/ext/nasm/disasm/ndisasm.c b/vere/ext/nasm/disasm/ndisasm.c
new file mode 100644
index 0000000..4d34b21
--- /dev/null
+++ b/vere/ext/nasm/disasm/ndisasm.c
@@ -0,0 +1,400 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * ndisasm.c   the Netwide Disassembler main module
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+#include <errno.h>
+
+#include "insns.h"
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "ver.h"
+#include "sync.h"
+#include "disasm.h"
+
+#define BPL 8                   /* bytes per line of hex dump */
+
+static const char *help =
+    "usage: ndisasm [-a] [-i] [-h] [-r] [-u] [-b bits] [-o origin] [-s sync...]\n"
+    "               [-e bytes] [-k start,bytes] [-p vendor] file\n"
+    "   -a or -i activates auto (intelligent) sync\n"
+    "   -u same as -b 32\n"
+    "   -b 16, -b 32 or -b 64 sets the processor mode\n"
+    "   -h displays this text\n"
+    "   -r or -v displays the version number\n"
+    "   -e skips <bytes> bytes of header\n"
+    "   -k avoids disassembling <bytes> bytes from position <start>\n"
+    "   -p selects the preferred vendor instruction set (intel, amd, cyrix, idt)\n";
+
+static void output_ins(uint64_t, uint8_t *, int, char *);
+static void skip(uint32_t dist, FILE * fp);
+
+void nasm_verror(errflags severity, const char *fmt, va_list val)
+{
+    severity &= ERR_MASK;
+
+    vfprintf(stderr, fmt, val);
+    if (severity >= ERR_FATAL)
+        exit(severity - ERR_FATAL + 1);
+}
+
+fatal_func nasm_verror_critical(errflags severity, const char *fmt, va_list val)
+{
+    nasm_verror(severity, fmt, val);
+    abort();
+}
+
+int main(int argc, char **argv)
+{
+    char buffer[INSN_MAX * 2], *p, *ep, *q;
+    char outbuf[256];
+    char *pname = *argv;
+    char *filename = NULL;
+    uint32_t nextsync, synclen, initskip = 0L;
+    int lenread;
+    int32_t lendis;
+    bool autosync = false;
+    int bits = 16, b;
+    bool eof = false;
+    iflag_t prefer;
+    bool rn_error;
+    int64_t offset;
+    FILE *fp;
+
+    nasm_ctype_init();
+    iflag_clear_all(&prefer);
+
+    offset = 0;
+    init_sync();
+
+    while (--argc) {
+        char *v, *vv, *p = *++argv;
+        if (*p == '-' && p[1]) {
+            p++;
+            while (*p)
+                switch (nasm_tolower(*p)) {
+                case 'a':      /* auto or intelligent sync */
+                case 'i':
+                    autosync = true;
+                    p++;
+                    break;
+                case 'h':
+                    fputs(help, stderr);
+                    return 0;
+                case 'r':
+                case 'v':
+                    fprintf(stderr,
+                            "NDISASM version %s compiled on %s\n",
+			    nasm_version, nasm_date);
+                    return 0;
+                case 'u':	/* -u for -b 32, -uu for -b 64 */
+		    if (bits < 64)
+			bits <<= 1;
+                    p++;
+                    break;
+                case 'b':      /* bits */
+                    v = p[1] ? p + 1 : --argc ? *++argv : NULL;
+                    if (!v) {
+                        fprintf(stderr, "%s: `-b' requires an argument\n",
+                                pname);
+                        return 1;
+                    }
+		    b = strtoul(v, &ep, 10);
+		    if (*ep || !(bits == 16 || bits == 32 || bits == 64)) {
+                        fprintf(stderr, "%s: argument to `-b' should"
+                                " be 16, 32 or 64\n", pname);
+                    } else {
+			bits = b;
+		    }
+                    p = "";     /* force to next argument */
+                    break;
+                case 'o':      /* origin */
+                    v = p[1] ? p + 1 : --argc ? *++argv : NULL;
+                    if (!v) {
+                        fprintf(stderr, "%s: `-o' requires an argument\n",
+                                pname);
+                        return 1;
+                    }
+                    offset = readnum(v, &rn_error);
+                    if (rn_error) {
+                        fprintf(stderr,
+                                "%s: `-o' requires a numeric argument\n",
+                                pname);
+                        return 1;
+                    }
+                    p = "";     /* force to next argument */
+                    break;
+                case 's':      /* sync point */
+                    v = p[1] ? p + 1 : --argc ? *++argv : NULL;
+                    if (!v) {
+                        fprintf(stderr, "%s: `-s' requires an argument\n",
+                                pname);
+                        return 1;
+                    }
+                    add_sync(readnum(v, &rn_error), 0L);
+                    if (rn_error) {
+                        fprintf(stderr,
+                                "%s: `-s' requires a numeric argument\n",
+                                pname);
+                        return 1;
+                    }
+                    p = "";     /* force to next argument */
+                    break;
+                case 'e':      /* skip a header */
+                    v = p[1] ? p + 1 : --argc ? *++argv : NULL;
+                    if (!v) {
+                        fprintf(stderr, "%s: `-e' requires an argument\n",
+                                pname);
+                        return 1;
+                    }
+                    initskip = readnum(v, &rn_error);
+                    if (rn_error) {
+                        fprintf(stderr,
+                                "%s: `-e' requires a numeric argument\n",
+                                pname);
+                        return 1;
+                    }
+                    p = "";     /* force to next argument */
+                    break;
+                case 'k':      /* skip a region */
+                    v = p[1] ? p + 1 : --argc ? *++argv : NULL;
+                    if (!v) {
+                        fprintf(stderr, "%s: `-k' requires an argument\n",
+                                pname);
+                        return 1;
+                    }
+                    vv = strchr(v, ',');
+                    if (!vv) {
+                        fprintf(stderr,
+                                "%s: `-k' requires two numbers separated"
+                                " by a comma\n", pname);
+                        return 1;
+                    }
+                    *vv++ = '\0';
+                    nextsync = readnum(v, &rn_error);
+                    if (rn_error) {
+                        fprintf(stderr,
+                                "%s: `-k' requires numeric arguments\n",
+                                pname);
+                        return 1;
+                    }
+                    synclen = readnum(vv, &rn_error);
+                    if (rn_error) {
+                        fprintf(stderr,
+                                "%s: `-k' requires numeric arguments\n",
+                                pname);
+                        return 1;
+                    }
+                    add_sync(nextsync, synclen);
+                    p = "";     /* force to next argument */
+                    break;
+                case 'p':      /* preferred vendor */
+                    v = p[1] ? p + 1 : --argc ? *++argv : NULL;
+                    if (!v) {
+                        fprintf(stderr, "%s: `-p' requires an argument\n",
+                                pname);
+                        return 1;
+                    }
+                    if (!strcmp(v, "intel")) {
+                        iflag_clear_all(&prefer); /* default */
+                    } else if (!strcmp(v, "amd")) {
+                        iflag_clear_all(&prefer);
+                        iflag_set(&prefer, IF_AMD);
+                        iflag_set(&prefer, IF_3DNOW);
+                    } else if (!strcmp(v, "cyrix")) {
+                        iflag_clear_all(&prefer);
+                        iflag_set(&prefer, IF_CYRIX);
+                        iflag_set(&prefer, IF_3DNOW);
+                    } else if (!strcmp(v, "idt") ||
+                               !strcmp(v, "centaur") ||
+                               !strcmp(v, "winchip")) {
+                        iflag_clear_all(&prefer);
+                        iflag_set(&prefer, IF_3DNOW);
+                    } else {
+                        fprintf(stderr,
+                                "%s: unknown vendor `%s' specified with `-p'\n",
+                                pname, v);
+                        return 1;
+                    }
+                    p = "";     /* force to next argument */
+                    break;
+                default:       /*bf */
+                    fprintf(stderr, "%s: unrecognised option `-%c'\n",
+                            pname, *p);
+                    return 1;
+                }
+        } else if (!filename) {
+            filename = p;
+        } else {
+            fprintf(stderr, "%s: more than one filename specified\n",
+                    pname);
+            return 1;
+        }
+    }
+
+    if (!filename) {
+        fprintf(stderr, help, pname);
+        return 0;
+    }
+
+    if (strcmp(filename, "-")) {
+        fp = fopen(filename, "rb");
+        if (!fp) {
+            fprintf(stderr, "%s: unable to open `%s': %s\n",
+                    pname, filename, strerror(errno));
+            return 1;
+        }
+    } else {
+        nasm_set_binary_mode(stdin);
+        fp = stdin;
+    }
+
+    if (initskip > 0)
+        skip(initskip, fp);
+
+    /*
+     * This main loop is really horrible, and wants rewriting with
+     * an axe. It'll stay the way it is for a while though, until I
+     * find the energy...
+     */
+
+    p = q = buffer;
+    nextsync = next_sync(offset, &synclen);
+    do {
+        int32_t to_read = buffer + sizeof(buffer) - p;
+	if ((nextsync || synclen) &&
+	    to_read > nextsync - offset - (p - q))
+            to_read = nextsync - offset - (p - q);
+        if (to_read) {
+            lenread = fread(p, 1, to_read, fp);
+            if (lenread == 0)
+                eof = true;     /* help along systems with bad feof */
+        } else
+            lenread = 0;
+        p += lenread;
+        if ((nextsync || synclen) &&
+	    (uint32_t)offset == nextsync) {
+            if (synclen) {
+                fprintf(stdout, "%08"PRIX64"  skipping 0x%"PRIX32" bytes\n",
+			offset, synclen);
+                offset += synclen;
+                skip(synclen, fp);
+            }
+            p = q = buffer;
+            nextsync = next_sync(offset, &synclen);
+        }
+        while (p > q && (p - q >= INSN_MAX || lenread == 0)) {
+            lendis = disasm((uint8_t *)q, INSN_MAX, outbuf, sizeof(outbuf),
+			    bits, offset, autosync, &prefer);
+            if (!lendis || lendis > (p - q)
+                || ((nextsync || synclen) &&
+		    (uint32_t)lendis > nextsync - offset))
+                lendis = eatbyte((uint8_t *) q, outbuf, sizeof(outbuf), bits);
+            output_ins(offset, (uint8_t *) q, lendis, outbuf);
+            q += lendis;
+            offset += lendis;
+        }
+        if (q >= buffer + INSN_MAX) {
+            uint8_t *r = (uint8_t *) buffer, *s = (uint8_t *) q;
+            int count = p - q;
+            while (count--)
+                *r++ = *s++;
+            p -= (q - buffer);
+            q = buffer;
+        }
+    } while (lenread > 0 || !(eof || feof(fp)));
+
+    if (fp != stdin)
+        fclose(fp);
+
+    return 0;
+}
+
+static void output_ins(uint64_t offset, uint8_t *data,
+                       int datalen, char *insn)
+{
+    int bytes;
+    fprintf(stdout, "%08"PRIX64"  ", offset);
+
+    bytes = 0;
+    while (datalen > 0 && bytes < BPL) {
+        fprintf(stdout, "%02X", *data++);
+        bytes++;
+        datalen--;
+    }
+
+    fprintf(stdout, "%*s%s\n", (BPL + 1 - bytes) * 2, "", insn);
+
+    while (datalen > 0) {
+        fprintf(stdout, "         -");
+        bytes = 0;
+        while (datalen > 0 && bytes < BPL) {
+            fprintf(stdout, "%02X", *data++);
+            bytes++;
+            datalen--;
+        }
+        fprintf(stdout, "\n");
+    }
+}
+
+/*
+ * Skip a certain amount of data in a file, either by seeking if
+ * possible, or if that fails then by reading and discarding.
+ */
+static void skip(uint32_t dist, FILE * fp)
+{
+    char buffer[256];           /* should fit on most stacks :-) */
+
+    /*
+     * Got to be careful with fseek: at least one fseek I've tried
+     * doesn't approve of SEEK_CUR. So I'll use SEEK_SET and
+     * ftell... horrible but apparently necessary.
+     */
+    if (fseek(fp, dist + ftell(fp), SEEK_SET)) {
+        while (dist > 0) {
+            uint32_t len = (dist < sizeof(buffer) ?
+                                 dist : sizeof(buffer));
+            if (fread(buffer, 1, len, fp) < len) {
+                perror("fread");
+                exit(1);
+            }
+            dist -= len;
+        }
+    }
+}
diff --git a/vere/ext/nasm/disasm/sync.c b/vere/ext/nasm/disasm/sync.c
new file mode 100644
index 0000000..b9b866e
--- /dev/null
+++ b/vere/ext/nasm/disasm/sync.c
@@ -0,0 +1,129 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * sync.c   the Netwide Disassembler synchronisation processing module
+ */
+
+#include "compiler.h"
+
+
+#include "nasmlib.h"
+#include "sync.h"
+
+#define SYNC_MAX_SHIFT          31
+#define SYNC_MAX_SIZE           (1U << SYNC_MAX_SHIFT)
+
+/* initial # of sync points (*must* be power of two)*/
+#define SYNC_INITIAL_CHUNK      (1U << 12)
+
+/*
+ * This lot manages the current set of sync points by means of a
+ * heap (priority queue) structure.
+ */
+
+static struct Sync {
+    uint64_t pos;
+    uint32_t length;
+} *synx;
+
+static uint32_t max_synx, nsynx;
+
+static inline void swap_sync(uint32_t dst, uint32_t src)
+{
+    struct Sync t = synx[dst];
+    synx[dst] = synx[src];
+    synx[src] = t;
+}
+
+void init_sync(void)
+{
+    max_synx = SYNC_INITIAL_CHUNK;
+    synx = nasm_malloc((max_synx + 1) * sizeof(*synx));
+    nsynx = 0;
+}
+
+void add_sync(uint64_t pos, uint32_t length)
+{
+    uint32_t i;
+
+    if (nsynx >= max_synx) {
+        if (max_synx >= SYNC_MAX_SIZE) /* too many sync points! */
+            return;
+        max_synx = (max_synx << 1);
+        synx = nasm_realloc(synx, (max_synx + 1) * sizeof(*synx));
+    }
+
+    nsynx++;
+    synx[nsynx].pos = pos;
+    synx[nsynx].length = length;
+
+    for (i = nsynx; i > 1; i /= 2) {
+        if (synx[i / 2].pos > synx[i].pos)
+            swap_sync(i / 2, i);
+    }
+}
+
+uint64_t next_sync(uint64_t position, uint32_t *length)
+{
+    while (nsynx > 0 && synx[1].pos + synx[1].length <= position) {
+        uint32_t i, j;
+
+        swap_sync(nsynx, 1);
+        nsynx--;
+
+        i = 1;
+        while (i * 2 <= nsynx) {
+            j = i * 2;
+            if (synx[j].pos < synx[i].pos &&
+                (j + 1 > nsynx || synx[j + 1].pos > synx[j].pos)) {
+                swap_sync(j, i);
+                i = j;
+            } else if (j + 1 <= nsynx && synx[j + 1].pos < synx[i].pos) {
+                swap_sync(j + 1, i);
+                i = j + 1;
+            } else
+                break;
+        }
+    }
+
+    if (nsynx > 0) {
+        if (length)
+            *length = synx[1].length;
+        return synx[1].pos;
+    } else {
+        if (length)
+            *length = 0L;
+        return 0;
+    }
+}
diff --git a/vere/ext/nasm/disasm/sync.h b/vere/ext/nasm/disasm/sync.h
new file mode 100644
index 0000000..15c5afd
--- /dev/null
+++ b/vere/ext/nasm/disasm/sync.h
@@ -0,0 +1,45 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * sync.h   header file for sync.c
+ */
+
+#ifndef NASM_SYNC_H
+#define NASM_SYNC_H
+
+void init_sync(void);
+void add_sync(uint64_t position, uint32_t length);
+uint64_t next_sync(uint64_t position, uint32_t *length);
+
+#endif
diff --git a/vere/ext/nasm/headers/c b/vere/ext/nasm/headers/c
new file mode 100644
index 0000000..311e15b
--- /dev/null
+++ b/vere/ext/nasm/headers/c
@@ -0,0 +1,33 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2010 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
diff --git a/vere/ext/nasm/headers/doc b/vere/ext/nasm/headers/doc
new file mode 100644
index 0000000..0a6c381
--- /dev/null
+++ b/vere/ext/nasm/headers/doc
@@ -0,0 +1,33 @@
+\# --------------------------------------------------------------------------
+\#
+\#   Copyright 1996-2010 The NASM Authors - All Rights Reserved
+\#   See the file AUTHORS included with the NASM distribution for
+\#   the specific copyright holders.
+\#
+\#   Redistribution and use in source and binary forms, with or without
+\#   modification, are permitted provided that the following
+\#   conditions are met:
+\#
+\#   * Redistributions of source code must retain the above copyright
+\#     notice, this list of conditions and the following disclaimer.
+\#   * Redistributions in binary form must reproduce the above
+\#     copyright notice, this list of conditions and the following
+\#     disclaimer in the documentation and/or other materials provided
+\#     with the distribution.
+\#
+\#     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+\#     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+\#     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+\#     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+\#     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+\#     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+\#     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+\#     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+\#     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+\#     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+\#     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+\#     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+\#     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+\#
+\# --------------------------------------------------------------------------
+
diff --git a/vere/ext/nasm/headers/mac b/vere/ext/nasm/headers/mac
new file mode 100644
index 0000000..514315b
--- /dev/null
+++ b/vere/ext/nasm/headers/mac
@@ -0,0 +1,33 @@
+;; --------------------------------------------------------------------------
+;;
+;;   Copyright 1996-2010 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
diff --git a/vere/ext/nasm/headers/perl b/vere/ext/nasm/headers/perl
new file mode 100644
index 0000000..3ce5ad7
--- /dev/null
+++ b/vere/ext/nasm/headers/perl
@@ -0,0 +1,33 @@
+## --------------------------------------------------------------------------
+##   
+##   Copyright 1996-2010 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##     
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
diff --git a/vere/ext/nasm/include/bytesex.h b/vere/ext/nasm/include/bytesex.h
new file mode 100644
index 0000000..186d561
--- /dev/null
+++ b/vere/ext/nasm/include/bytesex.h
@@ -0,0 +1,261 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * bytesex.h - byte order helper functions
+ *
+ * In this function, be careful about getting X86_MEMORY versus
+ * LITTLE_ENDIAN correct: X86_MEMORY also means we are allowed to
+ * do unaligned memory references, and is probabilistic.
+ */
+
+#ifndef NASM_BYTEORD_H
+#define NASM_BYTEORD_H
+
+#include "compiler.h"
+
+/*
+ * Some handy macros that will probably be of use in more than one
+ * output format: convert integers into little-endian byte packed
+ * format in memory.
+ */
+
+#define WRITECHAR(p,v)                          	\
+    do {                                        	\
+        uint8_t *_wc_p = (uint8_t *)(p);		\
+        *_wc_p++ = (v);                                 \
+        (p) = (void *)_wc_p;                            \
+    } while (0)
+
+#if X86_MEMORY
+
+#define WRITESHORT(p,v)                         	\
+    do {                                        	\
+        uint16_t *_ws_p = (uint16_t *)(p);      	\
+        *_ws_p++ = (v);                           	\
+        (p) = (void *)_ws_p;              		\
+    } while (0)
+
+#define WRITELONG(p,v)                          	\
+    do {                                        	\
+        uint32_t *_wl_p = (uint32_t *)(p);		\
+        *_wl_p++ = (v);                           	\
+        (p) = (void *)_wl_p;              		\
+    } while (0)
+
+#define WRITEDLONG(p,v)                         	\
+    do {                                        	\
+        uint64_t *_wq_p = (uint64_t *)(p);      	\
+        *_wq_p++ = (v);                           	\
+        (p) = (void *)_wq_p;              		\
+    } while (0)
+
+#else /* !X86_MEMORY */
+
+#define WRITESHORT(p,v)                         	\
+    do {                                        	\
+        uint8_t *_ws_p = (uint8_t *)(p);        	\
+        const uint16_t _ws_v = (v);                     \
+        WRITECHAR(_ws_p, _ws_v);                        \
+        WRITECHAR(_ws_p, _ws_v >> 8);                   \
+        (p) = (void *)_ws_p;                            \
+    } while (0)
+
+#define WRITELONG(p,v)                         		\
+    do {                                        	\
+        uint8_t *_wl_p = (uint8_t *)(p);        	\
+        const uint32_t _wl_v = (v);                     \
+        WRITESHORT(_wl_p, _wl_v);                       \
+        WRITESHORT(_wl_p, _wl_v >> 16);                 \
+        (p) = (void *)_wl_p;                            \
+    } while (0)
+
+#define WRITEDLONG(p,v)                         	\
+    do {                                        	\
+        uint8_t *_wq_p = (uint8_t *)(p);        	\
+        const uint64_t _wq_v = (v);                     \
+        WRITELONG(_wq_p, _wq_v);                        \
+        WRITELONG(_wq_p, _wq_v >> 32);                  \
+        (p) = (void *)_wq_p;                            \
+    } while (0)
+
+#endif /* X86_MEMORY */
+
+/*
+ * Endian control functions which work on a single integer
+ */
+#ifdef WORDS_LITTLEENDIAN
+
+#ifndef HAVE_CPU_TO_LE16
+# define cpu_to_le16(v) ((uint16_t)(v))
+#endif
+#ifndef HAVE_CPU_TO_LE32
+# define cpu_to_le32(v) ((uint32_t)(v))
+#endif
+#ifndef HAVE_CPU_TO_LE64
+# define cpu_to_le64(v) ((uint64_t)(v))
+#endif
+
+#elif defined(WORDS_BIGENDIAN)
+
+#ifndef HAVE_CPU_TO_LE16
+static inline uint16_t cpu_to_le16(uint16_t v)
+{
+# ifdef HAVE___CPU_TO_LE16
+    return __cpu_to_le16(v);
+# elif defined(HAVE_HTOLE16)
+    return htole16(v);
+# elif defined(HAVE___BSWAP_16)
+    return __bswap_16(v);
+# elif defined(HAVE___BUILTIN_BSWAP16)
+    return __builtin_bswap16(v);
+# elif defined(HAVE__BYTESWAP_USHORT) && (USHRT_MAX == 0xffffU)
+    return _byteswap_ushort(v);
+# else
+    return (v << 8) | (v >> 8);
+# endif
+}
+#endif
+
+#ifndef HAVE_CPU_TO_LE32
+static inline uint32_t cpu_to_le32(uint32_t v)
+{
+# ifdef HAVE___CPU_TO_LE32
+    return __cpu_to_le32(v);
+# elif defined(HAVE_HTOLE32)
+    return htole32(v);
+# elif defined(HAVE___BSWAP_32)
+    return __bswap_32(v);
+# elif defined(HAVE___BUILTIN_BSWAP32)
+    return __builtin_bswap32(v);
+# elif defined(HAVE__BYTESWAP_ULONG) && (ULONG_MAX == 0xffffffffUL)
+    return _byteswap_ulong(v);
+# else
+    v = ((v << 8) & 0xff00ff00 ) |
+        ((v >> 8) & 0x00ff00ff);
+    return (v << 16) | (v >> 16);
+# endif
+}
+#endif
+
+#ifndef HAVE_CPU_TO_LE64
+static inline uint64_t cpu_to_le64(uint64_t v)
+{
+# ifdef HAVE___CPU_TO_LE64
+    return __cpu_to_le64(v);
+# elif defined(HAVE_HTOLE64)
+    return htole64(v);
+# elif defined(HAVE___BSWAP_64)
+    return __bswap_64(v);
+# elif defined(HAVE___BUILTIN_BSWAP64)
+    return __builtin_bswap64(v);
+# elif defined(HAVE__BYTESWAP_UINT64)
+    return _byteswap_uint64(v);
+# else
+    v = ((v << 8) & 0xff00ff00ff00ff00ull) |
+        ((v >> 8) & 0x00ff00ff00ff00ffull);
+    v = ((v << 16) & 0xffff0000ffff0000ull) |
+        ((v >> 16) & 0x0000ffff0000ffffull);
+    return (v << 32) | (v >> 32);
+# endif
+}
+#endif
+
+#else /* not WORDS_LITTLEENDIAN or WORDS_BIGENDIAN */
+
+static inline uint16_t cpu_to_le16(uint16_t v)
+{
+    union u16 {
+        uint16_t v;
+        uint8_t c[2];
+    } x;
+    uint8_t *cp = &x.c;
+
+    WRITESHORT(cp, v);
+    return x.v;
+}
+
+static inline uint32_t cpu_to_le32(uint32_t v)
+{
+    union u32 {
+        uint32_t v;
+        uint8_t c[4];
+    } x;
+    uint8_t *cp = &x.c;
+
+    WRITELONG(cp, v);
+    return x.v;
+}
+
+static inline uint64_t cpu_to_le64(uint64_t v)
+{
+    union u64 {
+        uint64_t v;
+        uint8_t c[8];
+    } x;
+    uint8_t *cp = &x.c;
+
+    WRITEDLONG(cp, v);
+    return x.v;
+}
+
+#endif
+
+#define WRITEADDR(p,v,s)                        		\
+    do {                                                        \
+	switch (is_constant(s) ? (s) : 0) {                     \
+        case 1:                                                 \
+            WRITECHAR(p,v);                                     \
+            break;                                              \
+        case 2:                                                 \
+            WRITESHORT(p,v);                                    \
+            break;                                              \
+        case 4:                                                 \
+            WRITELONG(p,v);                                     \
+            break;                                              \
+	case 8:                                                 \
+            WRITEDLONG(p,v);                                    \
+            break;                                              \
+        default:                                                \
+        {                                                       \
+            const uint64_t _wa_v = cpu_to_le64(v);              \
+            const size_t _wa_s = (s);                           \
+            uint8_t * const _wa_p = (uint8_t *)(p);             \
+            memcpy(_wa_p, &_wa_v, _wa_s);                       \
+            (p) = (void *)(_wa_p + _wa_s);                      \
+        }                                                       \
+        break;                                                  \
+        }                                                       \
+    } while (0)
+
+#endif /* NASM_BYTESEX_H */
diff --git a/vere/ext/nasm/include/compiler.h b/vere/ext/nasm/include/compiler.h
new file mode 100644
index 0000000..407c160
--- /dev/null
+++ b/vere/ext/nasm/include/compiler.h
@@ -0,0 +1,415 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2007-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * compiler.h
+ *
+ * Compiler-specific macros for NASM.  Feel free to add support for
+ * other compilers in here.
+ *
+ * This header file should be included before any other header.
+ */
+
+#ifndef NASM_COMPILER_H
+#define NASM_COMPILER_H 1
+
+/*
+ * At least DJGPP and Cygwin have broken header files if __STRICT_ANSI__
+ * is defined.
+ */
+#ifdef __GNUC__
+# undef __STRICT_ANSI__
+#endif
+
+/* On Microsoft platforms we support multibyte character sets in filenames */
+#define _MBCS 1
+
+#ifdef HAVE_CONFIG_H
+# include "config/config.h"
+#else
+# if defined(_MSC_VER) && (_MSC_VER >= 1310)
+#  include "config/msvc.h"
+# elif defined(__WATCOMC__)
+#  include "config/watcom.h"
+# else
+#  include "config/unknown.h"
+# endif
+/* This unconditionally defines some macros we really want */
+# include "config/unconfig.h"
+#endif /* Configuration file */
+
+/* This is required to get the standard <inttypes.h> macros when compiling
+   with a C++ compiler.  This must be defined *before* <inttypes.h> is
+   included, directly or indirectly. */
+#define __STDC_CONSTANT_MACROS	1
+#define __STDC_LIMIT_MACROS	1
+#define __STDC_FORMAT_MACROS	1
+
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# include "nasmint.h"
+#endif
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#ifdef HAVE_ENDIAN_H
+# include <endian.h>
+#elif defined(HAVE_SYS_ENDIAN_H)
+# include <sys/endian.h>
+#elif defined(HAVE_MACHINE_ENDIAN_H)
+# include <machine/endian.h>
+#endif
+
+/*
+ * If we have BYTE_ORDER defined, or the compiler provides
+ * __BIG_ENDIAN__ or __LITTLE_ENDIAN__, trust it over what autoconf
+ * came up with, especially since autoconf obviously can't figure
+ * things out for a universal compiler.
+ */
+#if defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
+# undef WORDS_LITTLEENDIAN
+# undef WORDS_BIGENDIAN
+# define WORDS_BIGENDIAN 1
+#elif defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+# undef WORDS_LITTLEENDIAN
+# undef WORDS_BIGENDIAN
+# define WORDS_LITTLEENDIAN 1
+#elif defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
+# undef WORDS_LITTLEENDIAN
+# undef WORDS_BIGENDIAN
+# if BYTE_ORDER == LITTLE_ENDIAN
+#  define WORDS_LITTLEENDIAN 1
+# elif BYTE_ORDER == BIG_ENDIAN
+#  define WORDS_BIGENDIAN 1
+# endif
+#endif
+
+/*
+ * Define this to 1 for faster performance if this is a littleendian
+ * platform *and* it can do arbitrary unaligned memory references.  It
+ * is safe to leave it defined to 0 even if that is true.
+ */
+#if defined(__386__) || defined(__i386__) || defined(__x86_64__) \
+    || defined(_M_IX86) || defined(_M_X64)
+# define X86_MEMORY 1
+# undef WORDS_BIGENDIAN
+# undef WORDS_LITTLEENDIAN
+# define WORDS_LITTLEENDIAN 1
+#else
+# define X86_MEMORY 0
+#endif
+
+/* Some versions of MSVC have these only with underscores in front */
+#ifndef HAVE_SNPRINTF
+# ifdef HAVE__SNPRINTF
+#  define snprintf _snprintf
+# else
+int snprintf(char *, size_t, const char *, ...);
+# endif
+#endif
+
+#ifndef HAVE_VSNPRINTF
+# ifdef HAVE__VSNPRINTF
+#  define vsnprintf _vsnprintf
+# else
+int vsnprintf(char *, size_t, const char *, va_list);
+# endif
+#endif
+
+#if !defined(HAVE_STRLCPY) || !HAVE_DECL_STRLCPY
+size_t strlcpy(char *, const char *, size_t);
+#endif
+
+#if !defined(HAVE_STRCHRNUL) || !HAVE_DECL_STRCHRNUL
+char *strrchrnul(const char *, int);
+#endif
+
+#ifndef __cplusplus		/* C++ has false, true, bool as keywords */
+# ifdef HAVE_STDBOOL_H
+#  include <stdbool.h>
+# elif defined(HAVE__BOOL)
+   typedef _Bool bool;
+#  define false 0
+#  define true 1
+# else
+/* This is sort of dangerous, since casts will behave different than
+   casting to the standard boolean type.  Always use !!, not (bool). */
+typedef enum bool { false, true } bool;
+# endif
+#endif
+
+/* Create a NULL pointer of the same type as the address of
+   the argument, without actually evaluating said argument. */
+#define nullas(p) (0 ? &(p) : NULL)
+
+/* Convert an offsetted NULL pointer dereference to a size_t offset.
+   Technically non-portable as taking the offset from a NULL pointer
+   is undefined behavior, but... */
+#define null_offset(p) ((size_t)((const char *)&(p) - (const char *)NULL))
+
+/* Provide a substitute for offsetof() if we don't have one.  This
+   variant works on most (but not *all*) systems... */
+#ifndef offsetof
+# define offsetof(t,m) null_offset(((t *)NULL)->m)
+#endif
+
+/* If typeof is defined as a macro, assume we have typeof even if
+   HAVE_TYPEOF is not declared (e.g. due to not using autoconf.) */
+#ifdef typeof
+# define HAVE_TYPEOF 1
+#endif
+
+/* This is like offsetof(), but takes an object rather than a type. */
+#ifndef offsetin
+# ifdef HAVE_TYPEOF
+#  define offsetin(p,m) offsetof(typeof(p),m)
+# else
+#  define offsetin(p,m)	null_offset(nullas(p)->m)
+# endif
+#endif
+
+/* The container_of construct: if p is a pointer to member m of
+   container class c, then return a pointer to the container of which
+   *p is a member. */
+#ifndef container_of
+# define container_of(p, c, m) ((c *)((char *)(p) - offsetof(c,m)))
+#endif
+
+/* Some misguided platforms hide the defs for these */
+#if defined(HAVE_STRCASECMP) && !HAVE_DECL_STRCASECMP
+int strcasecmp(const char *, const char *);
+#endif
+
+#if defined(HAVE_STRICMP) && !HAVE_DECL_STRICMP
+int stricmp(const char *, const char *);
+#endif
+
+#if defined(HAVE_STRNCASECMP) && !HAVE_DECL_STRNCASECMP
+int strncasecmp(const char *, const char *, size_t);
+#endif
+
+#if defined(HAVE_STRNICMP) && !HAVE_DECL_STRNICMP
+int strnicmp(const char *, const char *, size_t);
+#endif
+
+#if defined(HAVE_STRSEP) && !HAVE_DECL_STRSEP
+char *strsep(char **, const char *);
+#endif
+
+#if !HAVE_DECL_STRNLEN
+size_t strnlen(const char *s, size_t maxlen);
+#endif
+
+#ifndef HAVE_MEMPCPY
+static inline void *mempcpy(void *dst, const void *src, size_t n)
+{
+    return (char *)memcpy(dst, src, n) + n;
+}
+#endif
+
+#ifndef HAVE_MEMPSET
+static inline void *mempset(void *dst, int c, size_t n)
+{
+    return (char *)memset(dst, c, n) + n;
+}
+#endif
+
+/*
+ * Hack to support external-linkage inline functions
+ */
+#ifndef HAVE_STDC_INLINE
+# ifdef __GNUC__
+#  ifdef __GNUC_STDC_INLINE__
+#   define HAVE_STDC_INLINE
+#  else
+#   define HAVE_GNU_INLINE
+#  endif
+# elif defined(__GNUC_GNU_INLINE__)
+/* Some other compiler implementing only GNU inline semantics? */
+#   define HAVE_GNU_INLINE
+# elif defined(__STDC_VERSION__)
+#  if __STDC_VERSION__ >= 199901L
+#   define HAVE_STDC_INLINE
+#  endif
+# endif
+#endif
+
+#ifdef HAVE_STDC_INLINE
+# define extern_inline inline
+#elif defined(HAVE_GNU_INLINE)
+# define extern_inline extern inline
+# define inline_prototypes
+#else
+# define inline_prototypes
+#endif
+
+/*
+ * Hints to the compiler that a particular branch of code is more or
+ * less likely to be taken.
+ */
+#if HAVE___BUILTIN_EXPECT
+# define likely(x)	__builtin_expect(!!(x), 1)
+# define unlikely(x)	__builtin_expect(!!(x), 0)
+#else
+# define likely(x)	(!!(x))
+# define unlikely(x)	(!!(x))
+#endif
+
+#define safe_alloc     never_null     malloc_func
+#define safe_alloc_ptr never_null_ptr malloc_func_ptr
+
+#define safe_malloc(s)          safe_alloc     alloc_size_func1(s)
+#define safe_malloc2(s1,s2)     safe_alloc     alloc_size_func2(s1,s2)
+#define safe_realloc(s)         never_null     alloc_size_func1(s)
+#define safe_malloc_ptr(s)      safe_alloc_ptr alloc_size_func1_ptr(s)
+#define safe_malloc2_ptr(s1,s2) safe_alloc_ptr alloc_size_func2_ptr(s1,s2)
+#define safe_realloc_ptr(s)     never_null_ptr alloc_size_func1_ptr(s)
+
+/*
+ * How to tell the compiler that a function doesn't return
+ */
+#ifdef HAVE_STDNORETURN_H
+# include <stdnoreturn.h>
+# define no_return noreturn void
+#elif defined(_MSC_VER)
+# define no_return __declspec(noreturn) void
+#else
+# define no_return void noreturn_func
+#endif
+
+/*
+ * A fatal function is both unlikely and no_return
+ */
+#define fatal_func     no_return unlikely_func
+#define fatal_func_ptr no_return unlikely_func_ptr
+
+/*
+ * How to tell the compiler that a function takes a printf-like string
+ */
+#define printf_func(fmt, list)     format_func3(printf,fmt,list)
+#define printf_func_ptr(fmt, list) format_func3_ptr(printf,fmt,list)
+#define vprintf_func(fmt)          format_func3(printf,fmt,0)
+#define vprintf_func_ptr(fmt)      format_func3_ptr(printf,fmt,0)
+
+/* Determine probabilistically if something is a compile-time constant */
+#ifdef HAVE___BUILTIN_CONSTANT_P
+# if defined(__GNUC__) && (__GNUC__ >= 5)
+#  define is_constant(x) __builtin_constant_p((x))
+# else
+#  define is_constant(x) false
+# endif
+#else
+# define is_constant(x) false
+#endif
+
+/*
+ * If we can guarantee that a particular expression is constant, use it,
+ * otherwise use a different version.
+ */
+#if defined(__GNUC__) && (__GNUC__ >= 3)
+# define not_pedantic_start                             \
+    _Pragma("GCC diagnostic push")                      \
+    _Pragma("GCC diagnostic ignored \"-Wpedantic\"")
+# define not_pedantic_end                       \
+    _Pragma("GCC diagnostic pop")
+#else
+# define not_pedantic_start
+# define not_pedantic_end
+#endif
+
+#ifdef HAVE___BUILTIN_CHOOSE_EXPR
+# define if_constant(x,y) __builtin_choose_expr(is_constant(x),(x),(y))
+#else
+# define if_constant(x,y) (y)
+#endif
+
+/*
+ * The autoconf documentation states:
+ *
+ * `va_copy'
+ *    The C99 standard provides `va_copy' for copying `va_list'
+ *    variables.  It may be available in older environments too, though
+ *    possibly as `__va_copy' (e.g., `gcc' in strict pre-C99 mode).
+ *    These can be tested with `#ifdef'.  A fallback to `memcpy (&dst,
+ *    &src, sizeof (va_list))' gives maximum portability.
+ */
+#ifndef va_copy
+# ifdef __va_copy
+#  define va_copy(dst,src) __va_copy(dst,src)
+# else
+#  define va_copy(dst,src) memcpy(&(dst),&(src),sizeof(va_list))
+# endif
+#endif
+
+/*
+ * If SIZE_MAX is not defined, rely on size_t being unsigned
+ */
+#ifndef SIZE_MAX
+# define SIZE_MAX (((size_t)0) - 1)
+#endif
+
+/* Watcom doesn't handle switch statements with 64-bit types, hack around it */
+#ifdef __WATCOMC__
+# define BOGUS_CASE 0x76543210
+
+static inline unsigned int watcom_switch_hack(uint64_t x)
+{
+    if (x > (uint64_t)UINT_MAX)
+        return BOGUS_CASE;
+    else
+        return (unsigned int)x;
+}
+
+# define switch(x) switch(sizeof(x) > sizeof(unsigned int) \
+                          ? watcom_switch_hack(x) : (unsigned int)(x))
+
+/* This is to make sure BOGUS_CASE doesn't conflict with anything real... */
+# define default case BOGUS_CASE: default
+#endif
+
+#endif	/* NASM_COMPILER_H */
diff --git a/vere/ext/nasm/include/dbginfo.h b/vere/ext/nasm/include/dbginfo.h
new file mode 100644
index 0000000..8584eda
--- /dev/null
+++ b/vere/ext/nasm/include/dbginfo.h
@@ -0,0 +1,115 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * dbginfo.h - debugging info structures
+ */
+
+#ifndef NASM_DBGINFO_H
+#define NASM_DBGINFO_H
+
+#include "compiler.h"
+#include "srcfile.h"
+#include "rbtree.h"
+
+struct debug_macro_def;         /* Definition */
+struct debug_macro_inv;         /* Invocation */
+struct debug_macro_addr;        /* Address range */
+
+/*
+ * Definitions structure, one for each non-.nolist macro invoked
+ * anywhere in the program; unique for each macro, even if a macro is
+ * redefined and/or overloaded.
+ */
+struct debug_macro_def {
+    struct debug_macro_def *next; /* List of definitions */
+    const char *name;            /* Macro name */
+    struct src_location where;   /* Start of definition */
+    size_t ninv;                 /* Call count */
+};
+
+/*
+ * Invocation structure. One for each invocation of a non-.nolist macro.
+ */
+struct debug_macro_inv_list {
+    struct debug_macro_inv *l;
+    size_t n;
+};
+
+struct debug_macro_inv {
+    struct debug_macro_inv *next; /* List of same-level invocations */
+    struct debug_macro_inv_list down;
+    struct debug_macro_inv *up;   /* Parent invocation */
+    struct debug_macro_def *def;  /* Macro definition */
+    struct src_location where;    /* Start of invocation */
+    struct {                      /* Address range pointers */
+        struct rbtree *tree;           /* rbtree of address ranges */
+        struct debug_macro_addr *last; /* Quick lookup for latest section */
+    } addr;
+    uint32_t naddr;             /* Number of address ranges */
+    int32_t  lastseg;           /* lastaddr segment number  */
+};
+
+/*
+ * Address range structure. An rbtree containing one address range for each
+ * section which this particular macro has generated code/data/space into.
+ */
+struct debug_macro_addr {
+    struct rbtree tree;          /* rbtree; key = index, must be first */
+    struct debug_macro_addr *up; /* same section in parent invocation */
+    uint64_t start;              /* starting offset */
+    uint64_t len;                /* length of range */
+};
+
+/*
+ * Complete information structure */
+struct debug_macro_info {
+    struct debug_macro_inv_list inv;
+    struct debug_macro_def_list {
+        struct debug_macro_def *l;
+        size_t n;
+    } def;
+};
+
+static inline int32_t debug_macro_seg(const struct debug_macro_addr *dma)
+{
+    return dma->tree.key;
+}
+
+/* Get/create a addr structure for the macro we are emitting for */
+struct debug_macro_addr *debug_macro_get_addr(int32_t seg);
+
+/* The macro we are currently emitting for, if any */
+extern struct debug_macro_inv *debug_current_macro;
+
+#endif /* NASM_DBGINFO_H */
diff --git a/vere/ext/nasm/include/disp8.h b/vere/ext/nasm/include/disp8.h
new file mode 100644
index 0000000..fc18e4f
--- /dev/null
+++ b/vere/ext/nasm/include/disp8.h
@@ -0,0 +1,45 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2013 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * disp8.h   header file for disp8.c
+ */
+
+#ifndef NASM_DISP8_H
+#define NASM_DISP8_H
+
+#include "nasm.h"
+
+uint8_t get_disp8N(insn *ins);
+bool is_disp8n(operand *input, insn *ins, int8_t *compdisp);
+#endif  /* NASM_DISP8_H */
diff --git a/vere/ext/nasm/include/error.h b/vere/ext/nasm/include/error.h
new file mode 100644
index 0000000..e6338c9
--- /dev/null
+++ b/vere/ext/nasm/include/error.h
@@ -0,0 +1,162 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Error reporting functions for the assembler
+ */
+
+#ifndef NASM_ERROR_H
+#define NASM_ERROR_H 1
+
+#include "compiler.h"
+
+/*
+ * File pointer for error messages
+ */
+extern FILE *error_file;        /* Error file descriptor */
+
+/*
+ * Typedef for the severity field
+ */
+typedef uint32_t errflags;
+
+/*
+ * An error reporting function should look like this.
+ */
+void printf_func(2, 3) nasm_error(errflags severity, const char *fmt, ...);
+void printf_func(1, 2) nasm_listmsg(const char *fmt, ...);
+void printf_func(2, 3) nasm_listmsgf(errflags flags, const char *fmt, ...);
+void printf_func(1, 2) nasm_debug(const char *fmt, ...);
+void printf_func(2, 3) nasm_debugf(errflags flags, const char *fmt, ...);
+void printf_func(1, 2) nasm_info(const char *fmt, ...);
+void printf_func(2, 3) nasm_infof(errflags flags, const char *fmt, ...);
+void printf_func(2, 3) nasm_warn(errflags flags, const char *fmt, ...);
+void printf_func(1, 2) nasm_nonfatal(const char *fmt, ...);
+void printf_func(2, 3) nasm_nonfatalf(errflags flags, const char *fmt, ...);
+fatal_func printf_func(1, 2) nasm_fatal(const char *fmt, ...);
+fatal_func printf_func(2, 3) nasm_fatalf(errflags flags, const char *fmt, ...);
+fatal_func printf_func(1, 2) nasm_critical(const char *fmt, ...);
+fatal_func printf_func(2, 3) nasm_criticalf(errflags flags, const char *fmt, ...);
+fatal_func printf_func(1, 2) nasm_panic(const char *fmt, ...);
+fatal_func printf_func(2, 3) nasm_panicf(errflags flags, const char *fmt, ...);
+fatal_func nasm_panic_from_macro(const char *file, int line);
+#define panic() nasm_panic_from_macro(__FILE__, __LINE__);
+
+void vprintf_func(2) nasm_verror(errflags severity, const char *fmt, va_list ap);
+fatal_func vprintf_func(2) nasm_verror_critical(errflags severity, const char *fmt, va_list ap);
+
+/*
+ * These are the error severity codes which get passed as the first
+ * argument to an efunc.
+ */
+#define ERR_LISTMSG		0x00000000      /* for the listing file only */
+#define ERR_DEBUG		0x00000001	/* debugging message */
+#define ERR_INFO		0x00000002	/* information for the list file */
+#define ERR_WARNING		0x00000003	/* warn only: no further action */
+#define ERR_NONFATAL		0x00000004	/* terminate assembly after phase */
+#define ERR_FATAL		0x00000005	/* instantly fatal: exit with error */
+#define ERR_CRITICAL		0x00000006      /* fatal, but minimize code before exit */
+#define ERR_PANIC		0x00000007	/* internal error: panic instantly
+						 * and dump core for reference */
+#define ERR_MASK		0x00000007	/* mask off the above codes */
+#define ERR_UNDEAD		0x00000008      /* skip if we already have errors */
+#define ERR_NOFILE		0x00000010	/* don't give source file name/line */
+#define ERR_HERE		0x00000020      /* point to a specific source location */
+#define ERR_USAGE		0x00000040	/* print a usage message */
+#define ERR_PASS2		0x00000100	/* ignore unless on pass_final */
+
+#define ERR_NO_SEVERITY		0x00000200	/* suppress printing severity */
+#define ERR_PP_PRECOND		0x00000400	/* for preprocessor use */
+#define ERR_PP_LISTMACRO	0x00000800	/* from pp_error_list_macros() */
+#define ERR_HOLD		0x00001000      /* this error/warning can be held */
+
+/*
+ * These codes define specific types of suppressible warning.
+ * They are assumed to occupy the most significant bits of the
+ * severity code.
+ */
+#define WARN_SHR		16              /* how far to shift right */
+#define WARN_IDX(x)		(((errflags)(x)) >> WARN_SHR)
+#define WARN_MASK		((~(errflags)0) << WARN_SHR)
+
+/* This is a bitmask */
+#define WARN_ST_ENABLED		1 /* Warning is currently enabled */
+#define WARN_ST_ERROR		2 /* Treat this warning as an error */
+
+/* Possible initial state for warnings */
+#define WARN_INIT_OFF		0
+#define WARN_INIT_ON		WARN_ST_ENABLED
+#define WARN_INIT_ERR		(WARN_ST_ENABLED|WARN_ST_ERROR)
+
+/* Process a warning option or directive */
+bool set_warning_status(const char *value);
+
+/* Warning stack management */
+void push_warnings(void);
+void pop_warnings(void);
+void init_warnings(void);
+void reset_warnings(void);
+
+/*
+ * Tentative error hold for warnings/errors indicated with ERR_HOLD.
+ *
+ * This is a stack; the "hold" argument *must*
+ * match the value returned from nasm_error_hold_push().
+ * If "issue" is true the errors are committed (or promoted to the next
+ * higher stack level), if false then they are discarded.
+ *
+ * Errors stronger than ERR_NONFATAL cannot be held.
+ */
+struct nasm_errhold;
+typedef struct nasm_errhold *errhold;
+errhold nasm_error_hold_push(void);
+void nasm_error_hold_pop(errhold hold, bool issue);
+
+/* Should be included from within error.h only */
+#include "warnings.h"
+
+/* By defining MAX_DEBUG, we can compile out messages entirely */
+#ifndef MAX_DEBUG
+# define MAX_DEBUG (~0U)
+#endif
+
+/* Debug level checks */
+static inline bool debug_level(unsigned int level)
+{
+    extern unsigned int debug_nasm;
+    if (is_constant(level) && level > MAX_DEBUG)
+        return false;
+    return unlikely(level <= debug_nasm);
+}
+
+#endif /* NASM_ERROR_H */
diff --git a/vere/ext/nasm/include/hashtbl.h b/vere/ext/nasm/include/hashtbl.h
new file mode 100644
index 0000000..9ea94dc
--- /dev/null
+++ b/vere/ext/nasm/include/hashtbl.h
@@ -0,0 +1,108 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * hashtbl.h
+ *
+ * Efficient dictionary hash table class.
+ */
+
+#ifndef NASM_HASHTBL_H
+#define NASM_HASHTBL_H
+
+#include "nasmlib.h"
+
+struct hash_node {
+    uint64_t hash;
+    const void *key;
+    size_t keylen;
+    void *data;
+};
+
+struct hash_table {
+    struct hash_node *table;
+    size_t load;
+    size_t size;
+    size_t max_load;
+};
+
+struct hash_insert {
+    struct hash_table *head;
+    struct hash_node *where;
+    struct hash_node node;
+};
+
+struct hash_iterator {
+    const struct hash_table *head;
+    const struct hash_node *next;
+};
+
+uint64_t crc64(uint64_t crc, const char *string);
+uint64_t crc64i(uint64_t crc, const char *string);
+uint64_t crc64b(uint64_t crc, const void *data, size_t len);
+uint64_t crc64ib(uint64_t crc, const void *data, size_t len);
+#define CRC64_INIT UINT64_C(0xffffffffffffffff)
+
+static inline uint64_t crc64_byte(uint64_t crc, uint8_t v)
+{
+    extern const uint64_t crc64_tab[256];
+    return crc64_tab[(uint8_t)(v ^ crc)] ^ (crc >> 8);
+}
+
+uint32_t crc32b(uint32_t crc, const void *data, size_t len);
+
+void **hash_find(struct hash_table *head, const char *string,
+		struct hash_insert *insert);
+void **hash_findb(struct hash_table *head, const void *key, size_t keylen,
+		struct hash_insert *insert);
+void **hash_findi(struct hash_table *head, const char *string,
+		struct hash_insert *insert);
+void **hash_findib(struct hash_table *head, const void *key, size_t keylen,
+                   struct hash_insert *insert);
+void **hash_add(struct hash_insert *insert, const void *key, void *data);
+static inline void hash_iterator_init(const struct hash_table *head,
+                                      struct hash_iterator *iterator)
+{
+    iterator->head = head;
+    iterator->next = head->table;
+}
+const struct hash_node *hash_iterate(struct hash_iterator *iterator);
+
+#define hash_for_each(_head,_it,_np) \
+    for (hash_iterator_init((_head), &(_it)), (_np) = hash_iterate(&(_it)) ; \
+         (_np) ; (_np) = hash_iterate(&(_it)))
+
+void hash_free(struct hash_table *head);
+void hash_free_all(struct hash_table *head, bool free_keys);
+
+#endif /* NASM_HASHTBL_H */
diff --git a/vere/ext/nasm/include/iflag.h b/vere/ext/nasm/include/iflag.h
new file mode 100644
index 0000000..31a0a98
--- /dev/null
+++ b/vere/ext/nasm/include/iflag.h
@@ -0,0 +1,134 @@
+#ifndef NASM_IFLAG_H
+#define NASM_IFLAG_H
+
+#include "compiler.h"
+#include "ilog2.h"
+
+
+#include "iflaggen.h"
+
+#define IF_GENBIT(bit)          (UINT32_C(1) << ((bit) & 31))
+
+static inline int ifcomp(uint32_t a, uint32_t b)
+{
+    return (a > b) - (a < b);
+}
+
+static inline bool iflag_test(const iflag_t *f, unsigned int bit)
+{
+    return !!(f->field[bit >> 5] & IF_GENBIT(bit));
+}
+
+static inline void iflag_set(iflag_t *f, unsigned int bit)
+{
+    f->field[bit >> 5] |= IF_GENBIT(bit);
+}
+
+static inline void iflag_clear(iflag_t *f, unsigned int bit)
+{
+    f->field[bit >> 5] &= ~IF_GENBIT(bit);
+}
+
+static inline void iflag_clear_all(iflag_t *f)
+{
+     memset(f, 0, sizeof(*f));
+}
+
+static inline void iflag_set_all(iflag_t *f)
+{
+     memset(f, ~0, sizeof(*f));
+}
+
+#define iflag_for_each_field(v) for ((v) = 0; (v) < IF_FIELD_COUNT; (v)++)
+
+static inline int iflag_cmp(const iflag_t *a, const iflag_t *b)
+{
+    int i;
+
+    /* This is intentionally a reverse loop! */
+    for (i = IF_FIELD_COUNT-1; i >= 0; i--) {
+        if (a->field[i] == b->field[i])
+            continue;
+
+        return ifcomp(a->field[i], b->field[i]);
+    }
+
+    return 0;
+}
+
+#define IF_GEN_HELPER(name, op)                                         \
+    static inline iflag_t iflag_##name(const iflag_t *a, const iflag_t *b) \
+    {                                                                   \
+        unsigned int i;                                                 \
+        iflag_t res;                                                    \
+                                                                        \
+        iflag_for_each_field(i)                                         \
+            res.field[i] = a->field[i] op b->field[i];                  \
+                                                                        \
+        return res;                                                     \
+    }
+
+IF_GEN_HELPER(xor, ^)
+
+/* Some helpers which are to work with predefined masks */
+#define IF_SMASK        (IFM_SB|IFM_SW|IFM_SD|IFM_SQ|IFM_SO|IFM_SY|IFM_SZ|IFM_SIZE|IFM_ANYSIZE)
+#define IF_ARMASK       (IFM_AR0|IFM_AR1|IFM_AR2|IFM_AR3|IFM_AR4)
+
+#define _itemp_smask(idx)      (insns_flags[(idx)].field[0] & IF_SMASK)
+#define _itemp_armask(idx)     (insns_flags[(idx)].field[0] & IF_ARMASK)
+#define _itemp_arg(idx)        ((_itemp_armask(idx) >> IF_AR0) - 1)
+
+#define itemp_smask(itemp)      _itemp_smask((itemp)->iflag_idx)
+#define itemp_arg(itemp)        _itemp_arg((itemp)->iflag_idx)
+#define itemp_armask(itemp)     _itemp_armask((itemp)->iflag_idx)
+
+/*
+ * IF_ANY is the highest CPU level by definition
+ */
+#define IF_CPU_LEVEL_MASK      ((IFM_ANY << 1) - 1)
+
+static inline int iflag_cmp_cpu(const iflag_t *a, const iflag_t *b)
+{
+    return ifcomp(a->field[IF_CPU_FIELD], b->field[IF_CPU_FIELD]);
+}
+
+static inline uint32_t _iflag_cpu_level(const iflag_t *a)
+{
+    return a->field[IF_CPU_FIELD] & IF_CPU_LEVEL_MASK;
+}
+
+static inline int iflag_cmp_cpu_level(const iflag_t *a, const iflag_t *b)
+{
+    return ifcomp(_iflag_cpu_level(a), _iflag_cpu_level(b));
+}
+
+/* Returns true if the CPU level is at least a certain value */
+static inline bool iflag_cpu_level_ok(const iflag_t *a, unsigned int bit)
+{
+    return _iflag_cpu_level(a) >= IF_GENBIT(bit);
+}
+
+static inline void iflag_set_all_features(iflag_t *a)
+{
+    uint32_t *p = &a->field[IF_FEATURE_FIELD];
+
+    memset(p, -1, IF_FEATURE_NFIELDS * sizeof(uint32_t));
+}
+
+static inline iflag_t _iflag_pfmask(const iflag_t *a)
+{
+    iflag_t r;
+
+    iflag_clear_all(&r);
+
+    if (iflag_test(a, IF_CYRIX))
+        iflag_set(&r, IF_CYRIX);
+    if (iflag_test(a, IF_AMD))
+        iflag_set(&r, IF_AMD);
+
+    return r;
+}
+
+#define iflag_pfmask(itemp)     _iflag_pfmask(&insns_flags[(itemp)->iflag_idx])
+
+#endif /* NASM_IFLAG_H */
diff --git a/vere/ext/nasm/include/ilog2.h b/vere/ext/nasm/include/ilog2.h
new file mode 100644
index 0000000..bba4595
--- /dev/null
+++ b/vere/ext/nasm/include/ilog2.h
@@ -0,0 +1,201 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef ILOG2_H
+#define ILOG2_H
+
+#include "compiler.h"
+
+#ifdef ILOG2_C                  /* For generating the out-of-line functions */
+# undef extern_inline
+# define extern_inline
+# define inline_prototypes
+#endif
+
+#ifdef inline_prototypes
+extern unsigned int const_func ilog2_32(uint32_t v);
+extern unsigned int const_func ilog2_64(uint64_t v);
+extern unsigned int const_func ilog2_64(uint64_t vv);
+extern int const_func alignlog2_32(uint32_t v);
+extern int const_func alignlog2_64(uint64_t v);
+#endif
+
+#ifdef extern_inline
+
+#define ROUND(v, a, w)                                  \
+    do {                                                \
+        if (v & (((UINT32_C(1) << w) - 1) << w)) {      \
+            a  += w;                                    \
+            v >>= w;                                    \
+        }                                               \
+    } while (0)
+
+
+#if defined(HAVE___BUILTIN_CLZ) && INT_MAX == 2147483647
+
+extern_inline unsigned int const_func ilog2_32(uint32_t v)
+{
+    if (!v)
+        return 0;
+
+    return __builtin_clz(v) ^ 31;
+}
+
+#elif defined(__GNUC__) && defined(__x86_64__)
+
+extern_inline unsigned int const_func ilog2_32(uint32_t v)
+{
+    unsigned int n;
+
+    __asm__("bsrl %1,%0"
+            : "=r" (n)
+            : "rm" (v), "0" (0));
+    return n;
+}
+
+#elif defined(__GNUC__) && defined(__i386__)
+
+extern_inline unsigned int const_func ilog2_32(uint32_t v)
+{
+    unsigned int n;
+
+#ifdef __i686__
+    __asm__("bsrl %1,%0 ; cmovz %2,%0\n"
+            : "=&r" (n)
+            : "rm" (v), "r" (0));
+#else
+    __asm__("bsrl %1,%0 ; jnz 1f ; xorl %0,%0\n"
+            "1:"
+            : "=&r" (n)
+            : "rm" (v));
+#endif
+     return n;
+}
+
+#elif defined(HAVE__BITSCANREVERSE)
+
+extern_inline unsigned int const_func ilog2_32(uint32_t v)
+{
+    unsigned long ix;
+    return _BitScanReverse(&ix, v) ? v : 0;
+}
+
+#else
+
+extern_inline unsigned int const_func ilog2_32(uint32_t v)
+{
+    unsigned int p = 0;
+
+    ROUND(v, p, 16);
+    ROUND(v, p,  8);
+    ROUND(v, p,  4);
+    ROUND(v, p,  2);
+    ROUND(v, p,  1);
+
+    return p;
+}
+
+#endif
+
+#if defined(HAVE__BUILTIN_CLZLL) && LLONG_MAX == 9223372036854775807LL
+
+extern_inline unsigned int const_func ilog2_64(uint64_t v)
+{
+    if (!v)
+        return 0;
+
+    return __builtin_clzll(v) ^ 63;
+}
+
+#elif defined(__GNUC__) && defined(__x86_64__)
+
+extern_inline unsigned int const_func ilog2_64(uint64_t v)
+{
+    uint64_t n;
+
+    __asm__("bsrq %1,%0"
+            : "=r" (n)
+            : "rm" (v), "0" (UINT64_C(0)));
+    return n;
+}
+
+#elif defined(HAVE__BITSCANREVERSE64)
+
+extern_inline unsigned int const_func ilog2_64(uint64_t v)
+{
+    unsigned long ix;
+    return _BitScanReverse64(&ix, v) ? ix : 0;
+}
+
+#else
+
+extern_inline unsigned int const_func ilog2_64(uint64_t vv)
+{
+    unsigned int p = 0;
+    uint32_t v;
+
+    v = vv >> 32;
+    if (v)
+        p += 32;
+    else
+        v = vv;
+
+    return p + ilog2_32(v);
+}
+
+#endif
+
+/*
+ * v == 0 ? 0 : is_power2(x) ? ilog2_X(v) : -1
+ */
+extern_inline int const_func alignlog2_32(uint32_t v)
+{
+    if (unlikely(v & (v-1)))
+        return -1;              /* invalid alignment */
+
+    return ilog2_32(v);
+}
+
+extern_inline int const_func alignlog2_64(uint64_t v)
+{
+    if (unlikely(v & (v-1)))
+        return -1;              /* invalid alignment */
+
+    return ilog2_64(v);
+}
+
+#undef ROUND
+
+#endif /* extern_inline */
+
+#endif /* ILOG2_H */
diff --git a/vere/ext/nasm/include/insns.h b/vere/ext/nasm/include/insns.h
new file mode 100644
index 0000000..00de288
--- /dev/null
+++ b/vere/ext/nasm/include/insns.h
@@ -0,0 +1,132 @@
+/* insns.h   header file for insns.c
+ *
+ * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the license given in the file "LICENSE"
+ * distributed in the NASM archive.
+ */
+
+#ifndef NASM_INSNS_H
+#define NASM_INSNS_H
+
+#include "nasm.h"
+#include "tokens.h"
+#include "iflag.h"
+
+/* if changed, ITEMPLATE_END should be also changed accordingly */
+struct itemplate {
+    enum opcode     opcode;             /* the token, passed from "parser.c" */
+    int             operands;           /* number of operands */
+    opflags_t       opd[MAX_OPERANDS];  /* bit flags for operand types */
+    decoflags_t     deco[MAX_OPERANDS]; /* bit flags for operand decorators */
+    const uint8_t   *code;              /* the code it assembles to */
+    uint32_t        iflag_idx;          /* some flags referenced by index */
+};
+
+/* Use this helper to test instruction template flags */
+static inline bool itemp_has(const struct itemplate *itemp, unsigned int bit)
+{
+    return iflag_test(&insns_flags[itemp->iflag_idx], bit);
+}
+
+/* Disassembler table structure */
+
+/*
+ * If n == -1, then p points to another table of 256
+ * struct disasm_index, otherwise p points to a list of n
+ * struct itemplates to consider.
+ */
+struct disasm_index {
+    const void *p;
+    int n;
+};
+
+/* Tables for the assembler and disassembler, respectively */
+extern const struct itemplate * const nasm_instructions[];
+extern const struct disasm_index itable[256];
+extern const struct disasm_index * const itable_vex[NASM_VEX_CLASSES][32][4];
+
+/* Common table for the byte codes */
+extern const uint8_t nasm_bytecodes[];
+
+/*
+ * this define is used to signify the end of an itemplate
+ */
+#define ITEMPLATE_END {I_none,0,{0,},{0,},NULL,0}
+
+/*
+ * Pseudo-op tests
+ */
+/* DB-type instruction (DB, DW, ...) */
+static inline bool const_func opcode_is_db(enum opcode opcode)
+{
+    return opcode >= I_DB && opcode < I_RESB;
+}
+
+/* RESB-type instruction (RESB, RESW, ...) */
+static inline bool const_func opcode_is_resb(enum opcode opcode)
+{
+    return opcode >= I_RESB && opcode < I_INCBIN;
+}
+
+/* Width of Dx and RESx instructions */
+
+/*
+ * initialized data bytes length from opcode
+ */
+static inline int const_func db_bytes(enum opcode opcode)
+{
+    switch (opcode) {
+    case I_DB:
+        return 1;
+    case I_DW:
+        return 2;
+    case I_DD:
+        return 4;
+    case I_DQ:
+        return 8;
+    case I_DT:
+        return 10;
+    case I_DO:
+        return 16;
+    case I_DY:
+        return 32;
+    case I_DZ:
+        return 64;
+    case I_none:
+        return -1;
+    default:
+        return 0;
+    }
+}
+
+/*
+ * Uninitialized data bytes length from opcode
+ */
+static inline int const_func resb_bytes(enum opcode opcode)
+{
+    switch (opcode) {
+    case I_RESB:
+        return 1;
+    case I_RESW:
+        return 2;
+    case I_RESD:
+        return 4;
+    case I_RESQ:
+        return 8;
+    case I_REST:
+        return 10;
+    case I_RESO:
+        return 16;
+    case I_RESY:
+        return 32;
+    case I_RESZ:
+        return 64;
+    case I_none:
+        return -1;
+    default:
+        return 0;
+    }
+}
+
+#endif /* NASM_INSNS_H */
diff --git a/vere/ext/nasm/include/labels.h b/vere/ext/nasm/include/labels.h
new file mode 100644
index 0000000..a825d1f
--- /dev/null
+++ b/vere/ext/nasm/include/labels.h
@@ -0,0 +1,79 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * labels.h  header file for labels.c
+ */
+
+#ifndef LABELS_H
+#define LABELS_H
+
+#include "compiler.h"
+
+enum mangle_index {
+    LM_LPREFIX,                 /* Local variable prefix */
+    LM_LSUFFIX,                 /* Local variable suffix */
+    LM_GPREFIX,                 /* Global variable prefix */
+    LM_GSUFFIX                  /* GLobal variable suffix */
+};
+
+enum label_type {
+    LBL_none = -1,              /* No label */
+    LBL_LOCAL = 0,              /* Must be zero */
+    LBL_STATIC,
+    LBL_GLOBAL,
+    LBL_EXTERN,
+    LBL_REQUIRED,               /* Like extern but emit even if unused */
+    LBL_COMMON,
+    LBL_SPECIAL,                /* Magic symbols like ..start */
+    LBL_BACKEND                 /* Backend-defined symbols like ..got */
+};
+
+enum label_type lookup_label(const char *label, int32_t *segment, int64_t *offset);
+static inline bool is_extern(enum label_type type)
+{
+    return type == LBL_EXTERN || type == LBL_REQUIRED;
+}
+void define_label(const char *label, int32_t segment, int64_t offset,
+                  bool normal);
+void backend_label(const char *label, int32_t segment, int64_t offset);
+bool declare_label(const char *label, enum label_type type,
+                   const char *special);
+void set_label_mangle(enum mangle_index which, const char *what);
+int init_labels(void);
+void cleanup_labels(void);
+const char *local_scope(const char *label);
+
+extern uint64_t global_offset_changed;
+
+#endif /* LABELS_H */
diff --git a/vere/ext/nasm/include/md5.h b/vere/ext/nasm/include/md5.h
new file mode 100644
index 0000000..cb77910
--- /dev/null
+++ b/vere/ext/nasm/include/md5.h
@@ -0,0 +1,21 @@
+#ifndef MD5_H
+#define MD5_H
+
+#include "compiler.h"
+
+#define MD5_HASHBYTES 16
+
+typedef struct MD5Context {
+	uint32_t buf[4];
+	uint32_t bits[2];
+	unsigned char in[64];
+} MD5_CTX;
+
+extern void   MD5Init(MD5_CTX *context);
+extern void   MD5Update(MD5_CTX *context, unsigned char const *buf,
+	       unsigned len);
+extern void   MD5Final(unsigned char digest[MD5_HASHBYTES], MD5_CTX *context);
+extern void   MD5Transform(uint32_t buf[4], uint32_t const in[16]);
+extern char * MD5End(MD5_CTX *, char *);
+
+#endif /* !MD5_H */
diff --git a/vere/ext/nasm/include/nasm.h b/vere/ext/nasm/include/nasm.h
new file mode 100644
index 0000000..8b017f3
--- /dev/null
+++ b/vere/ext/nasm/include/nasm.h
@@ -0,0 +1,1461 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasm.h   main header file for the Netwide Assembler: inter-module interface
+ */
+
+#ifndef NASM_NASM_H
+#define NASM_NASM_H
+
+#include "compiler.h"
+
+#include <time.h>
+
+#include "nasmlib.h"
+#include "nctype.h"
+#include "strlist.h"
+#include "preproc.h"
+#include "insnsi.h"     /* For enum opcode */
+#include "directiv.h"   /* For enum directive */
+#include "labels.h"     /* For enum mangle_index, enum label_type */
+#include "opflags.h"
+#include "regs.h"
+#include "srcfile.h"
+#include "error.h"
+
+/* Program name for error messages etc. */
+extern const char *_progname;
+
+/* Time stamp for the official start of compilation */
+struct compile_time {
+    time_t t;
+    bool have_local, have_gm, have_posix;
+    int64_t posix;
+    struct tm local;
+    struct tm gm;
+};
+extern struct compile_time official_compile_time;
+
+/* POSIX timestamp if and only if we are not a reproducible build */
+extern bool reproducible;
+static inline int64_t posix_timestamp(void)
+{
+    return reproducible ? 0 : official_compile_time.posix;
+}
+
+#define NO_SEG  INT32_C(-1)     /* null segment value */
+#define SEG_ABS 0x40000000L     /* mask for far-absolute segments */
+
+#define IDLEN_MAX 4096
+#define DECOLEN_MAX 32
+
+/*
+ * Name pollution problems: <time.h> on Digital UNIX pulls in some
+ * strange hardware header file which sees fit to define R_SP. We
+ * undefine it here so as not to break the enum below.
+ */
+#ifdef R_SP
+#undef R_SP
+#endif
+
+/*
+ * We must declare the existence of this structure type up here,
+ * since we have to reference it before we define it...
+ */
+struct ofmt;
+
+/*
+ * Values for the `type' parameter to an output function.
+ */
+enum out_type {
+    OUT_RAWDATA,    /* Plain bytes */
+    OUT_RESERVE,    /* Reserved bytes (RESB et al) */
+    OUT_ZERODATA,   /* Initialized data, but all zero */
+    OUT_ADDRESS,    /* An address (symbol value) */
+    OUT_RELADDR,    /* A relative address */
+    OUT_SEGMENT,    /* A segment number */
+
+    /*
+     * These values are used by the legacy backend interface only;
+     * see output/legacy.c for more information.  These should never
+     * be used otherwise.  Once all backends have been migrated to the
+     * new interface they should be removed.
+     */
+    OUT_REL1ADR,
+    OUT_REL2ADR,
+    OUT_REL4ADR,
+    OUT_REL8ADR
+};
+
+enum out_flags {
+    OUT_WRAP     = 0,           /* Undefined signedness (wraps) */
+    OUT_SIGNED   = 1,           /* Value is signed */
+    OUT_UNSIGNED = 2,           /* Value is unsigned */
+    OUT_SIGNMASK = 3            /* Mask for signedness bits */
+};
+
+/*
+ * The data we send down to the backend.
+ * XXX: We still want to push down the base address symbol if
+ * available, and replace the segment numbers with a structure.
+ */
+struct out_data {
+    int64_t offset;             /* Offset within segment */
+    int32_t segment;            /* Segment written to */
+    enum out_type type;         /* See above */
+    enum out_flags flags;       /* See above */
+    int inslen;                 /* Length of instruction */
+    int insoffs;                /* Offset inside instruction */
+    int bits;                   /* Bits mode of compilation */
+    uint64_t size;              /* Size of output */
+    const struct itemplate *itemp; /* Instruction template */
+    const void *data;           /* Data for OUT_RAWDATA */
+    uint64_t toffset;           /* Target address offset for relocation */
+    int32_t tsegment;           /* Target segment for relocation */
+    int32_t twrt;               /* Relocation with respect to */
+    int64_t relbase;            /* Relative base for OUT_RELADDR */
+    struct src_location where;  /* Source file and line */
+};
+
+/*
+ * And a label-definition function. The boolean parameter
+ * `is_norm' states whether the label is a `normal' label (which
+ * should affect the local-label system), or something odder like
+ * an EQU or a segment-base symbol, which shouldn't.
+ */
+typedef void (*ldfunc)(char *label, int32_t segment, int64_t offset,
+                       char *special, bool is_norm);
+
+/*
+ * Token types returned by the scanner, in addition to ordinary
+ * ASCII character values, and zero for end-of-string.
+ */
+enum token_type { /* token types, other than chars */
+
+    /* Token values shared between assembler and preprocessor */
+
+    /* Special codes */
+    TOKEN_INVALID = -1, /* a placeholder value */
+    TOKEN_BLOCK   = -2, /* used for storage management */
+    TOKEN_FREE    = -3, /* free token marker, use to catch leaks */
+    TOKEN_EOS     = 0,  /* end of string */
+
+    /*
+     * Single-character operators. Enumerated here to keep strict
+     * compilers happy, and for documentation.
+     */
+    TOKEN_WHITESPACE = ' ',     /* Preprocessor use */
+    TOKEN_BOOL_NOT   = '!',
+    TOKEN_AND        = '&',
+    TOKEN_OR         = '|',
+    TOKEN_XOR        = '^',
+    TOKEN_NOT        = '~',
+    TOKEN_MULT       = '*',
+    TOKEN_DIV        = '/',
+    TOKEN_MOD        = '%',
+    TOKEN_LPAR       = '(',
+    TOKEN_RPAR       = ')',
+    TOKEN_PLUS       = '+',
+    TOKEN_MINUS      = '-',
+    TOKEN_COMMA      = ',',
+    TOKEN_LBRACE     = '{',
+    TOKEN_RBRACE     = '}',
+    TOKEN_LBRACKET   = '[',
+    TOKEN_RBRACKET   = ']',
+    TOKEN_QMARK      = '?',
+    TOKEN_EQ         = '=',     /* = or == */
+    TOKEN_GT         = '>',
+    TOKEN_LT         = '<',
+
+    /* Multi-character operators */
+    TOKEN_SHL = 256,    /* << or <<< */
+    TOKEN_SHR,          /* >> */
+    TOKEN_SAR,          /* >>> */
+    TOKEN_SDIV,         /* // */
+    TOKEN_SMOD,         /* %% */
+    TOKEN_GE,           /* >= */
+    TOKEN_LE,           /* <= */
+    TOKEN_NE,           /* <> (!= is same as <>) */
+    TOKEN_LEG,          /* <=> */
+    TOKEN_DBL_AND,      /* && */
+    TOKEN_DBL_OR,       /* || */
+    TOKEN_DBL_XOR,      /* ^^ */
+
+    TOKEN_MAX_OPERATOR,
+
+    TOKEN_NUM,          /* numeric constant */
+    TOKEN_ERRNUM,       /* malformed numeric constant */
+    TOKEN_STR,          /* string constant */
+    TOKEN_ERRSTR,       /* unterminated string constant */
+    TOKEN_ID,           /* identifier */
+    TOKEN_FLOAT,        /* floating-point constant */
+    TOKEN_HERE,         /* $, not '$' because it is not an operator */
+    TOKEN_BASE,         /* $$ */
+
+    /* Token values only used by the assembler */
+    TOKEN_START_ASM,
+
+    TOKEN_SEG,          /* SEG */
+    TOKEN_WRT,          /* WRT */
+    TOKEN_FLOATIZE,     /* __?floatX?__ */
+    TOKEN_STRFUNC,      /* __utf16*__, __utf32*__ */
+    TOKEN_IFUNC,        /* __ilog2*__ */
+    TOKEN_DECORATOR,    /* decorators such as {...} */
+    TOKEN_MASM_PTR,     /* __?masm_ptr?__ for the masm package */
+    TOKEN_MASM_FLAT,    /* __?masm_flat?__ for the masm package */
+    TOKEN_OPMASK,       /* translated token for opmask registers */
+    TOKEN_SIZE,		/* BYTE, WORD, DWORD, QWORD, etc */
+    TOKEN_SPECIAL,      /* REL, FAR, NEAR, STRICT, NOSPLIT, etc */
+    TOKEN_PREFIX,       /* A32, O16, LOCK, REPNZ, TIMES, etc */
+    TOKEN_REG,          /* register name */
+    TOKEN_INSN,         /* instruction name */
+
+    TOKEN_END_ASM,
+
+    /* Token values only used by the preprocessor */
+
+    TOKEN_START_PP = TOKEN_END_ASM,
+
+    TOKEN_OTHER,           /* % sequence without (current) meaning */
+    TOKEN_PREPROC_ID,      /* Preprocessor ID, e.g. %symbol */
+    TOKEN_MMACRO_PARAM,    /* MMacro parameter, e.g. %1 */
+    TOKEN_LOCAL_SYMBOL,    /* Local symbol, e.g. %%symbol */
+    TOKEN_LOCAL_MACRO,     /* Context-local macro, e.g. %$symbol */
+    TOKEN_ENVIRON,         /* %! */
+    TOKEN_INTERNAL_STR,    /* Unquoted string that should remain so */
+    TOKEN_NAKED_STR,       /* Unquoted string that can be re-quoted */
+    TOKEN_PREPROC_Q,       /* %? */
+    TOKEN_PREPROC_QQ,      /* %?? */
+    TOKEN_PREPROC_SQ,      /* %*? */
+    TOKEN_PREPROC_SQQ,     /* %*?? */
+    TOKEN_PASTE,           /* %+ */
+    TOKEN_COND_COMMA,      /* %, */
+    TOKEN_INDIRECT,        /* %[...] */
+    TOKEN_XDEF_PARAM,      /* Used during %xdefine processing */
+    /* smacro parameters starting here; an arbitrary number. */
+    TOKEN_SMAC_START_PARAMS,    /* MUST BE LAST IN THE LIST!!! */
+    TOKEN_MAX = INT_MAX		/* Keep compiler from reducing the range */
+};
+
+/* Must match the fp_formats[] array in asm/floats.c */
+enum floatize {
+    FLOAT_8,
+    FLOAT_16,
+    FLOAT_B16,
+    FLOAT_32,
+    FLOAT_64,
+    FLOAT_80M,
+    FLOAT_80E,
+    FLOAT_128L,
+    FLOAT_128H,
+    FLOAT_ERR                   /* Invalid format, MUST BE LAST */
+};
+
+/* Must match the list in string_transform(), in strfunc.c */
+enum strfunc {
+    STRFUNC_UTF16,
+    STRFUNC_UTF16LE,
+    STRFUNC_UTF16BE,
+    STRFUNC_UTF32,
+    STRFUNC_UTF32LE,
+    STRFUNC_UTF32BE
+};
+
+enum ifunc {
+    IFUNC_ILOG2E,
+    IFUNC_ILOG2W,
+    IFUNC_ILOG2F,
+    IFUNC_ILOG2C
+};
+
+size_t string_transform(char *, size_t, char **, enum strfunc);
+
+/*
+ * The expression evaluator must be passed a scanner function; a
+ * standard scanner is provided as part of nasmlib.c. The
+ * preprocessor will use a different one. Scanners, and the
+ * token-value structures they return, look like this.
+ *
+ * The return value from the scanner is always a copy of the
+ * `t_type' field in the structure.
+ */
+struct tokenval {
+    char                *t_charptr;
+    int64_t             t_integer;
+    int64_t             t_inttwo;
+    enum token_type     t_type;
+    int8_t              t_flag;
+};
+typedef int (*scanner)(void *private_data, struct tokenval *tv);
+
+struct location {
+    int64_t offset;
+    int32_t segment;
+    int     known;
+};
+extern struct location location;
+
+/*
+ * Expression-evaluator datatype. Expressions, within the
+ * evaluator, are stored as an array of these beasts, terminated by
+ * a record with type==0. Mostly, it's a vector type: each type
+ * denotes some kind of a component, and the value denotes the
+ * multiple of that component present in the expression. The
+ * exception is the WRT type, whose `value' field denotes the
+ * segment to which the expression is relative. These segments will
+ * be segment-base types, i.e. either odd segment values or SEG_ABS
+ * types. So it is still valid to assume that anything with a
+ * `value' field of zero is insignificant.
+ */
+typedef struct {
+    int32_t type;                  /* a register, or EXPR_xxx */
+    int64_t value;                 /* must be >= 32 bits */
+} expr;
+
+/*
+ * Library routines to manipulate expression data types.
+ */
+bool is_reloc(const expr *vect);
+bool is_simple(const expr *vect);
+bool is_really_simple(const expr *vect);
+bool is_unknown(const expr *vect);
+bool is_just_unknown(const expr *vect);
+int64_t reloc_value(const expr *vect);
+int32_t reloc_seg(const expr *vect);
+int32_t reloc_wrt(const expr *vect);
+bool is_self_relative(const expr *vect);
+void dump_expr(const expr *vect);
+
+/*
+ * The evaluator can also return hints about which of two registers
+ * used in an expression should be the base register. See also the
+ * `operand' structure.
+ */
+struct eval_hints {
+    int64_t base;
+    int     type;
+};
+
+/*
+ * The actual expression evaluator function looks like this. When
+ * called, it expects the first token of its expression to already
+ * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
+ * it will start by calling the scanner.
+ *
+ * If a forward reference happens during evaluation, the evaluator
+ * must set `*fwref' to true if `fwref' is non-NULL.
+ *
+ * `critical' is non-zero if the expression may not contain forward
+ * references. The evaluator will report its own error if this
+ * occurs; if `critical' is 1, the error will be "symbol not
+ * defined before use", whereas if `critical' is 2, the error will
+ * be "symbol undefined".
+ *
+ * If `critical' has bit 8 set (in addition to its main value: 0x101
+ * and 0x102 correspond to 1 and 2) then an extended expression
+ * syntax is recognised, in which relational operators such as =, <
+ * and >= are accepted, as well as low-precedence logical operators
+ * &&, ^^ and ||.
+ *
+ * If `hints' is non-NULL, it gets filled in with some hints as to
+ * the base register in complex effective addresses.
+ */
+#define CRITICAL 0x100
+typedef expr *(*evalfunc)(scanner sc, void *scprivate,
+                          struct tokenval *tv, int *fwref, int critical,
+                          struct eval_hints *hints);
+
+/*
+ * Special values for expr->type.
+ * These come after EXPR_REG_END as defined in regs.h.
+ * Expr types : 0 ~ EXPR_REG_END, EXPR_UNKNOWN, EXPR_...., EXPR_RDSAE,
+ *              EXPR_SEGBASE ~ EXPR_SEGBASE + SEG_ABS, ...
+ */
+#define EXPR_UNKNOWN    (EXPR_REG_END+1) /* forward references */
+#define EXPR_SIMPLE     (EXPR_REG_END+2)
+#define EXPR_WRT        (EXPR_REG_END+3)
+#define EXPR_RDSAE      (EXPR_REG_END+4)
+#define EXPR_SEGBASE    (EXPR_REG_END+5)
+
+/*
+ * preprocessors ought to look like this:
+ */
+
+enum preproc_mode {
+    PP_NORMAL,                  /* Assembly */
+    PP_DEPS,                    /* Dependencies only */
+    PP_PREPROC                  /* Preprocessing only */
+};
+
+enum preproc_opt {
+    PP_TRIVIAL  = 1,            /* Only %line or # directives */
+    PP_NOLINE   = 2,            /* Ignore %line and # directives */
+    PP_TASM     = 4             /* TASM compatibility hacks */
+};
+
+/*
+ * Called once at the very start of assembly.
+ */
+void pp_init(enum preproc_opt opt);
+
+/*
+ * Called at the start of a pass; given a file name, the number
+ * of the pass, an error reporting function, an evaluator
+ * function, and a listing generator to talk to.
+ */
+void pp_reset(const char *file, enum preproc_mode mode,
+              struct strlist *deplist);
+
+/*
+ * Called to fetch a line of preprocessed source. The line
+ * returned has been malloc'ed, and so should be freed after
+ * use.
+ */
+char *pp_getline(void);
+
+/* Called at the end of each pass. */
+void pp_cleanup_pass(void);
+
+/*
+ * Called at the end of the assembly session,
+ * after cleanup_pass() has been called for the
+ * last pass.
+ */
+void pp_cleanup_session(void);
+
+/* Additional macros specific to output format */
+void pp_extra_stdmac(macros_t *macros);
+
+/* Early definitions and undefinitions for macros */
+void pp_pre_define(char *definition);
+void pp_pre_undefine(char *definition);
+
+/* Include file from command line */
+void pp_pre_include(char *fname);
+
+/* Add a command from the command line */
+void pp_pre_command(const char *what, char *str);
+
+/* Include path from command line */
+void pp_include_path(struct strlist *ipath);
+
+/* Unwind the macro stack when printing an error message */
+void pp_error_list_macros(errflags severity);
+
+/* Return true if an error message should be suppressed */
+bool pp_suppress_error(errflags severity);
+
+/* List of dependency files */
+extern struct strlist *depend_list;
+
+/* TASM mode changes some properties */
+extern bool tasm_compatible_mode;
+
+/*
+ * inline function to skip past an identifier; returns the first character past
+ * the identifier if valid, otherwise NULL.
+ */
+static inline char *nasm_skip_identifier(const char *str)
+{
+    const char *p = str;
+
+    if (!nasm_isidstart(*p++)) {
+        p = NULL;
+    } else {
+        while (nasm_isidchar(*p++))
+            ;
+    }
+    return (char *)p;
+}
+
+/*
+ * Data-type flags that get passed to listing-file routines.
+ */
+enum {
+    LIST_READ,
+    LIST_MACRO,
+    LIST_INCLUDE,
+    LIST_INCBIN,
+    LIST_TIMES
+};
+
+/*
+ * -----------------------------------------------------------
+ * Format of the `insn' structure returned from `parser.c' and
+ * passed into `assemble.c'
+ * -----------------------------------------------------------
+ */
+
+/* Verify value to be a valid register */
+static inline bool is_register(int reg)
+{
+    return reg >= EXPR_REG_START && reg < REG_ENUM_LIMIT;
+}
+
+/*
+ * token flags
+ */
+#define TFLAG_BRC       (1 << 0)    /* valid only with braces. {1to8}, {rd-sae}, ...*/
+#define TFLAG_BRC_OPT   (1 << 1)    /* may or may not have braces. opmasks {k1} */
+#define TFLAG_BRC_ANY   (TFLAG_BRC | TFLAG_BRC_OPT)
+#define TFLAG_BRDCAST   (1 << 2)    /* broadcasting decorator */
+#define TFLAG_WARN	(1 << 3)    /* warning only, treat as ID */
+#define TFLAG_DUP	(1 << 4)    /* valid ID but also has context-specific use */
+
+/*
+ * REX flags
+ */
+#define REX_MASK    0x4f    /* Actual REX prefix bits */
+#define REX_B       0x01    /* ModRM r/m extension */
+#define REX_X       0x02    /* SIB index extension */
+#define REX_R       0x04    /* ModRM reg extension */
+#define REX_W       0x08    /* 64-bit operand size */
+#define REX_L       0x20    /* Use LOCK prefix instead of REX.R */
+#define REX_P       0x40    /* REX prefix present/required */
+#define REX_H       0x80    /* High register present, REX forbidden */
+#define REX_V       0x0100  /* Instruction uses VEX/XOP instead of REX */
+#define REX_NH      0x0200  /* Instruction which doesn't use high regs */
+#define REX_EV      0x0400  /* Instruction uses EVEX instead of REX */
+
+/*
+ * EVEX bit field
+ */
+#define EVEX_P0MM       0x0f        /* EVEX P[3:0] : Opcode map           */
+#define EVEX_P0RP       0x10        /* EVEX P[4] : High-16 reg            */
+#define EVEX_P0X        0x40        /* EVEX P[6] : High-16 rm             */
+#define EVEX_P1PP       0x03        /* EVEX P[9:8] : Legacy prefix        */
+#define EVEX_P1VVVV     0x78        /* EVEX P[14:11] : NDS register       */
+#define EVEX_P1W        0x80        /* EVEX P[15] : Osize extension       */
+#define EVEX_P2AAA      0x07        /* EVEX P[18:16] : Embedded opmask    */
+#define EVEX_P2VP       0x08        /* EVEX P[19] : High-16 NDS reg       */
+#define EVEX_P2B        0x10        /* EVEX P[20] : Broadcast / RC / SAE  */
+#define EVEX_P2LL       0x60        /* EVEX P[22:21] : Vector length      */
+#define EVEX_P2RC       EVEX_P2LL   /* EVEX P[22:21] : Rounding control   */
+#define EVEX_P2Z        0x80        /* EVEX P[23] : Zeroing/Merging       */
+
+/*
+ * REX_V "classes" (prefixes which behave like VEX)
+ */
+enum vex_class {
+    RV_VEX      = 0,    /* C4/C5 */
+    RV_XOP      = 1,    /* 8F */
+    RV_EVEX     = 2     /* 62 */
+};
+
+/*
+ * Note that because segment registers may be used as instruction
+ * prefixes, we must ensure the enumerations for prefixes and
+ * register names do not overlap.
+ */
+enum prefixes { /* instruction prefixes */
+    P_none = 0,
+    PREFIX_ENUM_START = REG_ENUM_LIMIT,
+    P_A16 = PREFIX_ENUM_START,
+    P_A32,
+    P_A64,
+    P_ASP,
+    P_LOCK,
+    P_O16,
+    P_O32,
+    P_O64,
+    P_OSP,
+    P_REP,
+    P_REPE,
+    P_REPNE,
+    P_REPNZ,
+    P_REPZ,
+    P_TIMES,
+    P_WAIT,
+    P_XACQUIRE,
+    P_XRELEASE,
+    P_BND,
+    P_NOBND,
+    P_REX,
+    P_EVEX,
+    P_VEX,
+    P_VEX3,
+    P_VEX2,
+    PREFIX_ENUM_LIMIT
+};
+
+enum ea_flags { /* special EA flags */
+    EAF_BYTEOFFS    =   1,  /* force offset part to byte size */
+    EAF_WORDOFFS    =   2,  /* force offset part to [d]word size */
+    EAF_TIMESTWO    =   4,  /* really do EAX*2 not EAX+EAX */
+    EAF_REL         =   8,  /* IP-relative addressing */
+    EAF_ABS         =  16,  /* non-IP-relative addressing */
+    EAF_FSGS        =  32,  /* fs/gs segment override present */
+    EAF_MIB         =  64,  /* mib operand */
+    EAF_SIB         = 128   /* SIB encoding obligatory */
+};
+
+enum eval_hint { /* values for `hinttype' */
+    EAH_NOHINT   = 0,       /* no hint at all - our discretion */
+    EAH_MAKEBASE = 1,       /* try to make given reg the base */
+    EAH_NOTBASE  = 2,       /* try _not_ to make reg the base */
+    EAH_SUMMED   = 3        /* base and index are summed into index */
+};
+
+typedef struct operand { /* operand to an instruction */
+    opflags_t       type;       /* type of operand */
+    int             disp_size;  /* 0 means default; 16; 32; 64 */
+    enum reg_enum   basereg;
+    enum reg_enum   indexreg;   /* address registers */
+    int             scale;      /* index scale */
+    int             hintbase;
+    enum eval_hint  hinttype;   /* hint as to real base register */
+    int32_t         segment;    /* immediate segment, if needed */
+    int64_t         offset;     /* any immediate number */
+    int32_t         wrt;        /* segment base it's relative to */
+    int             eaflags;    /* special EA flags */
+    int             opflags;    /* see OPFLAG_* defines below */
+    decoflags_t     decoflags;  /* decorator flags such as {...} */
+} operand;
+
+#define OPFLAG_FORWARD      1   /* operand is a forward reference */
+#define OPFLAG_EXTERN       2   /* operand is an external reference */
+#define OPFLAG_UNKNOWN      4   /* operand is an unknown reference
+                                   (always a forward reference also) */
+#define OPFLAG_RELATIVE     8   /* operand is self-relative, e.g. [foo - $]
+                                   where foo is not in the current segment */
+
+enum extop_type { /* extended operand types */
+    EOT_NOTHING = 0,
+    EOT_EXTOP,          /* Subexpression */
+    EOT_DB_STRING,      /* Byte string */
+    EOT_DB_FLOAT,       /* Floating-pointer number (special byte string) */
+    EOT_DB_STRING_FREE, /* Byte string which should be nasm_free'd*/
+    EOT_DB_NUMBER,      /* Integer */
+    EOT_DB_RESERVE      /* ? */
+};
+
+typedef struct extop { /* extended operand */
+    struct extop    *next;       /* linked list */
+    union {
+        struct {                 /* text or byte string */
+            char    *data;
+            size_t   len;
+        } string;
+        struct {                 /* numeric expression */
+            int64_t  offset;     /* numeric value or address offset */
+            int32_t  segment;    /* address segment */
+            int32_t  wrt;        /* address wrt */
+            bool     relative;   /* self-relative expression */
+        } num;
+        struct extop *subexpr;   /* actual expressions */
+    } val;
+    size_t dup;                  /* duplicated? */
+    enum extop_type type;        /* defined above */
+    int elem;                    /* element size override, if any (bytes) */
+} extop;
+
+enum ea_type {
+    EA_INVALID,     /* Not a valid EA at all */
+    EA_SCALAR,      /* Scalar EA */
+    EA_XMMVSIB,     /* XMM vector EA */
+    EA_YMMVSIB,     /* YMM vector EA */
+    EA_ZMMVSIB      /* ZMM vector EA */
+};
+
+/*
+ * Prefix positions: each type of prefix goes in a specific slot.
+ * This affects the final ordering of the assembled output, which
+ * shouldn't matter to the processor, but if you have stylistic
+ * preferences, you can change this.  REX prefixes are handled
+ * differently for the time being.
+ *
+ * LOCK and REP used to be one slot; this is no longer the case since
+ * the introduction of HLE.
+ */
+enum prefix_pos {
+    PPS_TIMES = -1,     /* TIMES (not a slot, handled separately) */
+    PPS_WAIT  =  0,   	/* WAIT (technically not a prefix!) */
+    PPS_REP,    	/* REP/HLE prefix */
+    PPS_LOCK,   	/* LOCK prefix */
+    PPS_SEG,    	/* Segment override prefix */
+    PPS_OSIZE,  	/* Operand size prefix */
+    PPS_ASIZE,  	/* Address size prefix */
+    PPS_REX,    	/* REX/VEX type */
+    MAXPREFIX   	/* Total number of prefix slots */
+};
+
+/*
+ * Tuple types that are used when determining Disp8*N eligibility
+ * The order must match with a hash %tuple_codes in insns.pl
+ */
+enum ttypes {
+    FV    = 001,
+    HV    = 002,
+    FVM   = 003,
+    T1S8  = 004,
+    T1S16 = 005,
+    T1S   = 006,
+    T1F32 = 007,
+    T1F64 = 010,
+    T2    = 011,
+    T4    = 012,
+    T8    = 013,
+    HVM   = 014,
+    QVM   = 015,
+    OVM   = 016,
+    M128  = 017,
+    DUP   = 020
+};
+
+/* EVEX.L'L : Vector length on vector insns */
+enum vectlens {
+    VL128 = 0,
+    VL256 = 1,
+    VL512 = 2,
+    VLMAX = 3
+};
+
+/* If you need to change this, also change it in insns.pl */
+#define MAX_OPERANDS 5
+
+typedef struct insn { /* an instruction itself */
+    char            *label;                 /* the label defined, or NULL */
+    int             prefixes[MAXPREFIX];    /* instruction prefixes, if any */
+    enum opcode     opcode;                 /* the opcode - not just the string */
+    int             operands;               /* how many operands? 0-3 (more if db et al) */
+    int             addr_size;              /* address size */
+    operand         oprs[MAX_OPERANDS];     /* the operands, defined as above */
+    extop           *eops;                  /* extended operands */
+    int             eops_float;             /* true if DD and floating */
+    int32_t         times;                  /* repeat count (TIMES prefix) */
+    bool            forw_ref;               /* is there a forward reference? */
+    bool            rex_done;               /* REX prefix emitted? */
+    int             rex;                    /* Special REX Prefix */
+    int             vexreg;                 /* Register encoded in VEX prefix */
+    int             vex_cm;                 /* Class and M field for VEX prefix */
+    int             vex_wlp;                /* W, P and L information for VEX prefix */
+    uint8_t         evex_p[3];              /* EVEX.P0: [RXB,R',00,mm], P1: [W,vvvv,1,pp] */
+                                            /* EVEX.P2: [z,L'L,b,V',aaa] */
+    enum ttypes     evex_tuple;             /* Tuple type for compressed Disp8*N */
+    int             evex_rm;                /* static rounding mode for AVX512 (EVEX) */
+    int8_t          evex_brerop;            /* BR/ER/SAE operand position */
+} insn;
+
+/* Instruction flags type: IF_* flags are defined in insns.h */
+typedef uint64_t iflags_t;
+
+/*
+ * What to return from a directive- or pragma-handling function.
+ * Currently DIRR_OK and DIRR_ERROR are treated the same way;
+ * in both cases the backend is expected to produce the appropriate
+ * error message on its own.
+ *
+ * DIRR_BADPARAM causes a generic error message to be printed.  Note
+ * that it is an error, not a warning, even in the case of pragmas;
+ * don't use it where forward compatibility would be compromised
+ * (instead consider adding a DIRR_WARNPARAM.)
+ */
+enum directive_result {
+    DIRR_UNKNOWN,               /* Directive not handled by backend */
+    DIRR_OK,                    /* Directive processed */
+    DIRR_ERROR,                 /* Directive processed unsuccessfully */
+    DIRR_BADPARAM               /* Print bad argument error message */
+};
+
+/*
+ * A pragma facility: this structure is used to request passing a
+ * parsed pragma directive for a specific facility.  If the handler is
+ * NULL then this pragma facility is recognized but ignored; pragma
+ * processing stops at that point.
+ *
+ * Note that the handler is passed a pointer to the facility structure
+ * as part of the struct pragma.
+ */
+struct pragma;
+typedef enum directive_result (*pragma_handler)(const struct pragma *);
+
+struct pragma_facility {
+    const char *name;
+    pragma_handler handler;
+};
+
+/*
+ * This structure defines how a pragma directive is passed to a
+ * facility.  This structure may be augmented in the future.
+ *
+ * Any facility MAY, but is not required to, add its operations
+ * keywords or a subset thereof into asm/directiv.dat, in which case
+ * the "opcode" field will be set to the corresponding D_ constant
+ * from directiv.h; otherwise it will be D_unknown.
+ */
+struct pragma {
+    const struct pragma_facility *facility;
+    const char *facility_name;  /* Facility name exactly as entered by user */
+    const char *opname;         /* First word after the facility name */
+    const char *tail;           /* Anything after the operation */
+    enum directive opcode;     /* Operation as a D_ directives constant */
+};
+
+/*
+ * These are semi-arbitrary limits to keep the assembler from going
+ * into a black hole on certain kinds of bugs.  They can be overridden
+ * by command-line options or %pragma.
+ */
+enum nasm_limit {
+    LIMIT_PASSES,
+    LIMIT_STALLED,
+    LIMIT_MACRO_LEVELS,
+    LIMIT_MACRO_TOKENS,
+    LIMIT_MMACROS,
+    LIMIT_REP,
+    LIMIT_EVAL,
+    LIMIT_LINES
+};
+#define LIMIT_MAX LIMIT_LINES
+extern int64_t nasm_limit[LIMIT_MAX+1];
+extern enum directive_result  nasm_set_limit(const char *, const char *);
+
+/*
+ * The data structure defining an output format driver, and the
+ * interfaces to the functions therein.
+ */
+struct ofmt {
+    /*
+     * This is a short (one-liner) description of the type of
+     * output generated by the driver.
+     */
+    const char *fullname;
+
+    /*
+     * This is a single keyword used to select the driver.
+     */
+    const char *shortname;
+
+    /*
+     * Default output filename extension, or a null string
+     */
+    const char *extension;
+
+    /*
+     * Output format flags.
+     */
+#define OFMT_TEXT		1	/* Text file format */
+#define OFMT_KEEP_ADDR	2	/* Keep addr; no conversion to data */
+
+    unsigned int flags;
+
+    int maxbits;                /* Maximum segment bits supported */
+
+    /*
+     * this is a pointer to the first element of the debug information
+     */
+    const struct dfmt * const *debug_formats;
+
+    /*
+     * the default debugging format if -F is not specified
+     */
+    const struct dfmt *default_dfmt;
+
+    /*
+     * This, if non-NULL, is a NULL-terminated list of `char *'s
+     * pointing to extra standard macros supplied by the object
+     * format (e.g. a sensible initial default value of __?SECT?__,
+     * and user-level equivalents for any format-specific
+     * directives).
+     */
+    macros_t *stdmac;
+
+    /*
+     * This procedure is called at the start of an output session to set
+     * up internal parameters.
+     */
+    void (*init)(void);
+
+    /*
+     * This procedure is called at the start of each pass.
+     */
+    void (*reset)(void);
+
+    /*
+     * This is the modern output function, which gets passed
+     * a struct out_data with much more information.  See the
+     * definition of struct out_data.
+     */
+    void (*output)(const struct out_data *data);
+
+    /*
+     * This procedure is called by assemble() to write actual
+     * generated code or data to the object file. Typically it
+     * doesn't have to actually _write_ it, just store it for
+     * later.
+     *
+     * The `type' argument specifies the type of output data, and
+     * usually the size as well: its contents are described below.
+     *
+     * This is used for backends which have not yet been ported to
+     * the new interface, and should be NULL on ported backends.
+     * To use this entry point, set the output pointer to
+     * nasm_do_legacy_output.
+     */
+    void (*legacy_output)(int32_t segto, const void *data,
+                          enum out_type type, uint64_t size,
+                          int32_t segment, int32_t wrt);
+
+    /*
+     * This procedure is called once for every symbol defined in
+     * the module being assembled. It gives the name and value of
+     * the symbol, in NASM's terms, and indicates whether it has
+     * been declared to be global. Note that the parameter "name",
+     * when passed, will point to a piece of static storage
+     * allocated inside the label manager - it's safe to keep using
+     * that pointer, because the label manager doesn't clean up
+     * until after the output driver has.
+     *
+     * Values of `is_global' are: 0 means the symbol is local; 1
+     * means the symbol is global; 2 means the symbol is common (in
+     * which case `offset' holds the _size_ of the variable).
+     * Anything else is available for the output driver to use
+     * internally.
+     *
+     * This routine explicitly _is_ allowed to call the label
+     * manager to define further symbols, if it wants to, even
+     * though it's been called _from_ the label manager. That much
+     * re-entrancy is guaranteed in the label manager. However, the
+     * label manager will in turn call this routine, so it should
+     * be prepared to be re-entrant itself.
+     *
+     * The `special' parameter contains special information passed
+     * through from the command that defined the label: it may have
+     * been an EXTERN, a COMMON or a GLOBAL. The distinction should
+     * be obvious to the output format from the other parameters.
+     */
+    void (*symdef)(char *name, int32_t segment, int64_t offset,
+                   int is_global, char *special);
+
+    /*
+     * This procedure is called when the source code requests a
+     * segment change. It should return the corresponding segment
+     * _number_ for the name, or NO_SEG if the name is not a valid
+     * segment name.
+     *
+     * It may also be called with NULL, in which case it is to
+     * return the _default_ section number for starting assembly in.
+     *
+     * It is allowed to modify the string it is given a pointer to.
+     *
+     * It is also allowed to specify a default instruction size for
+     * the segment, by setting `*bits' to 16, 32 or 64. Or, if it
+     * doesn't wish to define a default, it can leave `bits' alone.
+     */
+    int32_t (*section)(char *name, int *bits);
+
+    /*
+     * This function is called when a label is defined
+     * in the source code. It is allowed to change the section
+     * number as a result, but not the bits value.
+     * This is *only* called if the symbol defined is at the
+     * current offset, i.e. "foo:" or "foo equ $".
+     * The offset isn't passed; and may not be stable at this point.
+     * The subsection number is a field available for use by the
+     * backend. It is initialized to NO_SEG.
+     *
+     * If "copyoffset" is set by the backend then the offset is
+     * copied from the previous segment, otherwise the new segment
+     * is treated as a new segment the normal way.
+     */
+    int32_t (*herelabel)(const char *name, enum label_type type,
+                         int32_t seg, int32_t *subsection,
+                         bool *copyoffset);
+
+    /*
+     * This procedure is called to modify section alignment,
+     * note there is a trick, the alignment can only increase
+     */
+    void (*sectalign)(int32_t seg, unsigned int value);
+
+    /*
+     * This procedure is called to modify the segment base values
+     * returned from the SEG operator. It is given a segment base
+     * value (i.e. a segment value with the low bit set), and is
+     * required to produce in return a segment value which may be
+     * different. It can map segment bases to absolute numbers by
+     * means of returning SEG_ABS types.
+     *
+     * It should return NO_SEG if the segment base cannot be
+     * determined; the evaluator (which calls this routine) is
+     * responsible for throwing an error condition if that occurs
+     * in pass two or in a critical expression.
+     */
+    int32_t (*segbase)(int32_t segment);
+
+    /*
+     * This procedure is called to allow the output driver to
+     * process its own specific directives. When called, it has the
+     * directive word in `directive' and the parameter string in
+     * `value'.
+     *
+     * The following values are (currently) possible for
+     * directive_result:
+     *
+     * 0 - DIRR_UNKNOWN		- directive not recognized by backend
+     * 1 - DIRR_OK		- directive processed ok
+     * 2 - DIRR_ERROR		- backend printed its own error message
+     * 3 - DIRR_BADPARAM	- print the generic message
+     *				  "invalid parameter to [*] directive"
+     */
+    enum directive_result
+    (*directive)(enum directive directive, char *value);
+
+    /*
+     * This procedure is called after assembly finishes, to allow
+     * the output driver to clean itself up and free its memory.
+     * Typically, it will also be the point at which the object
+     * file actually gets _written_.
+     *
+     * One thing the cleanup routine should always do is to close
+     * the output file pointer.
+     */
+    void (*cleanup)(void);
+
+    /*
+     * List of pragma facility names that apply to this backend.
+     */
+    const struct pragma_facility *pragmas;
+};
+
+/*
+ * Output format driver alias
+ */
+struct ofmt_alias {
+    const char  *shortname;
+    const struct ofmt *ofmt;
+};
+
+extern const struct ofmt *ofmt;
+extern FILE *ofile;
+
+/*
+ * ------------------------------------------------------------
+ * The data structure defining a debug format driver, and the
+ * interfaces to the functions therein.
+ * ------------------------------------------------------------
+ */
+struct debug_macro_info;
+
+struct dfmt {
+    /*
+     * This is a short (one-liner) description of the type of
+     * output generated by the driver.
+     */
+    const char *fullname;
+
+    /*
+     * This is a single keyword used to select the driver.
+     */
+    const char *shortname;
+
+    /*
+     * init - called initially to set up local pointer to object format.
+     */
+    void (*init)(void);
+
+    /*
+     * linenum - called any time there is output with a change of
+     * line number or file.
+     */
+    void (*linenum)(const char *filename, int32_t linenumber, int32_t segto);
+
+    /*
+     * debug_deflabel - called whenever a label is defined. Parameters
+     * are the same as to 'symdef()' in the output format. This function
+     * is called after the output format version.
+     */
+
+    void (*debug_deflabel)(char *name, int32_t segment, int64_t offset,
+                           int is_global, char *special);
+
+    /*
+     * debug_smacros - called when an smacro is defined or undefined
+     * during the code-generation pass. The definition string contains
+     * the macro name, any arguments, a single space, and the macro
+     * definition; this is what is expected by e.g. DWARF.
+     *
+     * The definition is provided even for an undef.
+     */
+    void (*debug_smacros)(bool define, const char *def);
+
+    /*
+     * debug_include - called when a file is included or the include
+     * is finished during the code-generation pass.  The filename is
+     * kept by the srcfile system and so can be compared for pointer
+     * equality.
+     *
+     * A filename of NULL means builtin (initial or %use) or command
+     * line statements.
+     */
+    void (*debug_include)(bool start, struct src_location outer,
+                          struct src_location inner);
+
+    /*
+     * debug_mmacros - called once at the end with a definition for each
+     * non-.nolist macro that has been invoked at least once in the program,
+     * and the corresponding address ranges. See dbginfo.h.
+     */
+    void (*debug_mmacros)(const struct debug_macro_info *);
+
+    /*
+     * debug_directive - called whenever a DEBUG directive other than 'LINE'
+     * is encountered. 'directive' contains the first parameter to the
+     * DEBUG directive, and params contains the rest. For example,
+     * 'DEBUG VAR _somevar:int' would translate to a call to this
+     * function with 'directive' equal to "VAR" and 'params' equal to
+     * "_somevar:int".
+     */
+    void (*debug_directive)(const char *directive, const char *params);
+
+    /*
+     * typevalue - called whenever the assembler wishes to register a type
+     * for the last defined label.  This routine MUST detect if a type was
+     * already registered and not re-register it.
+     */
+    void (*debug_typevalue)(int32_t type);
+
+    /*
+     * debug_output - called whenever output is required
+     * 'type' is the type of info required, and this is format-specific
+     */
+    void (*debug_output)(int type, void *param);
+
+    /*
+     * cleanup - called after processing of file is complete
+     */
+    void (*cleanup)(void);
+
+    /*
+     * List of pragma facility names that apply to this backend.
+     */
+    const struct pragma_facility *pragmas;
+};
+
+extern const struct dfmt *dfmt;
+
+/*
+ * The type definition macros
+ * for debugging
+ *
+ * low 3 bits: reserved
+ * next 5 bits: type
+ * next 24 bits: number of elements for arrays (0 for labels)
+ */
+
+#define TY_UNKNOWN 0x00
+#define TY_LABEL   0x08
+#define TY_BYTE    0x10
+#define TY_WORD    0x18
+#define TY_DWORD   0x20
+#define TY_FLOAT   0x28
+#define TY_QWORD   0x30
+#define TY_TBYTE   0x38
+#define TY_OWORD   0x40
+#define TY_YWORD   0x48
+#define TY_ZWORD   0x50
+#define TY_COMMON  0xE0
+#define TY_SEG     0xE8
+#define TY_EXTERN  0xF0
+#define TY_EQU     0xF8
+
+#define TYM_TYPE(x)     ((x) & 0xF8)
+#define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
+
+#define TYS_ELEMENTS(x) ((x) << 8)
+
+/* Sizes corresponding to various tokens */
+enum byte_sizes {
+    SIZE_BYTE	=  1,
+    SIZE_WORD	=  2,
+    SIZE_DWORD	=  4,
+    SIZE_QWORD	=  8,
+    SIZE_TWORD  = 10,
+    SIZE_OWORD  = 16,
+    SIZE_YWORD  = 32,
+    SIZE_ZWORD  = 64
+};
+
+enum special_tokens {
+    SIZE_ENUM_START     = PREFIX_ENUM_LIMIT,
+    S_BYTE              = SIZE_ENUM_START,
+    S_WORD,
+    S_DWORD,
+    S_QWORD,
+    S_TWORD,
+    S_OWORD,
+    S_YWORD,
+    S_ZWORD,
+    SIZE_ENUM_LIMIT,
+
+    SPECIAL_ENUM_START  = SIZE_ENUM_LIMIT,
+    S_ABS		= SPECIAL_ENUM_START,
+    S_FAR,
+    S_LONG,
+    S_NEAR,
+    S_NOSPLIT,
+    S_REL,
+    S_SHORT,
+    S_STRICT,
+    S_TO,
+    SPECIAL_ENUM_LIMIT
+};
+
+enum decorator_tokens {
+    DECORATOR_ENUM_START    = SPECIAL_ENUM_LIMIT,
+    BRC_1TO2                = DECORATOR_ENUM_START,
+    BRC_1TO4,
+    BRC_1TO8,
+    BRC_1TO16,
+    BRC_1TO32,
+    BRC_RN,
+    BRC_RD,
+    BRC_RU,
+    BRC_RZ,
+    BRC_SAE,
+    BRC_Z,
+    DECORATOR_ENUM_LIMIT
+};
+
+/*
+ * AVX512 Decorator (decoflags_t) bits distribution (counted from 0)
+ *  3         2         1
+ * 10987654321098765432109876543210
+ *                |
+ *                | word boundary
+ * ............................1111 opmask
+ * ...........................1.... zeroing / merging
+ * ..........................1..... broadcast
+ * .........................1...... static rounding
+ * ........................1....... SAE
+ * ....................1111........ broadcast element size
+ * .................111............ number of broadcast elements
+ */
+#define OP_GENVAL(val, bits, shift)     (((val) & ((UINT64_C(1) << (bits)) - 1)) << (shift))
+
+/*
+ * Opmask register number
+ * identical to EVEX.aaa
+ *
+ * Bits: 0 - 3
+ */
+#define OPMASK_SHIFT            (0)
+#define OPMASK_BITS             (4)
+#define OPMASK_MASK             OP_GENMASK(OPMASK_BITS, OPMASK_SHIFT)
+#define GEN_OPMASK(bit)         OP_GENBIT(bit, OPMASK_SHIFT)
+#define VAL_OPMASK(val)         OP_GENVAL(val, OPMASK_BITS, OPMASK_SHIFT)
+
+/*
+ * zeroing / merging control available
+ * matching to EVEX.z
+ *
+ * Bits: 4
+ */
+#define Z_SHIFT                 (4)
+#define Z_BITS                  (1)
+#define Z_MASK                  OP_GENMASK(Z_BITS, Z_SHIFT)
+#define GEN_Z(bit)              OP_GENBIT(bit, Z_SHIFT)
+
+/*
+ * broadcast - Whether this operand can be broadcasted
+ *
+ * Bits: 5
+ */
+#define BRDCAST_SHIFT           (5)
+#define BRDCAST_BITS            (1)
+#define BRDCAST_MASK            OP_GENMASK(BRDCAST_BITS, BRDCAST_SHIFT)
+#define GEN_BRDCAST(bit)        OP_GENBIT(bit, BRDCAST_SHIFT)
+
+/*
+ * Whether this instruction can have a static rounding mode.
+ * It goes with the last simd operand because the static rounding mode
+ * decorator is located between the last simd operand and imm8 (if any).
+ *
+ * Bits: 6
+ */
+#define STATICRND_SHIFT         (6)
+#define STATICRND_BITS          (1)
+#define STATICRND_MASK          OP_GENMASK(STATICRND_BITS, STATICRND_SHIFT)
+#define GEN_STATICRND(bit)      OP_GENBIT(bit, STATICRND_SHIFT)
+
+/*
+ * SAE(Suppress all exception) available
+ *
+ * Bits: 7
+ */
+#define SAE_SHIFT               (7)
+#define SAE_BITS                (1)
+#define SAE_MASK                OP_GENMASK(SAE_BITS, SAE_SHIFT)
+#define GEN_SAE(bit)            OP_GENBIT(bit, SAE_SHIFT)
+
+/*
+ * Broadcasting element size.
+ *
+ * Bits: 8 - 11
+ */
+#define BRSIZE_SHIFT            (8)
+#define BRSIZE_BITS             (4)
+#define BRSIZE_MASK             OP_GENMASK(BRSIZE_BITS, BRSIZE_SHIFT)
+#define GEN_BRSIZE(bit)         OP_GENBIT(bit, BRSIZE_SHIFT)
+
+#define BR_BITS8		GEN_BRSIZE(0) /* For potential future use */
+#define BR_BITS16               GEN_BRSIZE(1)
+#define BR_BITS32               GEN_BRSIZE(2)
+#define BR_BITS64               GEN_BRSIZE(3)
+
+/*
+ * Number of broadcasting elements
+ *
+ * Bits: 12 - 14
+ */
+#define BRNUM_SHIFT             (12)
+#define BRNUM_BITS              (3)
+#define BRNUM_MASK              OP_GENMASK(BRNUM_BITS, BRNUM_SHIFT)
+#define VAL_BRNUM(val)          OP_GENVAL(val, BRNUM_BITS, BRNUM_SHIFT)
+
+#define BR_1TO2                 VAL_BRNUM(0)
+#define BR_1TO4                 VAL_BRNUM(1)
+#define BR_1TO8                 VAL_BRNUM(2)
+#define BR_1TO16                VAL_BRNUM(3)
+#define BR_1TO32                VAL_BRNUM(4)
+#define BR_1TO64                VAL_BRNUM(5) /* For potential future use */
+
+#define MASK                    OPMASK_MASK             /* Opmask (k1 ~ 7) can be used */
+#define Z                       Z_MASK
+#define B16                     (BRDCAST_MASK|BR_BITS16) /* {1to32} : broadcast 16b * 32 to zmm(512b) */
+#define B32                     (BRDCAST_MASK|BR_BITS32) /* {1to16} : broadcast 32b * 16 to zmm(512b) */
+#define B64                     (BRDCAST_MASK|BR_BITS64) /* {1to8}  : broadcast 64b *  8 to zmm(512b) */
+#define ER                      STATICRND_MASK          /* ER(Embedded Rounding) == Static rounding mode */
+#define SAE                     SAE_MASK                /* SAE(Suppress All Exception) */
+
+/*
+ * Broadcast flags (BR_BITS*) to sizes (BITS*)
+ */
+static inline opflags_t brsize_to_size(opflags_t brbits)
+{
+    return (brbits & BRSIZE_MASK) << (SIZE_SHIFT - BRSIZE_SHIFT);
+}
+
+/*
+ * Global modes
+ */
+
+/*
+ * flag to disable optimizations selectively
+ * this is useful to turn-off certain optimizations
+ */
+enum optimization_disable_flag {
+    OPTIM_ALL_ENABLED       = 0,
+    OPTIM_DISABLE_JMP_MATCH = 1
+};
+
+struct optimization {
+    int level;
+    int flag;
+};
+
+/*
+ * Various types of compiler passes we may execute.
+ * If these are changed, you need to also change _pass_types[]
+ * in asm/nasm.c.
+ */
+enum pass_type {
+    PASS_INIT,            /* Initialization, not doing anything yet */
+    PASS_PREPROC,         /* Preprocess-only mode (similar to PASS_FIRST) */
+    PASS_FIRST,           /* The very first pass over the code */
+    PASS_OPT,             /* Optimization pass */
+    PASS_STAB,            /* Stabilization pass (original pass 1) */
+    PASS_FINAL            /* Code generation pass (original pass 2) */
+};
+extern const char * const _pass_types[];
+extern enum pass_type _pass_type;
+static inline enum pass_type pass_type(void)
+{
+    return _pass_type;
+}
+static inline const char *pass_type_name(void)
+{
+    return _pass_types[_pass_type];
+}
+/* True during initialization, no code read yet */
+static inline bool not_started(void)
+{
+    return pass_type() == PASS_INIT;
+}
+/* True for the initial pass and setup (old "pass2 < 2") */
+static inline bool pass_first(void)
+{
+    return pass_type() <= PASS_FIRST;
+}
+/* At this point we better have stable definitions */
+static inline bool pass_stable(void)
+{
+    return pass_type() >= PASS_STAB;
+}
+/* True for the code generation pass only, (old "pass1 >= 2") */
+static inline bool pass_final(void)
+{
+    return pass_type() >= PASS_FINAL;
+}
+/* True for code generation *or* preprocess-only mode */
+static inline bool pass_final_or_preproc(void)
+{
+    return pass_type() >= PASS_FINAL || pass_type() == PASS_PREPROC;
+}
+
+/*
+ * The actual pass number. 0 is used during initialization, the very
+ * first pass is 1, and then it is simply increasing numbers until we are
+ * done.
+ */
+extern int64_t _passn;           /* Actual pass number */
+static inline int64_t pass_count(void)
+{
+    return _passn;
+}
+
+extern struct optimization optimizing;
+extern int globalbits;          /* 16, 32 or 64-bit mode */
+extern int globalrel;           /* default to relative addressing? */
+extern int globalbnd;           /* default to using bnd prefix? */
+
+extern const char *inname;	/* primary input filename */
+extern const char *outname;     /* output filename */
+
+/*
+ * Switch to a different segment and return the current offset
+ */
+int64_t switch_segment(int32_t segment);
+
+#endif  /* NASM_NASM_H */
diff --git a/vere/ext/nasm/include/nasmint.h b/vere/ext/nasm/include/nasmint.h
new file mode 100644
index 0000000..6be623b
--- /dev/null
+++ b/vere/ext/nasm/include/nasmint.h
@@ -0,0 +1,219 @@
+/*
+ * nasmint.h
+ *
+ * Small ersatz subset of <inttypes.h>, deriving the types from
+ * <limits.h>.
+ *
+ * Important: the preprocessor may truncate numbers too large for it.
+ * Therefore, test the signed types only ... truncation won't generate
+ * a 01111111... bit pattern.
+ */
+
+#ifndef NASM_NASMINT_H
+#define NASM_NASMINT_H
+
+#include <limits.h>
+
+/*** 64-bit type: __int64, long or long long ***/
+
+/* Some old versions of gcc <limits.h> omit LLONG_MAX */
+#ifndef LLONG_MAX
+# ifdef __LONG_LONG_MAX__
+#  define LLONG_MAX __LONG_LONG_MAX__
+# else
+#  define LLONG_MAX 0		/* Assume long long is unusable */
+# endif
+#endif
+
+#ifndef _I64_MAX
+# ifdef _MSC_VER
+#  define _I64_MAX 9223372036854775807
+# else
+#  define _I64_MAX 0
+# endif
+#endif
+
+#if _I64_MAX == 9223372036854775807
+
+/* Windows-based compiler: use __int64 */
+typedef signed __int64		int64_t;
+typedef unsigned __int64	uint64_t;
+#define _scn64			"I64"
+#define _pri64			"I64"
+#define INT64_C(x)		x ## i64
+#define UINT64_C(x)		x ## ui64
+
+#elif LONG_MAX == 9223372036854775807L
+
+/* long is 64 bits */
+typedef signed long		int64_t;
+typedef unsigned long		uint64_t;
+#define _scn64			"l"
+#define _pri64			"l"
+#define INT64_C(x)		x ## L
+#define UINT64_C(x)		x ## UL
+
+#elif LLONG_MAX == 9223372036854775807LL
+
+/* long long is 64 bits */
+typedef signed long long	int64_t;
+typedef unsigned long long	uint64_t;
+#define _scn64			"ll"
+#define _pri64			"ll"
+#define INT64_C(x)		x ## LL
+#define UINT64_C(x)		x ## ULL
+
+#else
+
+#error "Neither long nor long long is 64 bits in size"
+
+#endif
+
+/*** 32-bit type: int or long ***/
+
+#if INT_MAX == 2147483647
+
+/* int is 32 bits */
+typedef signed int		int32_t;
+typedef unsigned int		uint32_t;
+#define _scn32			""
+#define _pri32			""
+#define INT32_C(x)		x
+#define UINT32_C(x)		x ## U
+
+#elif LONG_MAX == 2147483647L
+
+/* long is 32 bits */
+typedef signed long		int32_t;
+typedef unsigned long		uint32_t;
+#define _scn32			"l"
+#define _pri32			"l"
+#define INT32_C(x)		x ## L
+#define UINT32_C(x)		x ## UL
+
+#else
+
+#error "Neither int nor long is 32 bits in size"
+
+#endif
+
+/*** 16-bit size: int or short ***/
+
+#if INT_MAX == 32767
+
+/* int is 16 bits */
+typedef signed int		int16_t;
+typedef unsigned int		uint16_t;
+#define _scn16			""
+#define _pri16			""
+#define INT16_C(x)		x
+#define UINT16_C(x)		x ## U
+
+#elif SHRT_MAX == 32767
+
+/* short is 16 bits */
+typedef signed short		int16_t;
+typedef unsigned short		uint16_t;
+#define _scn16			"h"
+#define _pri16			""
+#define INT16_C(x)		x
+#define UINT16_C(x)		x ## U
+
+#else
+
+#error "Neither short nor int is 16 bits in size"
+
+#endif
+
+/*** 8-bit size: char ***/
+
+#if SCHAR_MAX == 127
+
+/* char is 8 bits */
+typedef signed char		int8_t;
+typedef unsigned char		uint8_t;
+#define _scn8			"hh"
+#define _pri8			""
+#define INT8_C(x)		x
+#define UINT8_C(x)		x ## U
+
+#else
+
+#error "char is not 8 bits in size"
+
+#endif
+
+/* The rest of this is common to all models */
+
+#define PRId8		_pri8  "d"
+#define PRId16		_pri16 "d"
+#define PRId32		_pri32 "d"
+#define PRId64		_pri64 "d"
+
+#define PRIi8		_pri8  "i"
+#define PRIi16		_pri16 "i"
+#define PRIi32		_pri32 "i"
+#define PRIi64		_pri64 "i"
+
+#define PRIo8		_pri8  "o"
+#define PRIo16		_pri16 "o"
+#define PRIo32		_pri32 "o"
+#define PRIo64		_pri64 "o"
+
+#define PRIu8		_pri8  "u"
+#define PRIu16		_pri16 "u"
+#define PRIu32		_pri32 "u"
+#define PRIu64		_pri64 "u"
+
+#define PRIx8		_pri8  "x"
+#define PRIx16		_pri16 "x"
+#define PRIx32		_pri32 "x"
+#define PRIx64		_pri64 "x"
+
+#define PRIX8		_pri8  "X"
+#define PRIX16		_pri16 "X"
+#define PRIX32		_pri32 "X"
+#define PRIX64		_pri64 "X"
+
+#define SCNd8		_scn8  "d"
+#define SCNd16		_scn16 "d"
+#define SCNd32		_scn32 "d"
+#define SCNd64		_scn64 "d"
+
+#define SCNi8		_scn8  "i"
+#define SCNi16		_scn16 "i"
+#define SCNi32		_scn32 "i"
+#define SCNi64		_scn64 "i"
+
+#define SCNo8		_scn8  "o"
+#define SCNo16		_scn16 "o"
+#define SCNo32		_scn32 "o"
+#define SCNo64		_scn64 "o"
+
+#define SCNu8		_scn8  "u"
+#define SCNu16		_scn16 "u"
+#define SCNu32		_scn32 "u"
+#define SCNu64		_scn64 "u"
+
+#define SCNx8		_scn8  "x"
+#define SCNx16		_scn16 "x"
+#define SCNx32		_scn32 "x"
+#define SCNx64		_scn64 "x"
+
+#define INT8_MIN	INT8_C(-128)
+#define INT8_MAX	INT8_C(127)
+#define UINT8_MAX	UINT8_C(255)
+
+#define INT16_MIN	INT16_C(-32768)
+#define INT16_MAX	INT16_C(32767)
+#define UINT16_MAX	UINT16_C(65535)
+
+#define INT32_MIN	INT32_C(-2147483648)
+#define INT32_MAX	INT32_C(2147483647)
+#define UINT32_MAX	UINT32_C(4294967295)
+
+#define INT64_MIN	INT64_C(-9223372036854775808)
+#define INT64_MAX	INT64_C(9223372036854775807)
+#define UINT64_MAX	UINT64_C(18446744073709551615)
+
+#endif /* NASM_NASMINT_H */
diff --git a/vere/ext/nasm/include/nasmlib.h b/vere/ext/nasm/include/nasmlib.h
new file mode 100644
index 0000000..87a7fc6
--- /dev/null
+++ b/vere/ext/nasm/include/nasmlib.h
@@ -0,0 +1,467 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.h    header file for nasmlib.c
+ */
+
+#ifndef NASM_NASMLIB_H
+#define NASM_NASMLIB_H
+
+#include "compiler.h"
+#include "bytesex.h"
+
+/*
+ * Useful construct for private values
+ */
+union intorptr {
+    int64_t i;
+    uint64_t u;
+    size_t s;
+    void *p;
+    const void *cp;
+    uintptr_t up;
+};
+typedef union intorptr intorptr;
+
+/*
+ * Wrappers around malloc, realloc, free and a few more. nasm_malloc
+ * will fatal-error and die rather than return NULL; nasm_realloc will
+ * do likewise, and will also guarantee to work right on being passed
+ * a NULL pointer; nasm_free will do nothing if it is passed a NULL
+ * pointer.
+ */
+void * safe_malloc(1) nasm_malloc(size_t);
+void * safe_malloc(1) nasm_zalloc(size_t);
+void * safe_malloc2(1,2) nasm_calloc(size_t, size_t);
+void * safe_realloc(2) nasm_realloc(void *, size_t);
+void nasm_free(void *);
+char * safe_alloc nasm_strdup(const char *);
+char * safe_alloc nasm_strndup(const char *, size_t);
+char * safe_alloc nasm_strcat(const char *one, const char *two);
+char * safe_alloc end_with_null nasm_strcatn(const char *one, ...);
+
+/*
+ * nasm_[v]asprintf() are variants of the semi-standard [v]asprintf()
+ * functions, except that we return the pointer instead of a count.
+ * The size of the string (including the final NUL!) is available
+ * by calling nasm_aprintf_size() afterwards.
+ *
+ * nasm_[v]axprintf() are similar, but allocates a user-defined amount
+ * of storage before the string, and returns a pointer to the
+ * allocated buffer. The value of nasm_aprintf_size() does *not* include
+ * this additional storage.
+ */
+char * safe_alloc printf_func(1, 2) nasm_asprintf(const char *fmt, ...);
+char * safe_alloc vprintf_func(1) nasm_vasprintf(const char *fmt, va_list ap);
+void * safe_alloc printf_func(2, 3) nasm_axprintf(size_t extra, const char *fmt, ...);
+void * safe_alloc vprintf_func(2) nasm_vaxprintf(size_t extra, const char *fmt, va_list ap);
+
+/*
+ * nasm_last_string_len() returns the length of the last string allocated
+ * by [v]asprintf, nasm_strdup, nasm_strcat, or nasm_strcatn.
+ *
+ * nasm_last_string_size() returns the equivalent size including the
+ * final NUL.
+ */
+static inline size_t nasm_last_string_len(void)
+{
+    extern size_t _nasm_last_string_size;
+    return _nasm_last_string_size - 1;
+}
+static inline size_t nasm_last_string_size(void)
+{
+    extern size_t _nasm_last_string_size;
+    return _nasm_last_string_size;
+}
+
+/* Assert the argument is a pointer without evaluating it */
+#define nasm_assert_pointer(p) ((void)sizeof(*(p)))
+
+#define nasm_new(p) ((p) = nasm_zalloc(sizeof(*(p))))
+#define nasm_newn(p,n) ((p) = nasm_calloc((n), sizeof(*(p))))
+/*
+ * This is broken on platforms where there are pointers which don't
+ * match void * in their internal layout.  It unfortunately also
+ * loses any "const" part of the argument, although hopefully the
+ * compiler will warn in that case.
+ */
+#define nasm_delete(p)                          \
+    do {                                        \
+        void **_pp = (void **)&(p);             \
+        nasm_assert_pointer(p);                 \
+        nasm_free(*_pp);                        \
+        *_pp = NULL;                            \
+    } while (0)
+#define nasm_zero(x) (memset(&(x), 0, sizeof(x)))
+#define nasm_zeron(p,n) (memset((p), 0, (n)*sizeof(*(p))))
+
+/*
+ * Wrappers around fread()/fwrite() which fatal-errors on failure.
+ * For fread(), only use this if EOF is supposed to be a fatal error!
+ */
+void nasm_read(void *, size_t, FILE *);
+void nasm_write(const void *, size_t, FILE *);
+
+/*
+ * NASM failure at build time if the argument is false
+ */
+#ifdef static_assert
+# define nasm_static_assert(x) static_assert((x), #x)
+#elif defined(HAVE_FUNC_ATTRIBUTE_ERROR) && defined(__OPTIMIZE__)
+# define nasm_static_assert(x)                                              \
+    do {                                                                    \
+        if (!(x)) {                                                         \
+            extern void __attribute__((error("assertion " #x " failed")))   \
+                _nasm_static_fail(void);                                    \
+            _nasm_static_fail();                                            \
+        }                                                                   \
+    } while (0)
+#else
+/* See http://www.drdobbs.com/compile-time-assertions/184401873 */
+# define nasm_static_assert(x)                                              \
+    do { enum { _static_assert_failed = 1/(!!(x)) }; } while (0)
+#endif
+
+/*
+ * conditional static assert, if we know it is possible to determine
+ * the assert value at compile time. Since if_constant triggers
+ * pedantic warnings on gcc, turn them off explicitly around this code.
+ */
+#ifdef static_assert
+# define nasm_try_static_assert(x)                                          \
+    do {                                                                    \
+        not_pedantic_start                                                  \
+        static_assert(if_constant(x, true), #x);                            \
+        not_pedantic_end                                                    \
+    } while (0)
+#elif defined(HAVE_FUNC_ATTRIBUTE_ERROR) && defined(__OPTIMIZE__)
+# define nasm_try_static_assert(x)                                          \
+    do {                                                                    \
+        if (!if_constant(x, true)) {                                        \
+            extern void __attribute__((error("assertion " #x " failed")))   \
+                _nasm_static_fail(void);                                    \
+            _nasm_static_fail();                                            \
+        }                                                                   \
+    } while (0)
+#else
+# define nasm_try_static_assert(x) ((void)0)
+#endif
+
+/*
+ * NASM assert failure
+ */
+fatal_func nasm_assert_failed(const char *, int, const char *);
+#define nasm_assert(x)                                          \
+    do {                                                        \
+        nasm_try_static_assert(x);                              \
+        if (unlikely(!(x)))                                     \
+            nasm_assert_failed(__FILE__,__LINE__,#x);           \
+    } while (0)
+
+/* Utility function to generate a string for an invalid enum */
+const char *invalid_enum_str(int);
+
+/*
+ * ANSI doesn't guarantee the presence of `stricmp' or
+ * `strcasecmp'.
+ */
+#if defined(HAVE_STRCASECMP)
+#define nasm_stricmp strcasecmp
+#elif defined(HAVE_STRICMP)
+#define nasm_stricmp stricmp
+#else
+int pure_func nasm_stricmp(const char *, const char *);
+#endif
+
+#if defined(HAVE_STRNCASECMP)
+#define nasm_strnicmp strncasecmp
+#elif defined(HAVE_STRNICMP)
+#define nasm_strnicmp strnicmp
+#else
+int pure_func nasm_strnicmp(const char *, const char *, size_t);
+#endif
+
+int pure_func nasm_memicmp(const char *, const char *, size_t);
+
+#if defined(HAVE_STRSEP)
+#define nasm_strsep strsep
+#else
+char *nasm_strsep(char **stringp, const char *delim);
+#endif
+
+#ifndef HAVE_DECL_STRNLEN
+size_t pure_func strnlen(const char *, size_t);
+#endif
+
+/* This returns the numeric value of a given 'digit'; no check for validity */
+static inline unsigned int numvalue(unsigned char c)
+{
+    c |= 0x20;
+    return c >= 'a' ? c - 'a' + 10 : c - '0';
+}
+
+/*
+ * Convert a string into a number, using NASM number rules. Sets
+ * `*error' to true if an error occurs, and false otherwise.
+ */
+int64_t readnum(const char *str, bool *error);
+
+/*
+ * Convert a character constant into a number. Sets
+ * `*warn' to true if an overflow occurs, and false otherwise.
+ * str points to and length covers the middle of the string,
+ * without the quotes.
+ */
+int64_t readstrnum(char *str, int length, bool *warn);
+
+/*
+ * seg_alloc: allocate a hitherto unused segment number.
+ */
+int32_t seg_alloc(void);
+
+/*
+ * Add/replace or remove an extension to the end of a filename
+ */
+const char *filename_set_extension(const char *inname, const char *extension);
+
+/*
+ * Utility macros...
+ *
+ * This is a useful #define which I keep meaning to use more often:
+ * the number of elements of a statically defined array.
+ */
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+/*
+ * List handling
+ *
+ *  list_for_each - regular iterator over list
+ *  list_for_each_safe - the same but safe against list items removal
+ *  list_last - find the last element in a list
+ *  list_reverse - reverse the order of a list
+ *
+ *  Arguments named with _ + single letter should be temp variables
+ *  of the appropriate pointer type.
+ */
+#define list_for_each(pos, head)                        \
+    for (pos = head; pos; pos = pos->next)
+#define list_for_each_safe(pos, _n, head)                \
+    for (pos = head, _n = (pos ? pos->next : NULL); pos; \
+        pos = _n, _n = (_n ? _n->next : NULL))
+#define list_last(pos, head)                            \
+    for (pos = head; pos && pos->next; pos = pos->next) \
+        ;
+#define list_reverse(head)                              \
+    do {                                                \
+        void *_p, *_n;                                  \
+        if (!head || !head->next)                       \
+            break;                                      \
+        _p = NULL;                                      \
+        while (head) {                                  \
+            _n = head->next;                            \
+            head->next = _p;                            \
+            _p = head;                                  \
+            head = _n;                                  \
+        }                                               \
+        head = _p;                                      \
+    } while (0)
+
+/*
+ * Power of 2 align helpers
+ */
+#undef ALIGN_MASK               /* Some BSD flavors define these in system headers */
+#undef ALIGN
+#define ALIGN_MASK(v, mask)     (((v) + (mask)) & ~(mask))
+#define ALIGN(v, a)             ALIGN_MASK(v, (a) - 1)
+#define IS_ALIGNED(v, a)        (((v) & ((a) - 1)) == 0)
+
+/*
+ * Routines to write littleendian data to a file
+ */
+#define fwriteint8_t(d,f) putc(d,f)
+void fwriteint16_t(uint16_t data, FILE * fp);
+void fwriteint32_t(uint32_t data, FILE * fp);
+void fwriteint64_t(uint64_t data, FILE * fp);
+void fwriteaddr(uint64_t data, int size, FILE * fp);
+
+/*
+ * Binary search routine. Returns index into `array' of an entry
+ * matching `string', or <0 if no match. `array' is taken to
+ * contain `size' elements.
+ *
+ * bsi() is case sensitive, bsii() is case insensitive.
+ */
+int bsi(const char *string, const char **array, int size);
+int bsii(const char *string, const char **array, int size);
+
+/*
+ * Convenient string processing helper routines
+ */
+char *nasm_skip_spaces(const char *p);
+char *nasm_skip_word(const char *p);
+char *nasm_zap_spaces_fwd(char *p);
+char *nasm_zap_spaces_rev(char *p);
+char *nasm_trim_spaces(char *p);
+char *nasm_get_word(char *p, char **tail);
+char *nasm_opt_val(char *p, char **opt, char **val);
+
+/*
+ * Converts a relative pathname rel_path into an absolute path name.
+ *
+ * The buffer returned must be freed by the caller
+ */
+char * safe_alloc nasm_realpath(const char *rel_path);
+
+/*
+ * Path-splitting and merging functions
+ */
+char * safe_alloc nasm_dirname(const char *path);
+char * safe_alloc nasm_basename(const char *path);
+char * safe_alloc nasm_catfile(const char *dir, const char *path);
+
+const char * pure_func prefix_name(int);
+
+/*
+ * Wrappers around fopen()... for future change to a dedicated structure
+ */
+enum file_flags {
+    NF_BINARY   = 0x00000000,   /* Binary file (default) */
+    NF_TEXT     = 0x00000001,   /* Text file */
+    NF_NONFATAL = 0x00000000,   /* Don't die on open failure (default) */
+    NF_FATAL    = 0x00000002,   /* Die on open failure */
+    NF_FORMAP   = 0x00000004,   /* Intended to use nasm_map_file() */
+    NF_IONBF    = 0x00000010,   /* Force unbuffered stdio */
+    NF_IOLBF    = 0x00000020,   /* Force line buffered stdio */
+    NF_IOFBF    = 0000000030    /* Force fully buffered stdio */
+};
+#define NF_BUF_MASK  0x30
+
+FILE *nasm_open_read(const char *filename, enum file_flags flags);
+FILE *nasm_open_write(const char *filename, enum file_flags flags);
+
+void nasm_set_binary_mode(FILE *f);
+
+/* Probe for existence of a file */
+bool nasm_file_exists(const char *filename);
+
+#define ZERO_BUF_SIZE 65536     /* Default value */
+#if defined(BUFSIZ) && (BUFSIZ > ZERO_BUF_SIZE)
+# undef ZERO_BUF_SIZE
+# define ZERO_BUF_SIZE BUFSIZ
+#endif
+extern const uint8_t zero_buffer[ZERO_BUF_SIZE];
+
+/* Missing fseeko/ftello */
+#ifndef HAVE_FSEEKO
+# undef off_t                   /* Just in case it is a macro */
+# ifdef HAVE__FSEEKI64
+#  define fseeko _fseeki64
+#  define ftello _ftelli64
+#  define off_t  int64_t
+# else
+#  define fseeko fseek
+#  define ftello ftell
+#  define off_t  long
+# endif
+#endif
+
+const void *nasm_map_file(FILE *fp, off_t start, off_t len);
+void nasm_unmap_file(const void *p, size_t len);
+off_t nasm_file_size(FILE *f);
+off_t nasm_file_size_by_path(const char *pathname);
+bool nasm_file_time(time_t *t, const char *pathname);
+void fwritezero(off_t bytes, FILE *fp);
+
+static inline bool const_func overflow_general(int64_t value, int bytes)
+{
+    int sbit;
+    int64_t vmax, vmin;
+
+    if (bytes >= 8)
+        return false;
+
+    sbit = (bytes << 3) - 1;
+    vmax =  ((int64_t)2 << sbit) - 1;
+    vmin = -((int64_t)2 << sbit);
+
+    return value < vmin || value > vmax;
+}
+
+static inline bool const_func overflow_signed(int64_t value, int bytes)
+{
+    int sbit;
+    int64_t vmax, vmin;
+
+    if (bytes >= 8)
+        return false;
+
+    sbit = (bytes << 3) - 1;
+    vmax =  ((int64_t)1 << sbit) - 1;
+    vmin = -((int64_t)1 << sbit);
+
+    return value < vmin || value > vmax;
+}
+
+static inline bool const_func overflow_unsigned(int64_t value, int bytes)
+{
+    int sbit;
+    int64_t vmax, vmin;
+
+    if (bytes >= 8)
+        return false;
+
+    sbit = (bytes << 3) - 1;
+    vmax = ((int64_t)2 << sbit) - 1;
+    vmin = 0;
+
+    return value < vmin || value > vmax;
+}
+
+static inline int64_t const_func signed_bits(int64_t value, int bits)
+{
+    if (bits < 64) {
+        value &= ((int64_t)1 << bits) - 1;
+        if (value & (int64_t)1 << (bits - 1))
+            value |= (int64_t)((uint64_t)-1 << bits);
+    }
+    return value;
+}
+
+/* check if value is power of 2 */
+#define is_power2(v)   ((v) && ((v) & ((v) - 1)) == 0)
+
+/* try to get the system stack size */
+extern size_t nasm_get_stack_size_limit(void);
+
+#endif
diff --git a/vere/ext/nasm/include/nctype.h b/vere/ext/nasm/include/nctype.h
new file mode 100644
index 0000000..ba594b9
--- /dev/null
+++ b/vere/ext/nasm/include/nctype.h
@@ -0,0 +1,127 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * ctype-like functions specific to NASM
+ */
+#ifndef NASM_NCTYPE_H
+#define NASM_NCTYPE_H
+
+#include "compiler.h"
+
+void nasm_ctype_init(void);
+
+extern unsigned char nasm_tolower_tab[256];
+static inline char nasm_tolower(char x)
+{
+    return nasm_tolower_tab[(unsigned char)x];
+}
+
+/*
+ * NASM ctype table
+ */
+enum nasm_ctype {
+    NCT_CTRL       = 0x0001,
+    NCT_SPACE      = 0x0002,
+    NCT_ASCII      = 0x0004,
+    NCT_LOWER      = 0x0008,    /* isalpha(x) && tolower(x) == x */
+    NCT_UPPER      = 0x0010,    /* isalpha(x) && tolower(x) != x */
+    NCT_DIGIT      = 0x0020,
+    NCT_HEX        = 0x0040,
+    NCT_ID         = 0x0080,
+    NCT_IDSTART    = 0x0100,
+    NCT_MINUS      = 0x0200,    /* - */
+    NCT_DOLLAR     = 0x0400,    /* $ */
+    NCT_UNDER      = 0x0800,    /* _ */
+    NCT_QUOTE      = 0x1000     /* " ' ` */
+};
+
+extern uint16_t nasm_ctype_tab[256];
+static inline bool nasm_ctype(unsigned char x, enum nasm_ctype mask)
+{
+    return (nasm_ctype_tab[x] & mask) != 0;
+}
+
+static inline bool nasm_isspace(char x)
+{
+    return nasm_ctype(x, NCT_SPACE);
+}
+
+static inline bool nasm_isalpha(char x)
+{
+    return nasm_ctype(x, NCT_LOWER|NCT_UPPER);
+}
+
+static inline bool nasm_isdigit(char x)
+{
+    return nasm_ctype(x, NCT_DIGIT);
+}
+static inline bool nasm_isalnum(char x)
+{
+    return nasm_ctype(x, NCT_LOWER|NCT_UPPER|NCT_DIGIT);
+}
+static inline bool nasm_isxdigit(char x)
+{
+    return nasm_ctype(x, NCT_HEX);
+}
+static inline bool nasm_isidstart(char x)
+{
+    return nasm_ctype(x, NCT_IDSTART);
+}
+static inline bool nasm_isidchar(char x)
+{
+    return nasm_ctype(x, NCT_ID);
+}
+static inline bool nasm_isbrcchar(char x)
+{
+    return nasm_ctype(x, NCT_ID|NCT_MINUS);
+}
+static inline bool nasm_isnumstart(char x)
+{
+    return nasm_ctype(x, NCT_DIGIT|NCT_DOLLAR);
+}
+static inline bool nasm_isnumchar(char x)
+{
+    return nasm_ctype(x, NCT_DIGIT|NCT_LOWER|NCT_UPPER|NCT_UNDER);
+}
+static inline bool nasm_isquote(char x)
+{
+    return nasm_ctype(x, NCT_QUOTE);
+}
+
+static inline void nasm_ctype_tasm_mode(void)
+{
+    /* No differences at the present moment */
+}
+
+#endif /* NASM_NCTYPE_H */
diff --git a/vere/ext/nasm/include/opflags.h b/vere/ext/nasm/include/opflags.h
new file mode 100644
index 0000000..179b1e0
--- /dev/null
+++ b/vere/ext/nasm/include/opflags.h
@@ -0,0 +1,301 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * opflags.h - operand flags
+ */
+
+#ifndef NASM_OPFLAGS_H
+#define NASM_OPFLAGS_H
+
+#include "compiler.h"
+#include "tables.h"     /* for opflags_t and nasm_reg_flags[] */
+#include "regs.h"
+
+/*
+ * Here we define the operand types. These are implemented as bit
+ * masks, since some are subsets of others; e.g. AX in a MOV
+ * instruction is a special operand type, whereas AX in other
+ * contexts is just another 16-bit register. (Also, consider CL in
+ * shift instructions, DX in OUT, etc.)
+ *
+ * The basic concept here is that
+ *    (class & ~operand) == 0
+ *
+ * if and only if "operand" belongs to class type "class".
+ */
+
+#define OP_GENMASK(bits, shift)         (((UINT64_C(1) << (bits)) - 1) << (shift))
+#define OP_GENBIT(bit, shift)           (UINT64_C(1) << ((shift) + (bit)))
+
+/*
+ * Type of operand: memory reference, register, etc.
+ *
+ * Bits: 0 - 3
+ */
+#define OPTYPE_SHIFT            (0)
+#define OPTYPE_BITS             (4)
+#define OPTYPE_MASK             OP_GENMASK(OPTYPE_BITS, OPTYPE_SHIFT)
+#define GEN_OPTYPE(bit)         OP_GENBIT(bit, OPTYPE_SHIFT)
+
+/*
+ * Modifiers.
+ *
+ * Bits: 4 - 6
+ */
+#define MODIFIER_SHIFT          (4)
+#define MODIFIER_BITS           (3)
+#define MODIFIER_MASK           OP_GENMASK(MODIFIER_BITS, MODIFIER_SHIFT)
+#define GEN_MODIFIER(bit)       OP_GENBIT(bit, MODIFIER_SHIFT)
+
+/*
+ * Register classes.
+ *
+ * Bits: 7 - 17
+ */
+#define REG_CLASS_SHIFT         (7)
+#define REG_CLASS_BITS          (11)
+#define REG_CLASS_MASK          OP_GENMASK(REG_CLASS_BITS, REG_CLASS_SHIFT)
+#define GEN_REG_CLASS(bit)      OP_GENBIT(bit, REG_CLASS_SHIFT)
+
+/*
+ * Subclasses. Depends on type of operand.
+ *
+ * Bits: 18 - 25
+ */
+#define SUBCLASS_SHIFT          (18)
+#define SUBCLASS_BITS           (8)
+#define SUBCLASS_MASK           OP_GENMASK(SUBCLASS_BITS, SUBCLASS_SHIFT)
+#define GEN_SUBCLASS(bit)       OP_GENBIT(bit, SUBCLASS_SHIFT)
+
+/*
+ * Special flags. Context dependent.
+ *
+ * Bits: 26 - 32
+ */
+#define SPECIAL_SHIFT           (26)
+#define SPECIAL_BITS            (7)
+#define SPECIAL_MASK            OP_GENMASK(SPECIAL_BITS, SPECIAL_SHIFT)
+#define GEN_SPECIAL(bit)        OP_GENBIT(bit, SPECIAL_SHIFT)
+
+/*
+ * Sizes of the operands and attributes.
+ *
+ * Bits: 33 - 43
+ */
+#define SIZE_SHIFT              (33)
+#define SIZE_BITS               (11)
+#define SIZE_MASK               OP_GENMASK(SIZE_BITS, SIZE_SHIFT)
+#define GEN_SIZE(bit)           OP_GENBIT(bit, SIZE_SHIFT)
+
+/*
+ * Register set count
+ *
+ * Bits: 44 - 48
+ */
+#define REGSET_SHIFT            (44)
+#define REGSET_BITS             (5)
+#define REGSET_MASK             OP_GENMASK(REGSET_BITS, REGSET_SHIFT)
+#define GEN_REGSET(bit)         OP_GENBIT(bit, REGSET_SHIFT)
+
+/*
+ * Bits distribution (counted from 0)
+ *
+ *    6         5         4         3         2         1
+ * 3210987654321098765432109876543210987654321098765432109876543210
+ *                                 |
+ *                                 | dword bound
+ *
+ * ............................................................1111 optypes
+ * .........................................................111.... modifiers
+ * ..............................................11111111111....... register classes
+ * ......................................11111111.................. subclasses
+ * ...............................1111111.......................... specials
+ * ....................11111111111................................. sizes
+ * ...............11111............................................ regset count
+ */
+
+#define REGISTER                GEN_OPTYPE(0)                   /* register number in 'basereg' */
+#define IMMEDIATE               GEN_OPTYPE(1)
+#define REGMEM                  GEN_OPTYPE(2)                   /* for r/m, ie EA, operands */
+#define MEMORY                  (GEN_OPTYPE(3) | REGMEM)
+
+#define BITS8                   GEN_SIZE(0)                     /*   8 bits (BYTE) */
+#define BITS16                  GEN_SIZE(1)                     /*  16 bits (WORD) */
+#define BITS32                  GEN_SIZE(2)                     /*  32 bits (DWORD) */
+#define BITS64                  GEN_SIZE(3)                     /*  64 bits (QWORD), x64 and FPU only */
+#define BITS80                  GEN_SIZE(4)                     /*  80 bits (TWORD), FPU only */
+#define BITS128                 GEN_SIZE(5)                     /* 128 bits (OWORD) */
+#define BITS256                 GEN_SIZE(6)                     /* 256 bits (YWORD) */
+#define BITS512                 GEN_SIZE(7)                     /* 512 bits (ZWORD) */
+#define FAR                     GEN_SIZE(8)                     /* grotty: this means 16:16 or 16:32, like in CALL/JMP */
+#define NEAR                    GEN_SIZE(9)
+#define SHORT                   GEN_SIZE(10)                    /* and this means what it says :) */
+
+#define TO                      GEN_MODIFIER(0)                 /* reverse effect in FADD, FSUB &c */
+#define COLON                   GEN_MODIFIER(1)                 /* operand is followed by a colon */
+#define STRICT                  GEN_MODIFIER(2)                 /* do not optimize this operand */
+
+#define REG_CLASS_CDT           GEN_REG_CLASS(0)
+#define REG_CLASS_GPR           GEN_REG_CLASS(1)
+#define REG_CLASS_SREG          GEN_REG_CLASS(2)
+#define REG_CLASS_FPUREG        GEN_REG_CLASS(3)
+#define REG_CLASS_RM_MMX        GEN_REG_CLASS(4)
+#define REG_CLASS_RM_XMM        GEN_REG_CLASS(5)
+#define REG_CLASS_RM_YMM        GEN_REG_CLASS(6)
+#define REG_CLASS_RM_ZMM        GEN_REG_CLASS(7)
+#define REG_CLASS_OPMASK        GEN_REG_CLASS(8)
+#define REG_CLASS_BND           GEN_REG_CLASS(9)
+#define REG_CLASS_RM_TMM	GEN_REG_CLASS(10)
+
+static inline bool is_class(opflags_t class, opflags_t op)
+{
+	return !(class & ~op);
+}
+
+static inline bool is_reg_class(opflags_t class, opflags_t reg)
+{
+	if (reg >= EXPR_REG_START && reg <= EXPR_REG_END)
+		return is_class(class, nasm_reg_flags[reg]);
+	return false;
+}
+
+#define IS_SREG(reg)                is_reg_class(REG_SREG, (reg))
+#define IS_FSGS(reg)                is_reg_class(REG_FSGS, (reg))
+
+/* Register classes */
+#define REG_EA                  (                                               REGMEM | REGISTER)      /* 'normal' reg, qualifies as EA */
+#define RM_GPR                  (                  REG_CLASS_GPR              | REGMEM)                 /* integer operand */
+#define REG_GPR                 (                  REG_CLASS_GPR              | REGMEM | REGISTER)      /* integer register */
+#define REG8                    (                  REG_CLASS_GPR    | BITS8   | REGMEM | REGISTER)      /*  8-bit GPR  */
+#define REG16                   (                  REG_CLASS_GPR    | BITS16  | REGMEM | REGISTER)      /* 16-bit GPR */
+#define REG32                   (                  REG_CLASS_GPR    | BITS32  | REGMEM | REGISTER)      /* 32-bit GPR */
+#define REG64                   (                  REG_CLASS_GPR    | BITS64  | REGMEM | REGISTER)      /* 64-bit GPR */
+#define FPUREG                  (                  REG_CLASS_FPUREG                    | REGISTER)      /* floating point stack registers */
+#define FPU0                    (GEN_SUBCLASS(1) | REG_CLASS_FPUREG                    | REGISTER)      /* FPU stack register zero */
+#define RM_MMX                  (                  REG_CLASS_RM_MMX           | REGMEM)                 /* MMX operand */
+#define MMXREG                  (                  REG_CLASS_RM_MMX           | REGMEM | REGISTER)      /* MMX register */
+#define RM_XMM                  (                  REG_CLASS_RM_XMM           | REGMEM)                 /* XMM (SSE) operand */
+#define XMMREG                  (                  REG_CLASS_RM_XMM           | REGMEM | REGISTER)      /* XMM (SSE) register */
+#define RM_YMM                  (                  REG_CLASS_RM_YMM           | REGMEM)                 /* YMM (AVX) operand */
+#define YMMREG                  (                  REG_CLASS_RM_YMM           | REGMEM | REGISTER)      /* YMM (AVX) register */
+#define RM_ZMM                  (                  REG_CLASS_RM_ZMM           | REGMEM)                 /* ZMM (AVX512) operand */
+#define ZMMREG                  (                  REG_CLASS_RM_ZMM           | REGMEM | REGISTER)      /* ZMM (AVX512) register */
+#define RM_OPMASK               (                  REG_CLASS_OPMASK           | REGMEM)                 /* Opmask operand */
+#define OPMASKREG               (                  REG_CLASS_OPMASK           | REGMEM | REGISTER)      /* Opmask register */
+#define OPMASK0                 (GEN_SUBCLASS(1) | REG_CLASS_OPMASK           | REGMEM | REGISTER)      /* Opmask register zero (k0) */
+#define RM_K                    RM_OPMASK
+#define KREG                    OPMASKREG
+#define RM_BND                  (                  REG_CLASS_BND              | REGMEM)                 /* Bounds operand */
+#define BNDREG                  (                  REG_CLASS_BND              | REGMEM | REGISTER)      /* Bounds register */
+#define TMMREG                  (                  REG_CLASS_RM_TMM           | REGMEM | REGISTER)      /* TMM (AMX) register */
+#define REG_CDT                 (                  REG_CLASS_CDT    | BITS32           | REGISTER)      /* CRn, DRn and TRn */
+#define REG_CREG                (GEN_SUBCLASS(1) | REG_CLASS_CDT    | BITS32           | REGISTER)      /* CRn */
+#define REG_DREG                (GEN_SUBCLASS(2) | REG_CLASS_CDT    | BITS32           | REGISTER)      /* DRn */
+#define REG_TREG                (GEN_SUBCLASS(3) | REG_CLASS_CDT    | BITS32           | REGISTER)      /* TRn */
+#define REG_SREG                (                  REG_CLASS_SREG   | BITS16           | REGISTER)      /* any segment register */
+
+/* Segment registers */
+#define REG_ES                  (GEN_SUBCLASS(0) | GEN_SUBCLASS(2) | REG_CLASS_SREG | BITS16 | REGISTER)      /* ES */
+#define REG_CS                  (GEN_SUBCLASS(1) | GEN_SUBCLASS(2) | REG_CLASS_SREG | BITS16 | REGISTER)      /* CS */
+#define REG_SS                  (GEN_SUBCLASS(0) | GEN_SUBCLASS(3) | REG_CLASS_SREG | BITS16 | REGISTER)      /* SS */
+#define REG_DS                  (GEN_SUBCLASS(1) | GEN_SUBCLASS(3) | REG_CLASS_SREG | BITS16 | REGISTER)      /* DS */
+#define REG_FS                  (GEN_SUBCLASS(0) | GEN_SUBCLASS(4) | REG_CLASS_SREG | BITS16 | REGISTER)      /* FS */
+#define REG_GS                  (GEN_SUBCLASS(1) | GEN_SUBCLASS(4) | REG_CLASS_SREG | BITS16 | REGISTER)      /* GS */
+#define REG_FSGS                (                  GEN_SUBCLASS(4) | REG_CLASS_SREG | BITS16 | REGISTER)      /* FS or GS */
+#define REG_SEG67               (                  GEN_SUBCLASS(5) | REG_CLASS_SREG | BITS16 | REGISTER)      /* Unimplemented segment registers */
+
+/* Special GPRs */
+#define REG_SMASK               SUBCLASS_MASK                                                                           /* a mask for the following */
+#define REG_ACCUM               (GEN_SUBCLASS(1)                   | REG_CLASS_GPR           | REGMEM | REGISTER)       /* accumulator: AL, AX, EAX, RAX */
+#define REG_AL                  (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)
+#define REG_AX                  (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)
+#define REG_EAX                 (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)
+#define REG_RAX                 (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)
+#define REG_COUNT               (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR           | REGMEM | REGISTER)       /* counter: CL, CX, ECX, RCX */
+#define REG_CL                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)
+#define REG_CX                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)
+#define REG_ECX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)
+#define REG_RCX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)
+#define REG_DL                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)       /* data: DL, DX, EDX, RDX */
+#define REG_DX                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)
+#define REG_EDX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)
+#define REG_RDX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)
+#define REG_HIGH                (GEN_SUBCLASS(5) | GEN_SUBCLASS(4) | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)       /* high regs: AH, CH, DH, BH */
+#define REG_NOTACC              GEN_SUBCLASS(5)                                                                         /* non-accumulator register */
+#define REG8NA                  (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)       /*  8-bit non-acc GPR  */
+#define REG16NA                 (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)       /* 16-bit non-acc GPR */
+#define REG32NA                 (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)       /* 32-bit non-acc GPR */
+#define REG64NA                 (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)       /* 64-bit non-acc GPR */
+
+/* special types of EAs */
+#define MEM_OFFS                (GEN_SUBCLASS(1) | MEMORY)      /* simple [address] offset - absolute! */
+#define IP_REL                  (GEN_SUBCLASS(2) | MEMORY)      /* IP-relative offset */
+#define XMEM                    (GEN_SUBCLASS(3) | MEMORY)      /* 128-bit vector SIB */
+#define YMEM                    (GEN_SUBCLASS(4) | MEMORY)      /* 256-bit vector SIB */
+#define ZMEM                    (GEN_SUBCLASS(5) | MEMORY)      /* 512-bit vector SIB */
+
+/* memory which matches any type of r/m operand */
+#define MEMORY_ANY              (MEMORY | RM_GPR | RM_MMX | RM_XMM_L16 | RM_YMM_L16 | RM_ZMM_L16 | RM_OPMASK | RM_BND)
+
+/* special immediate values */
+#define UNITY                   (GEN_SUBCLASS(0) | IMMEDIATE)   /* operand equals 1 */
+#define SBYTEWORD               (GEN_SUBCLASS(1) | IMMEDIATE)   /* operand is in the range -128..127 mod 2^16 */
+#define SBYTEDWORD              (GEN_SUBCLASS(2) | IMMEDIATE)   /* operand is in the range -128..127 mod 2^32 */
+#define SDWORD                  (GEN_SUBCLASS(3) | IMMEDIATE)   /* operand is in the range -0x80000000..0x7FFFFFFF */
+#define UDWORD                  (GEN_SUBCLASS(4) | IMMEDIATE)   /* operand is in the range 0..0xFFFFFFFF */
+
+/*
+ * Subset of vector registers: register 0 only and registers 0-15.
+ * Avoid conflicts in subclass bitfield with any of special EA types!
+ */
+#define RM_XMM_L16              (GEN_SUBCLASS(6) | RM_XMM)                                              /* XMM r/m operand  0 ~ 15 */
+#define XMM0                    (GEN_SUBCLASS(1) | GEN_SUBCLASS(6) | XMMREG)                            /* XMM register   zero  */
+#define XMM_L16                 (                  GEN_SUBCLASS(6) | XMMREG)                            /* XMM register  0 ~ 15 */
+
+#define RM_YMM_L16              (GEN_SUBCLASS(6) | RM_YMM)                                              /* YMM r/m operand  0 ~ 15 */
+#define YMM0                    (GEN_SUBCLASS(1) | GEN_SUBCLASS(6) | YMMREG)                            /* YMM register   zero  */
+#define YMM_L16                 (                  GEN_SUBCLASS(6) | YMMREG)                            /* YMM register  0 ~ 15 */
+
+#define RM_ZMM_L16              (GEN_SUBCLASS(6) | RM_ZMM)                                              /* ZMM r/m operand  0 ~ 15 */
+#define ZMM0                    (GEN_SUBCLASS(1) | GEN_SUBCLASS(6) | ZMMREG)                            /* ZMM register   zero  */
+#define ZMM_L16                 (                  GEN_SUBCLASS(6) | ZMMREG)                            /* ZMM register  0 ~ 15 */
+
+/* Register set sizes */
+#define RS2                     GEN_REGSET(0)
+#define RS4                     GEN_REGSET(1)
+#define RS8                     GEN_REGSET(2)
+#define RS16                    GEN_REGSET(3)
+#define RS32                    GEN_REGSET(4)
+
+#endif /* NASM_OPFLAGS_H */
diff --git a/vere/ext/nasm/include/perfhash.h b/vere/ext/nasm/include/perfhash.h
new file mode 100644
index 0000000..43e536c
--- /dev/null
+++ b/vere/ext/nasm/include/perfhash.h
@@ -0,0 +1,52 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef PERFHASH_H
+#define PERFHASH_H 1
+
+#include "compiler.h"
+#include "nasmlib.h"            /* For invalid_enum_str() */
+
+struct perfect_hash {
+    uint64_t crcinit;
+    uint32_t hashmask;
+    uint32_t tbllen;
+    int tbloffs;
+    int errval;
+    const int16_t *hashvals;
+    const char * const *strings;
+};
+
+int perfhash_find(const struct perfect_hash *, const char *);
+
+#endif /* PERFHASH_H */
diff --git a/vere/ext/nasm/include/raa.h b/vere/ext/nasm/include/raa.h
new file mode 100644
index 0000000..e08d90b
--- /dev/null
+++ b/vere/ext/nasm/include/raa.h
@@ -0,0 +1,49 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASM_RAA_H
+#define NASM_RAA_H 1
+
+#include "compiler.h"
+
+struct RAA;
+typedef uint64_t raaindex;
+
+#define raa_init() NULL
+void raa_free(struct RAA *);
+int64_t raa_read(struct RAA *, raaindex);
+void *raa_read_ptr(struct RAA *, raaindex);
+struct RAA * never_null raa_write(struct RAA *r, raaindex posn, int64_t value);
+struct RAA * never_null raa_write_ptr(struct RAA *r, raaindex posn, void *value);
+
+#endif                          /* NASM_RAA_H */
diff --git a/vere/ext/nasm/include/rbtree.h b/vere/ext/nasm/include/rbtree.h
new file mode 100644
index 0000000..39d45af
--- /dev/null
+++ b/vere/ext/nasm/include/rbtree.h
@@ -0,0 +1,108 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASM_RBTREE_H
+#define NASM_RBTREE_H
+
+#include "compiler.h"
+
+/*
+ * This structure should be embedded in a larger data structure;
+ * the final output from rb_search() can then be converted back
+ * to the larger data structure via container_of().
+ *
+ * An empty tree is simply represented by a NULL pointer.
+ */
+
+/* Note: the values of these flags is significant */
+enum rbtree_node_flags {
+    RBTREE_NODE_BLACK	= 1,  /* Node color is black */
+    RBTREE_NODE_PRED    = 2,  /* Left pointer is an uplink */
+    RBTREE_NODE_SUCC    = 4   /* Right pointer is an uplink */
+};
+
+struct rbtree {
+    uint64_t key;
+    struct rbtree_metadata {
+        struct rbtree *left, *right;
+        enum rbtree_node_flags flags;
+    } m;
+};
+
+/*
+ * Add a node to a tree. Returns the new root pointer.
+ * The key value in the structure needs to be preinitialized;
+ * the rest of the structure should be zero.
+ */
+struct rbtree *rb_insert(struct rbtree *, struct rbtree *);
+
+/*
+ * Find a node in the tree corresponding to the key immediately
+ * <= the passed-in key value.
+ */
+struct rbtree *rb_search(const struct rbtree *, uint64_t);
+
+/*
+ * Find a node in the tree exactly matching the key value.
+ */
+struct rbtree *rb_search_exact(const struct rbtree *, uint64_t);
+
+/*
+ * Return the immediately previous or next node in key order.
+ * Returns NULL if this node is the end of the tree.
+ * These operations are safe for complee (but not partial!)
+ * tree walk-with-destruction in key order.
+ */
+struct rbtree *rb_prev(const struct rbtree *);
+struct rbtree *rb_next(const struct rbtree *);
+
+/*
+ * Return the very first or very last node in key order.
+ */
+struct rbtree *rb_first(const struct rbtree *);
+struct rbtree *rb_last(const struct rbtree *);
+
+/*
+ * Left and right nodes, if real. These operations are
+ * safe for tree destruction, but not for splitting a tree.
+ */
+static inline struct rbtree *rb_left(const struct rbtree *rb)
+{
+    return (rb->m.flags & RBTREE_NODE_PRED) ? NULL : rb->m.left;
+}
+static inline struct rbtree *rb_right(const struct rbtree *rb)
+{
+    return (rb->m.flags & RBTREE_NODE_SUCC) ? NULL : rb->m.right;
+}
+
+#endif /* NASM_RBTREE_H */
diff --git a/vere/ext/nasm/include/rdoff.h b/vere/ext/nasm/include/rdoff.h
new file mode 100644
index 0000000..973be8c
--- /dev/null
+++ b/vere/ext/nasm/include/rdoff.h
@@ -0,0 +1,169 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rdoff.h	RDOFF Object File manipulation routines header file
+ */
+
+#ifndef RDOFF_H
+#define RDOFF_H 1
+
+/*
+ * RDOFF definitions. They are used by RDOFF utilities and by NASM's
+ * 'outrdf2.c' output module.
+ */
+
+/* RDOFF format revision (currently used only when printing the version) */
+#define RDOFF2_REVISION		"0.6.1"
+
+/* RDOFF2 file signature */
+#define RDOFF2_SIGNATURE	"RDOFF2"
+
+/* Maximum size of an import/export label (including trailing zero) */
+#define EXIM_LABEL_MAX		256
+
+/* Maximum size of library or module name (including trailing zero) */
+#define MODLIB_NAME_MAX		128
+
+/* Maximum number of segments that we can handle in one file */
+#define RDF_MAXSEGS		64
+
+/* Record types that may present the RDOFF header */
+#define RDFREC_GENERIC		0
+#define RDFREC_RELOC		1
+#define RDFREC_IMPORT		2
+#define RDFREC_GLOBAL		3
+#define RDFREC_DLL		4
+#define RDFREC_BSS		5
+#define RDFREC_SEGRELOC		6
+#define RDFREC_FARIMPORT	7
+#define RDFREC_MODNAME		8
+#define RDFREC_COMMON		10
+
+/*
+ * Generic record - contains the type and length field, plus a 128 byte
+ * array 'data'
+ */
+struct GenericRec {
+    uint8_t type;
+    uint8_t reclen;
+    char data[128];
+};
+
+/*
+ * Relocation record
+ */
+struct RelocRec {
+    uint8_t type;                  /* must be 1 */
+    uint8_t reclen;                /* content length */
+    uint8_t segment;               /* only 0 for code, or 1 for data supported,
+                                   but add 64 for relative refs (ie do not require
+                                   reloc @ loadtime, only linkage) */
+    int32_t offset;                /* from start of segment in which reference is loc'd */
+    uint8_t length;                /* 1 2 or 4 bytes */
+    uint16_t refseg;              /* segment to which reference refers to */
+};
+
+/*
+ * Extern/import record
+ */
+struct ImportRec {
+    uint8_t type;                  /* must be 2 */
+    uint8_t reclen;                /* content length */
+    uint8_t flags;                 /* SYM_* flags (see below) */
+    uint16_t segment;             /* segment number allocated to the label for reloc
+                                   records - label is assumed to be at offset zero
+                                   in this segment, so linker must fix up with offset
+                                   of segment and of offset within segment */
+    char label[EXIM_LABEL_MAX]; /* zero terminated, should be written to file
+                                   until the zero, but not after it */
+};
+
+/*
+ * Public/export record
+ */
+struct ExportRec {
+    uint8_t type;                  /* must be 3 */
+    uint8_t reclen;                /* content length */
+    uint8_t flags;                 /* SYM_* flags (see below) */
+    uint8_t segment;               /* segment referred to (0/1/2) */
+    int32_t offset;                /* offset within segment */
+    char label[EXIM_LABEL_MAX]; /* zero terminated as in import */
+};
+
+/*
+ * DLL record
+ */
+struct DLLRec {
+    uint8_t type;                  /* must be 4 */
+    uint8_t reclen;                /* content length */
+    char libname[MODLIB_NAME_MAX];      /* name of library to link with at load time */
+};
+
+/*
+ * BSS record
+ */
+struct BSSRec {
+    uint8_t type;                  /* must be 5 */
+    uint8_t reclen;                /* content length */
+    int32_t amount;                /* number of bytes BSS to reserve */
+};
+
+/*
+ * Module name record
+ */
+struct ModRec {
+    uint8_t type;                  /* must be 8 */
+    uint8_t reclen;                /* content length */
+    char modname[MODLIB_NAME_MAX];      /* module name */
+};
+
+/*
+ * Common variable record
+ */
+struct CommonRec {
+    uint8_t type;                  /* must be 10 */
+    uint8_t reclen;                /* equals 7+label length */
+    uint16_t segment;             /* segment number */
+    int32_t size;                  /* size of common variable */
+    uint16_t align;               /* alignment (power of two) */
+    char label[EXIM_LABEL_MAX]; /* zero terminated as in import */
+};
+
+/* Flags for ExportRec */
+#define SYM_DATA	1
+#define SYM_FUNCTION	2
+#define SYM_GLOBAL	4
+#define SYM_IMPORT	8
+
+#endif                          /* RDOFF_H */
diff --git a/vere/ext/nasm/include/saa.h b/vere/ext/nasm/include/saa.h
new file mode 100644
index 0000000..9d939ef
--- /dev/null
+++ b/vere/ext/nasm/include/saa.h
@@ -0,0 +1,94 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASM_SAA_H
+#define NASM_SAA_H
+
+#include "compiler.h"
+
+/*
+ * Routines to manage a dynamic sequential-access array, under the
+ * same restriction on maximum mallocable block. This array may be
+ * written to in two ways: a contiguous chunk can be reserved of a
+ * given size with a pointer returned OR single-byte data may be
+ * written. The array can also be read back in the same two ways:
+ * as a series of big byte-data blocks or as a list of structures
+ * of a given size.
+ */
+
+struct SAA {
+    /*
+     * members `end' and `elem_len' are only valid in first link in
+     * list; `rptr' and `rpos' are used for reading
+     */
+    size_t elem_len;            /* Size of each element */
+    size_t blk_len;             /* Size of each allocation block */
+    size_t nblks;               /* Total number of allocated blocks */
+    size_t nblkptrs;            /* Total number of allocation block pointers */
+    size_t length;              /* Total allocated length of the array */
+    size_t datalen;             /* Total data length of the array */
+    char **wblk;                /* Write block pointer */
+    size_t wpos;                /* Write position inside block */
+    size_t wptr;                /* Absolute write position */
+    char **rblk;                /* Read block pointer */
+    size_t rpos;                /* Read position inside block */
+    size_t rptr;                /* Absolute read position */
+    char **blk_ptrs;            /* Pointer to pointer blocks */
+};
+
+struct SAA * never_null saa_init(size_t elem_len);  /* 1 == byte */
+void saa_free(struct SAA *);
+void *saa_wstruct(struct SAA *);        /* return a structure of elem_len */
+void saa_wbytes(struct SAA *, const void *, size_t);    /* write arbitrary bytes */
+size_t saa_wcstring(struct SAA *s, const char *str);     /* write a C string */
+void saa_rewind(struct SAA *);  /* for reading from beginning */
+void *saa_rstruct(struct SAA *);        /* return NULL on EOA */
+const void *saa_rbytes(struct SAA *, size_t *); /* return 0 on EOA */
+void saa_rnbytes(struct SAA *, void *, size_t); /* read a given no. of bytes */
+/* random access */
+void saa_fread(struct SAA *, size_t, void *, size_t);
+void saa_fwrite(struct SAA *, size_t, const void *, size_t);
+
+/* dump to file */
+void saa_fpwrite(struct SAA *, FILE *);
+
+/* Write specific-sized values */
+void saa_write8(struct SAA *s, uint8_t v);
+void saa_write16(struct SAA *s, uint16_t v);
+void saa_write32(struct SAA *s, uint32_t v);
+void saa_write64(struct SAA *s, uint64_t v);
+void saa_wleb128u(struct SAA *, int);   /* write unsigned LEB128 value */
+void saa_wleb128s(struct SAA *, int);   /* write signed LEB128 value */
+void saa_writeaddr(struct SAA *, uint64_t, size_t);
+
+#endif                          /* NASM_SAA_H */
diff --git a/vere/ext/nasm/include/strlist.h b/vere/ext/nasm/include/strlist.h
new file mode 100644
index 0000000..faf70e2
--- /dev/null
+++ b/vere/ext/nasm/include/strlist.h
@@ -0,0 +1,93 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * strlist.h - list of unique, ordered strings
+ */
+
+#ifndef NASM_STRLIST_H
+#define NASM_STRLIST_H
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "hashtbl.h"
+
+struct strlist_entry {
+	struct strlist_entry	*next;
+	size_t			offset;
+	size_t			size;
+	intorptr		pvt;
+	char			str[1];
+};
+
+struct strlist {
+	struct hash_table	hash;
+	struct strlist_entry	*head, **tailp;
+	size_t			nstr, size;
+	bool			uniq;
+};
+
+static inline const struct strlist_entry *
+strlist_head(const struct strlist *list)
+{
+	return list ? list->head : NULL;
+}
+static inline struct strlist_entry *strlist_tail(struct strlist *list)
+{
+	if (!list || !list->head)
+		return NULL;
+	return container_of(list->tailp, struct strlist_entry, next);
+}
+static inline size_t strlist_count(const struct strlist *list)
+{
+	return list ? list->nstr : 0;
+}
+static inline size_t strlist_size(const struct strlist *list)
+{
+	return list ? list->size : 0;
+}
+
+struct strlist * safe_alloc strlist_alloc(bool uniq);
+const struct strlist_entry *strlist_add(struct strlist *list, const char *str);
+const struct strlist_entry * printf_func(2, 3)
+	strlist_printf(struct strlist *list, const char *fmt, ...);
+const struct strlist_entry * vprintf_func(2)
+	strlist_vprintf(struct strlist *list, const char *fmt, va_list ap);
+const struct strlist_entry *
+strlist_find(const struct strlist *list, const char *str);
+void * safe_alloc strlist_linearize(const struct strlist *list, char sep);
+void strlist_write(const struct strlist *list, const char *sep, FILE *f);
+void strlist_free(struct strlist **listp);
+#define strlist_for_each(p,h) list_for_each((p), strlist_head(h))
+ 
+#endif /* NASM_STRLIST_H */
diff --git a/vere/ext/nasm/include/tables.h b/vere/ext/nasm/include/tables.h
new file mode 100644
index 0000000..2b36357
--- /dev/null
+++ b/vere/ext/nasm/include/tables.h
@@ -0,0 +1,77 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * tables.h
+ *
+ * Declarations for auto-generated tables
+ */
+
+#ifndef NASM_TABLES_H
+#define NASM_TABLES_H
+
+#include "compiler.h"
+#include "insnsi.h"		/* For enum opcode */
+
+/* --- From standard.mac via macros.pl: --- */
+
+/* macros.c */
+extern const unsigned char nasm_stdmac_tasm[];
+extern const unsigned char nasm_stdmac_nasm[];
+extern const unsigned char nasm_stdmac_version[];
+
+struct use_package {
+    const char *package;
+    const unsigned char *macros;
+    int index;
+};
+extern const struct use_package *nasm_find_use_package(const char *);
+extern const int use_package_count;
+
+/* --- From insns.dat via insns.pl: --- */
+
+/* insnsn.c */
+extern const char * const nasm_insn_names[];
+
+/* --- From regs.dat via regs.pl: --- */
+
+/* regs.c */
+extern const char * const nasm_reg_names[];
+/* regflags.c */
+typedef uint64_t opflags_t;
+typedef uint16_t  decoflags_t;
+extern const opflags_t nasm_reg_flags[];
+/* regvals.c */
+extern const int nasm_regvals[];
+
+#endif /* NASM_TABLES_H */
diff --git a/vere/ext/nasm/include/ver.h b/vere/ext/nasm/include/ver.h
new file mode 100644
index 0000000..a5bbf38
--- /dev/null
+++ b/vere/ext/nasm/include/ver.h
@@ -0,0 +1,55 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * NASM version strings, defined in ver.c
+ */
+
+#ifndef NASM_VER_H
+#define NASM_VER_H
+
+#include "compiler.h"
+
+extern const char nasm_version[];
+extern const char nasm_date[];
+extern const char nasm_compile_options[];
+
+extern bool reproducible;
+
+extern const char *nasm_comment(void);
+extern size_t nasm_comment_len(void);
+
+extern const char *nasm_signature(void);
+extern size_t nasm_signature_len(void);
+
+#endif /* NASM_VER_H */
diff --git a/vere/ext/nasm/include/warnings.h b/vere/ext/nasm/include/warnings.h
new file mode 100644
index 0000000..3707515
--- /dev/null
+++ b/vere/ext/nasm/include/warnings.h
@@ -0,0 +1,131 @@
+#ifndef NASM_WARNINGS_H
+#define NASM_WARNINGS_H
+
+#ifndef WARN_SHR
+# error "warnings.h should only be included from within error.h"
+#endif
+
+enum warn_index {
+	WARN_IDX_NONE                    =   0, /* not suppressible */
+	WARN_IDX_DB_EMPTY                =   1, /* no operand for data declaration */
+	WARN_IDX_EA_ABSOLUTE             =   2, /* absolute address cannot be RIP-relative */
+	WARN_IDX_EA_DISPSIZE             =   3, /* displacement size ignored on absolute address */
+	WARN_IDX_FLOAT_DENORM            =   4, /* floating point denormal */
+	WARN_IDX_FLOAT_OVERFLOW          =   5, /* floating point overflow */
+	WARN_IDX_FLOAT_TOOLONG           =   6, /* too many digits in floating-point number */
+	WARN_IDX_FLOAT_UNDERFLOW         =   7, /* floating point underflow */
+	WARN_IDX_FORWARD                 =   8, /* forward reference may have unpredictable results */
+	WARN_IDX_LABEL_ORPHAN            =   9, /* labels alone on lines without trailing `:' */
+	WARN_IDX_LABEL_REDEF             =  10, /* label redefined to an identical value */
+	WARN_IDX_LABEL_REDEF_LATE        =  11, /* label (re)defined during code generation */
+	WARN_IDX_NUMBER_OVERFLOW         =  12, /* numeric constant does not fit */
+	WARN_IDX_OBSOLETE_NOP            =  13, /* instruction obsolete and is a noop on the target CPU */
+	WARN_IDX_OBSOLETE_REMOVED        =  14, /* instruction obsolete and removed on the target CPU */
+	WARN_IDX_OBSOLETE_VALID          =  15, /* instruction obsolete but valid on the target CPU */
+	WARN_IDX_PHASE                   =  16, /* phase error during stabilization */
+	WARN_IDX_PP_ELSE_ELIF            =  17, /* %elif after %else */
+	WARN_IDX_PP_ELSE_ELSE            =  18, /* %else after %else */
+	WARN_IDX_PP_EMPTY_BRACES         =  19, /* empty %{} construct */
+	WARN_IDX_PP_ENVIRONMENT          =  20, /* nonexistent environment variable */
+	WARN_IDX_PP_MACRO_DEF_CASE_SINGLE =  21, /* single-line macro defined both case sensitive and insensitive */
+	WARN_IDX_PP_MACRO_DEF_GREEDY_SINGLE =  22, /* single-line macro */
+	WARN_IDX_PP_MACRO_DEF_PARAM_SINGLE =  23, /* single-line macro defined with and without parameters */
+	WARN_IDX_PP_MACRO_DEFAULTS       =  24, /* macros with more default than optional parameters */
+	WARN_IDX_PP_MACRO_PARAMS_LEGACY  =  25, /* improperly calling multi-line macro for legacy support */
+	WARN_IDX_PP_MACRO_PARAMS_MULTI   =  26, /* multi-line macro calls with wrong parameter count */
+	WARN_IDX_PP_MACRO_PARAMS_SINGLE  =  27, /* single-line macro calls with wrong parameter count */
+	WARN_IDX_PP_MACRO_REDEF_MULTI    =  28, /* redefining multi-line macro */
+	WARN_IDX_PP_OPEN_BRACES          =  29, /* unterminated %{...} */
+	WARN_IDX_PP_OPEN_BRACKETS        =  30, /* unterminated %[...] */
+	WARN_IDX_PP_OPEN_STRING          =  31, /* unterminated string */
+	WARN_IDX_PP_REP_NEGATIVE         =  32, /* regative %rep count */
+	WARN_IDX_PP_SEL_RANGE            =  33, /* %sel() argument out of range */
+	WARN_IDX_PP_TRAILING             =  34, /* trailing garbage ignored */
+	WARN_IDX_PRAGMA_BAD              =  35, /* malformed %pragma */
+	WARN_IDX_PRAGMA_EMPTY            =  36, /* empty %pragma directive */
+	WARN_IDX_PRAGMA_NA               =  37, /* %pragma not applicable to this compilation */
+	WARN_IDX_PRAGMA_UNKNOWN          =  38, /* unknown %pragma facility or directive */
+	WARN_IDX_PREFIX_BND              =  39, /* invalid BND prefix */
+	WARN_IDX_PREFIX_HLE              =  40, /* invalid HLE prefix */
+	WARN_IDX_PREFIX_LOCK             =  41, /* LOCK prefix on unlockable instructions */
+	WARN_IDX_PREFIX_OPSIZE           =  42, /* invalid operand size prefix */
+	WARN_IDX_PREFIX_SEG              =  43, /* segment prefix ignored in 64-bit mode */
+	WARN_IDX_PTR                     =  44, /* non-NASM keyword used in other assemblers */
+	WARN_IDX_REGSIZE                 =  45, /* register size specification ignored */
+	WARN_IDX_UNKNOWN_WARNING         =  46, /* unknown warning in -W/-w or warning directive */
+	WARN_IDX_USER                    =  47, /* %warning directives */
+	WARN_IDX_WARN_STACK_EMPTY        =  48, /* warning stack empty */
+	WARN_IDX_ZEROING                 =  49, /* RESx in initialized section becomes zero */
+	WARN_IDX_ZEXT_RELOC              =  50, /* relocation zero-extended to match output format */
+	WARN_IDX_OTHER                   =  51, /* any warning not specifically mentioned above */
+	WARN_IDX_ALL                     =  52  /* all possible warnings */
+};
+
+enum warn_const {
+	WARN_NONE                        =   0 << WARN_SHR,
+	WARN_DB_EMPTY                    =   1 << WARN_SHR,
+	WARN_EA_ABSOLUTE                 =   2 << WARN_SHR,
+	WARN_EA_DISPSIZE                 =   3 << WARN_SHR,
+	WARN_FLOAT_DENORM                =   4 << WARN_SHR,
+	WARN_FLOAT_OVERFLOW              =   5 << WARN_SHR,
+	WARN_FLOAT_TOOLONG               =   6 << WARN_SHR,
+	WARN_FLOAT_UNDERFLOW             =   7 << WARN_SHR,
+	WARN_FORWARD                     =   8 << WARN_SHR,
+	WARN_LABEL_ORPHAN                =   9 << WARN_SHR,
+	WARN_LABEL_REDEF                 =  10 << WARN_SHR,
+	WARN_LABEL_REDEF_LATE            =  11 << WARN_SHR,
+	WARN_NUMBER_OVERFLOW             =  12 << WARN_SHR,
+	WARN_OBSOLETE_NOP                =  13 << WARN_SHR,
+	WARN_OBSOLETE_REMOVED            =  14 << WARN_SHR,
+	WARN_OBSOLETE_VALID              =  15 << WARN_SHR,
+	WARN_PHASE                       =  16 << WARN_SHR,
+	WARN_PP_ELSE_ELIF                =  17 << WARN_SHR,
+	WARN_PP_ELSE_ELSE                =  18 << WARN_SHR,
+	WARN_PP_EMPTY_BRACES             =  19 << WARN_SHR,
+	WARN_PP_ENVIRONMENT              =  20 << WARN_SHR,
+	WARN_PP_MACRO_DEF_CASE_SINGLE    =  21 << WARN_SHR,
+	WARN_PP_MACRO_DEF_GREEDY_SINGLE  =  22 << WARN_SHR,
+	WARN_PP_MACRO_DEF_PARAM_SINGLE   =  23 << WARN_SHR,
+	WARN_PP_MACRO_DEFAULTS           =  24 << WARN_SHR,
+	WARN_PP_MACRO_PARAMS_LEGACY      =  25 << WARN_SHR,
+	WARN_PP_MACRO_PARAMS_MULTI       =  26 << WARN_SHR,
+	WARN_PP_MACRO_PARAMS_SINGLE      =  27 << WARN_SHR,
+	WARN_PP_MACRO_REDEF_MULTI        =  28 << WARN_SHR,
+	WARN_PP_OPEN_BRACES              =  29 << WARN_SHR,
+	WARN_PP_OPEN_BRACKETS            =  30 << WARN_SHR,
+	WARN_PP_OPEN_STRING              =  31 << WARN_SHR,
+	WARN_PP_REP_NEGATIVE             =  32 << WARN_SHR,
+	WARN_PP_SEL_RANGE                =  33 << WARN_SHR,
+	WARN_PP_TRAILING                 =  34 << WARN_SHR,
+	WARN_PRAGMA_BAD                  =  35 << WARN_SHR,
+	WARN_PRAGMA_EMPTY                =  36 << WARN_SHR,
+	WARN_PRAGMA_NA                   =  37 << WARN_SHR,
+	WARN_PRAGMA_UNKNOWN              =  38 << WARN_SHR,
+	WARN_PREFIX_BND                  =  39 << WARN_SHR,
+	WARN_PREFIX_HLE                  =  40 << WARN_SHR,
+	WARN_PREFIX_LOCK                 =  41 << WARN_SHR,
+	WARN_PREFIX_OPSIZE               =  42 << WARN_SHR,
+	WARN_PREFIX_SEG                  =  43 << WARN_SHR,
+	WARN_PTR                         =  44 << WARN_SHR,
+	WARN_REGSIZE                     =  45 << WARN_SHR,
+	WARN_UNKNOWN_WARNING             =  46 << WARN_SHR,
+	WARN_USER                        =  47 << WARN_SHR,
+	WARN_WARN_STACK_EMPTY            =  48 << WARN_SHR,
+	WARN_ZEROING                     =  49 << WARN_SHR,
+	WARN_ZEXT_RELOC                  =  50 << WARN_SHR,
+	WARN_OTHER                       =  51 << WARN_SHR
+};
+
+struct warning_alias {
+	const char *name;
+	enum warn_index warning;
+};
+
+#define NUM_WARNING_ALIAS 68
+extern const char * const warning_name[53];
+extern const char * const warning_help[53];
+extern const struct warning_alias warning_alias[NUM_WARNING_ALIAS];
+extern const uint8_t warning_default[52];
+extern uint8_t warning_state[52];
+
+#endif /* NASM_WARNINGS_H */
diff --git a/vere/ext/nasm/macros/altreg.mac b/vere/ext/nasm/macros/altreg.mac
new file mode 100644
index 0000000..16134cd
--- /dev/null
+++ b/vere/ext/nasm/macros/altreg.mac
@@ -0,0 +1,107 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;;
+;; altreg.mac
+;;
+;; Alternate register names for 64-bit mode
+;;
+
+USE: altreg
+
+;;
+;; Intel documents R8L-R15L instead of R8B-R15B
+;; (Warning: this may confuse people with an AT&T-style assembly
+;; background, where "r8l" means R8D, etc.)
+;;
+%idefine r8l  r8b
+%idefine r9l  r9b
+%idefine r10l r10b
+%idefine r11l r11b
+%idefine r12l r12b
+%idefine r13l r13b
+%idefine r14l r14b
+%idefine r15l r15b
+
+;;
+;; Numeric register names for the lower 8 registers
+;;
+%idefine r0  rax
+%idefine r1  rcx
+%idefine r2  rdx
+%idefine r3  rbx
+%idefine r4  rsp
+%idefine r5  rbp
+%idefine r6  rsi
+%idefine r7  rdi
+
+%idefine r0d eax
+%idefine r1d ecx
+%idefine r2d edx
+%idefine r3d ebx
+%idefine r4d esp
+%idefine r5d ebp
+%idefine r6d esi
+%idefine r7d edi
+
+%idefine r0w ax
+%idefine r1w cx
+%idefine r2w dx
+%idefine r3w bx
+%idefine r4w sp
+%idefine r5w bp
+%idefine r6w si
+%idefine r7w di
+
+%idefine r0b al
+%idefine r1b cl
+%idefine r2b dl
+%idefine r3b bl
+%idefine r4b spl
+%idefine r5b bpl
+%idefine r6b sil
+%idefine r7b dil
+
+%idefine r0l al
+%idefine r1l cl
+%idefine r2l dl
+%idefine r3l bl
+%idefine r4l spl
+%idefine r5l bpl
+%idefine r6l sil
+%idefine r7l dil
+
+%idefine r0h ah
+%idefine r1h ch
+%idefine r2h dh
+%idefine r3h bh
diff --git a/vere/ext/nasm/macros/fp.mac b/vere/ext/nasm/macros/fp.mac
new file mode 100644
index 0000000..3a094a5
--- /dev/null
+++ b/vere/ext/nasm/macros/fp.mac
@@ -0,0 +1,62 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 2010-2020 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;;
+;; fp.mac
+;;
+;; Floating-point utility macros
+;;
+
+USE: fp
+
+%define	Inf		__?Infinity?__
+%define NaN		__?QNaN?__
+%define QNaN		__?QNaN?__
+%define SNaN		__?SNaN?__
+
+%define float8(x)	__?float8?__(x)
+%define float16(x)	__?float16?__(x)
+%define bfloat16(x)     __?bfloat16?__(x)
+%define float32(x)	__?float32?__(x)
+%define float64(x)	__?float64?__(x)
+%define float80m(x)	__?float80m?__(x)
+%define float80e(x)	__?float80e?__(x)
+%define float128l(x)	__?float128l?__(x)
+%define float128h(x)	__?float128h?__(x)
+
+%imacro bf16 1-*.nolist
+  %rep %0
+    dw __?bfloat16?__(%1)
+    %rotate 1
+  %endrep
+%endmacro
diff --git a/vere/ext/nasm/macros/ifunc.mac b/vere/ext/nasm/macros/ifunc.mac
new file mode 100644
index 0000000..4db46d3
--- /dev/null
+++ b/vere/ext/nasm/macros/ifunc.mac
@@ -0,0 +1,48 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 2012-2016 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;;
+;; ifunc.mac
+;;
+;; Integer function utility macros
+;;
+
+USE: ifunc
+
+%idefine ilog2(x)	(__?ilog2e?__(x))
+%idefine ilog2e(x)	(__?ilog2e?__(x))
+%idefine ilog2w(x)	(__?ilog2w?__(x))
+%idefine ilog2fw(x)	(__?ilog2w?__(x))
+%idefine ilog2f(x)	(__?ilog2f?__(x))
+%idefine ilog2cw(x)	(__?ilog2w?__(x) * 0 + __?ilog2c?__(x))
+%idefine ilog2c(x)	(__?ilog2c?__(x))
diff --git a/vere/ext/nasm/macros/macros.c b/vere/ext/nasm/macros/macros.c
new file mode 100644
index 0000000..b00e426
--- /dev/null
+++ b/vere/ext/nasm/macros/macros.c
@@ -0,0 +1,875 @@
+/*
+ * Do not edit - this file auto-generated by macros.pl from:
+ *   version.mac
+ *   ./macros/altreg.mac
+ *   ./macros/fp.mac
+ *   ./macros/ifunc.mac
+ *   ./macros/masm.mac
+ *   ./macros/smartalign.mac
+ *   ./macros/standard.mac
+ *   ./output/outaout.mac
+ *   ./output/outas86.mac
+ *   ./output/outbin.mac
+ *   ./output/outcoff.mac
+ *   ./output/outdbg.mac
+ *   ./output/outelf.mac
+ *   ./output/outmacho.mac
+ *   ./output/outobj.mac
+ */
+
+#include "tables.h"
+#include "nasmlib.h"
+#include "hashtbl.h"
+#include "outform.h"
+
+#define p_if                     128
+#define p_ifctx                  129
+#define p_ifdef                  130
+#define p_ifdefalias             131
+#define p_ifdifi                 132
+#define p_ifempty                133
+#define p_ifenv                  134
+#define p_ifid                   135
+#define p_ifidn                  136
+#define p_ifidni                 137
+#define p_ifmacro                138
+#define p_ifnum                  139
+#define p_ifstr                  140
+#define p_iftoken                141
+#define p_ifusable               142
+#define p_ifusing                143
+#define p_ifn                    144
+#define p_ifnctx                 145
+#define p_ifndef                 146
+#define p_ifndefalias            147
+#define p_ifndifi                148
+#define p_ifnempty               149
+#define p_ifnenv                 150
+#define p_ifnid                  151
+#define p_ifnidn                 152
+#define p_ifnidni                153
+#define p_ifnmacro               154
+#define p_ifnnum                 155
+#define p_ifnstr                 156
+#define p_ifntoken               157
+#define p_ifnusable              158
+#define p_ifnusing               159
+#define p_elif                   160
+#define p_elifctx                161
+#define p_elifdef                162
+#define p_elifdefalias           163
+#define p_elifdifi               164
+#define p_elifempty              165
+#define p_elifenv                166
+#define p_elifid                 167
+#define p_elifidn                168
+#define p_elifidni               169
+#define p_elifmacro              170
+#define p_elifnum                171
+#define p_elifstr                172
+#define p_eliftoken              173
+#define p_elifusable             174
+#define p_elifusing              175
+#define p_elifn                  176
+#define p_elifnctx               177
+#define p_elifndef               178
+#define p_elifndefalias          179
+#define p_elifndifi              180
+#define p_elifnempty             181
+#define p_elifnenv               182
+#define p_elifnid                183
+#define p_elifnidn               184
+#define p_elifnidni              185
+#define p_elifnmacro             186
+#define p_elifnnum               187
+#define p_elifnstr               188
+#define p_elifntoken             189
+#define p_elifnusable            190
+#define p_elifnusing             191
+#define p_aliases                192
+#define p_arg                    193
+#define p_clear                  194
+#define p_depend                 195
+#define p_else                   196
+#define p_endif                  197
+#define p_endm                   198
+#define p_endmacro               199
+#define p_endrep                 200
+#define p_error                  201
+#define p_exitmacro              202
+#define p_exitrep                203
+#define p_fatal                  204
+#define p_include                205
+#define p_line                   206
+#define p_local                  207
+#define p_null                   208
+#define p_pop                    209
+#define p_pragma                 210
+#define p_push                   211
+#define p_rep                    212
+#define p_repl                   213
+#define p_require                214
+#define p_rotate                 215
+#define p_stacksize              216
+#define p_undef                  217
+#define p_undefalias             218
+#define p_use                    219
+#define p_warning                220
+#define p_assign                 222
+#define p_iassign                223
+#define p_defalias               224
+#define p_idefalias              225
+#define p_define                 226
+#define p_idefine                227
+#define p_defstr                 228
+#define p_idefstr                229
+#define p_deftok                 230
+#define p_ideftok                231
+#define p_macro                  232
+#define p_imacro                 233
+#define p_pathsearch             234
+#define p_ipathsearch            235
+#define p_rmacro                 236
+#define p_irmacro                237
+#define p_strcat                 238
+#define p_istrcat                239
+#define p_strlen                 240
+#define p_istrlen                241
+#define p_substr                 242
+#define p_isubstr                243
+#define p_xdefine                244
+#define p_ixdefine               245
+#define p_unmacro                246
+#define p_unimacro               247
+#define EOL                      127
+
+
+#if 1
+const unsigned char nasm_stdmac_version[] = {
+    /* From version.mac */
+        /*    0 */ p_define,'_','_','?','N','A','S','M','_','M','A','J','O','R','?','_','_',' ','2',EOL,
+        /*   20 */ p_define,'_','_','?','N','A','S','M','_','M','I','N','O','R','?','_','_',' ','1','6',EOL,
+        /*   41 */ p_define,'_','_','?','N','A','S','M','_','S','U','B','M','I','N','O','R','?','_','_',' ','1',EOL,
+        /*   64 */ p_define,'_','_','?','N','A','S','M','_','P','A','T','C','H','L','E','V','E','L','?','_','_',' ','0',EOL,
+        /*   89 */ p_define,'_','_','?','N','A','S','M','_','V','E','R','S','I','O','N','_','I','D','?','_','_',' ','0','0','2','1','0','0','1','0','0','h',EOL,
+        /*  123 */ p_define,'_','_','?','N','A','S','M','_','V','E','R','?','_','_',' ','\"','2','.','1','6','.','0','1','\"',EOL,
+        /*  149 */ EOL
+};
+#endif
+
+#if 1
+static const unsigned char nasm_usemac_altreg[] = {
+    /* From ./macros/altreg.mac */
+        /*    0 */ p_define,'_','_','?','U','S','E','_','A','L','T','R','E','G','?','_','_',EOL,
+        /*    0 */ p_defalias,'_','_','U','S','E','_','A','L','T','R','E','G','_','_',' ','_','_','?','U','S','E','A','L','T','R','E','G','?','_','_',EOL,
+        /*   32 */ p_idefine,'r','8','l',' ','r','8','b',EOL,
+        /*   41 */ p_idefine,'r','9','l',' ','r','9','b',EOL,
+        /*   50 */ p_idefine,'r','1','0','l',' ','r','1','0','b',EOL,
+        /*   61 */ p_idefine,'r','1','1','l',' ','r','1','1','b',EOL,
+        /*   72 */ p_idefine,'r','1','2','l',' ','r','1','2','b',EOL,
+        /*   83 */ p_idefine,'r','1','3','l',' ','r','1','3','b',EOL,
+        /*   94 */ p_idefine,'r','1','4','l',' ','r','1','4','b',EOL,
+        /*  105 */ p_idefine,'r','1','5','l',' ','r','1','5','b',EOL,
+        /*  116 */ p_idefine,'r','0',' ','r','a','x',EOL,
+        /*  124 */ p_idefine,'r','1',' ','r','c','x',EOL,
+        /*  132 */ p_idefine,'r','2',' ','r','d','x',EOL,
+        /*  140 */ p_idefine,'r','3',' ','r','b','x',EOL,
+        /*  148 */ p_idefine,'r','4',' ','r','s','p',EOL,
+        /*  156 */ p_idefine,'r','5',' ','r','b','p',EOL,
+        /*  164 */ p_idefine,'r','6',' ','r','s','i',EOL,
+        /*  172 */ p_idefine,'r','7',' ','r','d','i',EOL,
+        /*  180 */ p_idefine,'r','0','d',' ','e','a','x',EOL,
+        /*  189 */ p_idefine,'r','1','d',' ','e','c','x',EOL,
+        /*  198 */ p_idefine,'r','2','d',' ','e','d','x',EOL,
+        /*  207 */ p_idefine,'r','3','d',' ','e','b','x',EOL,
+        /*  216 */ p_idefine,'r','4','d',' ','e','s','p',EOL,
+        /*  225 */ p_idefine,'r','5','d',' ','e','b','p',EOL,
+        /*  234 */ p_idefine,'r','6','d',' ','e','s','i',EOL,
+        /*  243 */ p_idefine,'r','7','d',' ','e','d','i',EOL,
+        /*  252 */ p_idefine,'r','0','w',' ','a','x',EOL,
+        /*  260 */ p_idefine,'r','1','w',' ','c','x',EOL,
+        /*  268 */ p_idefine,'r','2','w',' ','d','x',EOL,
+        /*  276 */ p_idefine,'r','3','w',' ','b','x',EOL,
+        /*  284 */ p_idefine,'r','4','w',' ','s','p',EOL,
+        /*  292 */ p_idefine,'r','5','w',' ','b','p',EOL,
+        /*  300 */ p_idefine,'r','6','w',' ','s','i',EOL,
+        /*  308 */ p_idefine,'r','7','w',' ','d','i',EOL,
+        /*  316 */ p_idefine,'r','0','b',' ','a','l',EOL,
+        /*  324 */ p_idefine,'r','1','b',' ','c','l',EOL,
+        /*  332 */ p_idefine,'r','2','b',' ','d','l',EOL,
+        /*  340 */ p_idefine,'r','3','b',' ','b','l',EOL,
+        /*  348 */ p_idefine,'r','4','b',' ','s','p','l',EOL,
+        /*  357 */ p_idefine,'r','5','b',' ','b','p','l',EOL,
+        /*  366 */ p_idefine,'r','6','b',' ','s','i','l',EOL,
+        /*  375 */ p_idefine,'r','7','b',' ','d','i','l',EOL,
+        /*  384 */ p_idefine,'r','0','l',' ','a','l',EOL,
+        /*  392 */ p_idefine,'r','1','l',' ','c','l',EOL,
+        /*  400 */ p_idefine,'r','2','l',' ','d','l',EOL,
+        /*  408 */ p_idefine,'r','3','l',' ','b','l',EOL,
+        /*  416 */ p_idefine,'r','4','l',' ','s','p','l',EOL,
+        /*  425 */ p_idefine,'r','5','l',' ','b','p','l',EOL,
+        /*  434 */ p_idefine,'r','6','l',' ','s','i','l',EOL,
+        /*  443 */ p_idefine,'r','7','l',' ','d','i','l',EOL,
+        /*  452 */ p_idefine,'r','0','h',' ','a','h',EOL,
+        /*  460 */ p_idefine,'r','1','h',' ','c','h',EOL,
+        /*  468 */ p_idefine,'r','2','h',' ','d','h',EOL,
+        /*  476 */ p_idefine,'r','3','h',' ','b','h',EOL,
+        /*  484 */ EOL
+};
+#endif
+
+#if 1
+static const unsigned char nasm_usemac_fp[] = {
+    /* From ./macros/fp.mac */
+        /*    0 */ p_define,'_','_','?','U','S','E','_','F','P','?','_','_',EOL,
+        /*    0 */ p_defalias,'_','_','U','S','E','_','F','P','_','_',' ','_','_','?','U','S','E','F','P','?','_','_',EOL,
+        /*   24 */ p_define,'I','n','f',' ','_','_','?','I','n','f','i','n','i','t','y','?','_','_',EOL,
+        /*   44 */ p_define,'N','a','N',' ','_','_','?','Q','N','a','N','?','_','_',EOL,
+        /*   60 */ p_define,'Q','N','a','N',' ','_','_','?','Q','N','a','N','?','_','_',EOL,
+        /*   77 */ p_define,'S','N','a','N',' ','_','_','?','S','N','a','N','?','_','_',EOL,
+        /*   94 */ p_define,'f','l','o','a','t','8','(','x',')',' ','_','_','?','f','l','o','a','t','8','?','_','_','(','x',')',EOL,
+        /*  121 */ p_define,'f','l','o','a','t','1','6','(','x',')',' ','_','_','?','f','l','o','a','t','1','6','?','_','_','(','x',')',EOL,
+        /*  150 */ p_define,'b','f','l','o','a','t','1','6','(','x',')',' ','_','_','?','b','f','l','o','a','t','1','6','?','_','_','(','x',')',EOL,
+        /*  181 */ p_define,'f','l','o','a','t','3','2','(','x',')',' ','_','_','?','f','l','o','a','t','3','2','?','_','_','(','x',')',EOL,
+        /*  210 */ p_define,'f','l','o','a','t','6','4','(','x',')',' ','_','_','?','f','l','o','a','t','6','4','?','_','_','(','x',')',EOL,
+        /*  239 */ p_define,'f','l','o','a','t','8','0','m','(','x',')',' ','_','_','?','f','l','o','a','t','8','0','m','?','_','_','(','x',')',EOL,
+        /*  270 */ p_define,'f','l','o','a','t','8','0','e','(','x',')',' ','_','_','?','f','l','o','a','t','8','0','e','?','_','_','(','x',')',EOL,
+        /*  301 */ p_define,'f','l','o','a','t','1','2','8','l','(','x',')',' ','_','_','?','f','l','o','a','t','1','2','8','l','?','_','_','(','x',')',EOL,
+        /*  334 */ p_define,'f','l','o','a','t','1','2','8','h','(','x',')',' ','_','_','?','f','l','o','a','t','1','2','8','h','?','_','_','(','x',')',EOL,
+        /*  367 */ p_imacro,'b','f','1','6',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /*  384 */ p_rep,'%','0',EOL,
+        /*  388 */ 'd','w',' ','_','_','?','b','f','l','o','a','t','1','6','?','_','_','(','%','1',')',EOL,
+        /*  410 */ p_rotate,'1',EOL,
+        /*  413 */ p_endrep,EOL,
+        /*  415 */ p_endmacro,EOL,
+        /*  417 */ EOL
+};
+#endif
+
+#if 1
+static const unsigned char nasm_usemac_ifunc[] = {
+    /* From ./macros/ifunc.mac */
+        /*    0 */ p_define,'_','_','?','U','S','E','_','I','F','U','N','C','?','_','_',EOL,
+        /*    0 */ p_defalias,'_','_','U','S','E','_','I','F','U','N','C','_','_',' ','_','_','?','U','S','E','I','F','U','N','C','?','_','_',EOL,
+        /*   30 */ p_idefine,'i','l','o','g','2','(','x',')',' ','(','_','_','?','i','l','o','g','2','e','?','_','_','(','x',')',')',EOL,
+        /*   58 */ p_idefine,'i','l','o','g','2','e','(','x',')',' ','(','_','_','?','i','l','o','g','2','e','?','_','_','(','x',')',')',EOL,
+        /*   87 */ p_idefine,'i','l','o','g','2','w','(','x',')',' ','(','_','_','?','i','l','o','g','2','w','?','_','_','(','x',')',')',EOL,
+        /*  116 */ p_idefine,'i','l','o','g','2','f','w','(','x',')',' ','(','_','_','?','i','l','o','g','2','w','?','_','_','(','x',')',')',EOL,
+        /*  146 */ p_idefine,'i','l','o','g','2','f','(','x',')',' ','(','_','_','?','i','l','o','g','2','f','?','_','_','(','x',')',')',EOL,
+        /*  175 */ p_idefine,'i','l','o','g','2','c','w','(','x',')',' ','(','_','_','?','i','l','o','g','2','w','?','_','_','(','x',')',' ','*',' ','0',' ','+',' ','_','_','?','i','l','o','g','2','c','?','_','_','(','x',')',')',EOL,
+        /*  227 */ p_idefine,'i','l','o','g','2','c','(','x',')',' ','(','_','_','?','i','l','o','g','2','c','?','_','_','(','x',')',')',EOL,
+        /*  256 */ EOL
+};
+#endif
+
+#if 1
+static const unsigned char nasm_usemac_masm[] = {
+    /* From ./macros/masm.mac */
+        /*    0 */ p_define,'_','_','?','U','S','E','_','M','A','S','M','?','_','_',EOL,
+        /*    0 */ p_defalias,'_','_','U','S','E','_','M','A','S','M','_','_',' ','_','_','?','U','S','E','M','A','S','M','?','_','_',EOL,
+        /*   28 */ p_unimacro,'s','e','g','m','e','n','t',' ','1','+',EOL,
+        /*   40 */ p_imacro,'s','e','g','m','e','n','t',' ','0','-','1','+','.','n','o','l','i','s','t',EOL,
+        /*   61 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','g','m','e','n','t',' ','%','0','0',' ','%','1',']',EOL,
+        /*   90 */ '_','_','?','S','E','C','T','?','_','_',EOL,
+        /*  101 */ p_endmacro,EOL,
+        /*  103 */ p_imacro,'e','n','d','s',' ','0','+','.','n','o','l','i','s','t',EOL,
+        /*  119 */ p_null,'e','n','d','s',' ','%','0','0',EOL,
+        /*  129 */ p_endmacro,EOL,
+        /*  131 */ p_imacro,'p','r','o','c',' ','0','-','*','.','n','o','l','i','s','t',EOL,
+        /*  148 */ p_rep,'%','0',EOL,
+        /*  152 */ p_ifidni,'%','1',',','f','a','r',EOL,
+        /*  160 */ p_idefine,'r','e','t',' ','r','e','t','f',EOL,
+        /*  170 */ p_else,EOL,
+        /*  172 */ p_idefine,'r','e','t',' ','r','e','t','n',EOL,
+        /*  182 */ p_endif,EOL,
+        /*  184 */ p_rotate,'1',EOL,
+        /*  187 */ p_endrep,EOL,
+        /*  189 */ p_endmacro,EOL,
+        /*  191 */ p_imacro,'e','n','d','p',' ','0','.','n','o','l','i','s','t',EOL,
+        /*  206 */ p_null,'e','n','d','p',' ','%','0','0',EOL,
+        /*  216 */ p_undef,'r','e','t',EOL,
+        /*  221 */ p_endmacro,EOL,
+        /*  223 */ p_idefine,'p','t','r',' ','_','_','?','m','a','s','m','_','p','t','r','?','_','_',EOL,
+        /*  243 */ p_idefine,'f','l','a','t',' ','_','_','?','m','a','s','m','_','f','l','a','t','?','_','_',EOL,
+        /*  265 */ p_idefine,'o','f','f','s','e','t',EOL,
+        /*  273 */ p_imacro,'e','n','d',' ','0','+','.','n','o','l','i','s','t',EOL,
+        /*  288 */ p_endmacro,EOL,
+        /*  290 */ p_idefine,'t','b','y','t','e',' ','t','w','o','r','d',EOL,
+        /*  303 */ 'd','e','f','a','u','l','t',' ','r','e','l',EOL,
+        /*  315 */ EOL
+};
+#endif
+
+#if 1
+static const unsigned char nasm_usemac_smartalign[] = {
+    /* From ./macros/smartalign.mac */
+        /*    0 */ p_define,'_','_','?','U','S','E','_','S','M','A','R','T','A','L','I','G','N','?','_','_',EOL,
+        /*    0 */ p_defalias,'_','_','U','S','E','_','S','M','A','R','T','A','L','I','G','N','_','_',' ','_','_','?','U','S','E','S','M','A','R','T','A','L','I','G','N','?','_','_',EOL,
+        /*   40 */ p_imacro,'a','l','i','g','n','m','o','d','e',' ','1','-','2','.','n','o','l','i','s','t',EOL,
+        /*   62 */ p_ifidni,'%','1',',','n','o','p',EOL,
+        /*   70 */ p_define,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','1','6',EOL,
+        /*  100 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /*  127 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','G','R','O','U','P','?','_','_',' ','1',EOL,
+        /*  154 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /*  181 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','G','R','O','U','P','?','_','_',' ','1',EOL,
+        /*  208 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /*  235 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','G','R','O','U','P','?','_','_',' ','1',EOL,
+        /*  262 */ p_elifidni,'%','1',',','g','e','n','e','r','i','c',EOL,
+        /*  274 */ p_define,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','8',EOL,
+        /*  303 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /*  330 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','2','B','?','_','_',' ','0','x','8','9',',','0','x','f','6',EOL,
+        /*  362 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','3','B','?','_','_',' ','0','x','8','d',',','0','x','7','4',',','0','x','0','0',EOL,
+        /*  399 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','4','B','?','_','_',' ','0','x','8','d',',','0','x','b','4',',','0','x','0','0',',','0','x','0','0',EOL,
+        /*  441 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','5','B','?','_','_',' ','0','x','8','d',',','0','x','b','4',',','0','x','0','0',',','0','x','0','0',',','0','x','9','0',EOL,
+        /*  488 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','6','B','?','_','_',' ','0','x','8','d',',','0','x','b','4',',','0','x','0','0',',','0','x','0','0',',','0','x','8','9',',','0','x','f','f',EOL,
+        /*  540 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','7','B','?','_','_',' ','0','x','8','d',',','0','x','b','4',',','0','x','0','0',',','0','x','0','0',',','0','x','8','d',',','0','x','7','d',',','0','x','0','0',EOL,
+        /*  597 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','8','B','?','_','_',' ','0','x','8','d',',','0','x','b','4',',','0','x','0','0',',','0','x','0','0',',','0','x','8','d',',','0','x','b','d',',','0','x','0','0',',','0','x','0','0',EOL,
+        /*  659 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','G','R','O','U','P','?','_','_',' ','8',EOL,
+        /*  686 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /*  713 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','2','B','?','_','_',' ','0','x','8','9',',','0','x','f','6',EOL,
+        /*  745 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','3','B','?','_','_',' ','0','x','8','d',',','0','x','7','6',',','0','x','0','0',EOL,
+        /*  782 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','4','B','?','_','_',' ','0','x','8','d',',','0','x','7','4',',','0','x','2','6',',','0','x','0','0',EOL,
+        /*  824 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','5','B','?','_','_',' ','0','x','9','0',',','0','x','8','d',',','0','x','7','4',',','0','x','2','6',',','0','x','0','0',EOL,
+        /*  871 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','6','B','?','_','_',' ','0','x','8','d',',','0','x','b','6',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /*  923 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','7','B','?','_','_',' ','0','x','8','d',',','0','x','b','4',',','0','x','2','6',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /*  980 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','G','R','O','U','P','?','_','_',' ','7',EOL,
+        /* 1007 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 1034 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1066 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','3','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1103 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','4','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1145 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 1172 */ p_elifidni,'%','1',',','k','8',EOL,
+        /* 1179 */ p_define,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','1','6',EOL,
+        /* 1209 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 1236 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1268 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','3','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1305 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','4','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1347 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 1374 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 1401 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1433 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','3','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1470 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','4','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1512 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 1539 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 1566 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1598 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','3','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1635 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','4','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1677 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 1704 */ p_elifidni,'%','1',',','k','7',EOL,
+        /* 1711 */ p_define,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','1','6',EOL,
+        /* 1741 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 1768 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1800 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','3','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1837 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','4','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 1879 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 1906 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 1933 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','2','B','?','_','_',' ','0','x','8','b',',','0','x','c','0',EOL,
+        /* 1965 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','3','B','?','_','_',' ','0','x','8','d',',','0','x','0','4',',','0','x','2','0',EOL,
+        /* 2002 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','4','B','?','_','_',' ','0','x','8','d',',','0','x','4','4',',','0','x','2','0',',','0','x','0','0',EOL,
+        /* 2044 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','5','B','?','_','_',' ','0','x','8','d',',','0','x','4','4',',','0','x','2','0',',','0','x','0','0',',','0','x','9','0',EOL,
+        /* 2091 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','6','B','?','_','_',' ','0','x','8','d',',','0','x','8','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 2143 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','7','B','?','_','_',' ','0','x','8','d',',','0','x','0','4',',','0','x','0','5',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 2200 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','G','R','O','U','P','?','_','_',' ','7',EOL,
+        /* 2227 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 2254 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 2286 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','3','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 2323 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','4','B','?','_','_',' ','0','x','6','6',',','0','x','6','6',',','0','x','6','6',',','0','x','9','0',EOL,
+        /* 2365 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 2392 */ p_elifidni,'%','1',',','p','6',EOL,
+        /* 2399 */ p_define,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','1','6',EOL,
+        /* 2429 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 2456 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 2488 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','3','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','0','0',EOL,
+        /* 2525 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','4','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','4','0',',','0','x','0','0',EOL,
+        /* 2567 */ p_define,'_','_','?','A','L','I','G','N','_','1','6','B','I','T','_','G','R','O','U','P','?','_','_',' ','4',EOL,
+        /* 2594 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 2621 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 2653 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','3','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','0','0',EOL,
+        /* 2690 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','4','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','4','0',',','0','x','0','0',EOL,
+        /* 2732 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','5','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','4','4',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 2779 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','6','B','?','_','_',' ','0','x','6','6',',','0','x','0','f',',','0','x','1','f',',','0','x','4','4',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 2831 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','7','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','8','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 2888 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','8','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','8','4',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 2950 */ p_define,'_','_','?','A','L','I','G','N','_','3','2','B','I','T','_','G','R','O','U','P','?','_','_',' ','8',EOL,
+        /* 2977 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','1','B','?','_','_',' ','0','x','9','0',EOL,
+        /* 3004 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','2','B','?','_','_',' ','0','x','6','6',',','0','x','9','0',EOL,
+        /* 3036 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','3','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','0','0',EOL,
+        /* 3073 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','4','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','4','0',',','0','x','0','0',EOL,
+        /* 3115 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','5','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','4','4',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 3162 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','6','B','?','_','_',' ','0','x','6','6',',','0','x','0','f',',','0','x','1','f',',','0','x','4','4',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 3214 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','7','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','8','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 3271 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','8','B','?','_','_',' ','0','x','0','f',',','0','x','1','f',',','0','x','8','4',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',',','0','x','0','0',EOL,
+        /* 3333 */ p_define,'_','_','?','A','L','I','G','N','_','6','4','B','I','T','_','G','R','O','U','P','?','_','_',' ','8',EOL,
+        /* 3360 */ p_else,EOL,
+        /* 3362 */ p_error,'u','n','k','n','o','w','n',' ','a','l','i','g','n','m','e','n','t',' ','m','o','d','e',':',' ','%','1',EOL,
+        /* 3390 */ p_endif,EOL,
+        /* 3392 */ p_ifnempty,'%','2',EOL,
+        /* 3396 */ p_ifidni,'%','2',',','n','o','j','m','p',EOL,
+        /* 3406 */ p_xdefine,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','-','1',EOL,
+        /* 3436 */ p_else,EOL,
+        /* 3438 */ p_xdefine,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','%','2',EOL,
+        /* 3468 */ p_endif,EOL,
+        /* 3470 */ p_endif,EOL,
+        /* 3472 */ p_xdefine,'_','_','?','A','L','I','G','N','M','O','D','E','?','_','_',' ','%','1',',','_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',EOL,
+        /* 3518 */ p_endmacro,EOL,
+        /* 3520 */ p_defalias,'_','_','A','L','I','G','N','M','O','D','E','_','_',' ','_','_','?','A','L','I','G','N','M','O','D','E','?','_','_',EOL,
+        /* 3551 */ p_unimacro,'a','l','i','g','n',' ','1','-','2','+','.','n','o','l','i','s','t',EOL,
+        /* 3570 */ p_imacro,'a','l','i','g','n',' ','1','-','2','+','.','n','o','l','i','s','t',EOL,
+        /* 3589 */ 's','e','c','t','a','l','i','g','n',' ','%','1',EOL,
+        /* 3602 */ p_ifnempty,'%','2',EOL,
+        /* 3606 */ 't','i','m','e','s',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',' ','%','2',EOL,
+        /* 3649 */ p_elif,'_','_','?','P','A','S','S','?','_','_',' ','=','=',' ','0',' ','|','|',' ','_','_','?','P','A','S','S','?','_','_',' ','=','=',' ','3',EOL,
+        /* 3685 */ 't','i','m','e','s',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',' ','n','o','p',EOL,
+        /* 3729 */ p_else,EOL,
+        /* 3731 */ p_push,EOL,
+        /* 3733 */ p_assign,'%','$','p','a','d',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',EOL,
+        /* 3774 */ p_if,'_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',' ','!','=',' ','-','1',' ','&','&',' ','%','$','p','a','d',' ','>',' ','_','_','?','A','L','I','G','N','_','J','M','P','_','T','H','R','E','S','H','O','L','D','?','_','_',EOL,
+        /* 3844 */ 'j','m','p',' ','%','$','e','n','d',EOL,
+        /* 3854 */ 't','i','m','e','s',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',' ','n','o','p',EOL,
+        /* 3898 */ p_else,EOL,
+        /* 3900 */ 't','i','m','e','s',' ','(','%','$','p','a','d',' ','/',' ','_','_','?','A','L','I','G','N','_','%','[','_','_','?','B','I','T','S','?','_','_',']','B','I','T','_','G','R','O','U','P','?','_','_',')',' ','d','b',' ','_','_','?','A','L','I','G','N','_','%','[','_','_','?','B','I','T','S','?','_','_',']','B','I','T','_','%','[','_','_','?','A','L','I','G','N','_','%','[','_','_','?','B','I','T','S','?','_','_',']','B','I','T','_','G','R','O','U','P','?','_','_',']','B','?','_','_',EOL,
+        /* 4022 */ p_assign,'%','$','p','a','d',' ','%','$','p','a','d',' ','%',' ','_','_','?','A','L','I','G','N','_','%','[','_','_','?','B','I','T','S','?','_','_',']','B','I','T','_','G','R','O','U','P','?','_','_',EOL,
+        /* 4072 */ p_if,'%','$','p','a','d',' ','>',' ','0',EOL,
+        /* 4083 */ 'd','b',' ','_','_','?','A','L','I','G','N','_','%','[','_','_','?','B','I','T','S','?','_','_',']','B','I','T','_','%','[','%','$','p','a','d',']','B','?','_','_',EOL,
+        /* 4125 */ p_endif,EOL,
+        /* 4127 */ p_endif,EOL,
+        /* 4129 */ '%','$','e','n','d',':',EOL,
+        /* 4136 */ p_pop,EOL,
+        /* 4138 */ p_endif,EOL,
+        /* 4140 */ p_endmacro,EOL,
+        /* 4142 */ 'a','l','i','g','n','m','o','d','e',' ','g','e','n','e','r','i','c',EOL,
+        /* 4160 */ EOL
+};
+#endif
+
+#if 1
+const unsigned char nasm_stdmac_tasm[] = {
+    /* From ./macros/standard.mac */
+        /*    0 */ p_idefine,'I','D','E','A','L',EOL,
+        /*    7 */ p_idefine,'J','U','M','P','S',EOL,
+        /*   14 */ p_idefine,'P','3','8','6',EOL,
+        /*   20 */ p_idefine,'P','4','8','6',EOL,
+        /*   26 */ p_idefine,'P','5','8','6',EOL,
+        /*   32 */ p_idefine,'E','N','D',EOL,
+        /*   37 */ EOL
+};
+#endif
+
+#if 1
+const unsigned char nasm_stdmac_nasm[] = {
+    /* From ./macros/standard.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',EOL,
+        /*   12 */ p_defalias,'_','_','S','E','C','T','_','_',' ','_','_','?','S','E','C','T','?','_','_',EOL,
+        /*   33 */ p_imacro,'s','e','c','t','i','o','n',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*   52 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','%','1',']',EOL,
+        /*   77 */ '_','_','?','S','E','C','T','?','_','_',EOL,
+        /*   88 */ p_endmacro,EOL,
+        /*   90 */ p_imacro,'s','e','g','m','e','n','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  109 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','g','m','e','n','t',' ','%','1',']',EOL,
+        /*  134 */ '_','_','?','S','E','C','T','?','_','_',EOL,
+        /*  145 */ p_endmacro,EOL,
+        /*  147 */ p_define,'_','_','?','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','?','_','_',' ','1',EOL,
+        /*  188 */ p_imacro,'s','e','c','t','a','l','i','g','n',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  209 */ p_ifidni,'%','1',',','o','f','f',EOL,
+        /*  217 */ p_define,'_','_','?','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','?','_','_',' ','0',EOL,
+        /*  258 */ p_elifidni,'%','1',',','o','n',EOL,
+        /*  265 */ p_define,'_','_','?','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','?','_','_',' ','1',EOL,
+        /*  306 */ p_else,EOL,
+        /*  308 */ '[','s','e','c','t','a','l','i','g','n',' ','%','1',']',EOL,
+        /*  323 */ p_endif,EOL,
+        /*  325 */ p_endmacro,EOL,
+        /*  327 */ p_defalias,'_','_','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','_','_',' ','_','_','?','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','?','_','_',EOL,
+        /*  402 */ p_imacro,'a','b','s','o','l','u','t','e',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  422 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','a','b','s','o','l','u','t','e',' ','%','1',']',EOL,
+        /*  448 */ '_','_','?','S','E','C','T','?','_','_',EOL,
+        /*  459 */ p_endmacro,EOL,
+        /*  461 */ p_imacro,'s','t','r','u','c',' ','1','-','2','.','n','o','l','i','s','t',' ','0',EOL,
+        /*  481 */ p_push,EOL,
+        /*  483 */ p_define,'%','$','s','t','r','u','c','n','a','m','e',' ','%','1',EOL,
+        /*  499 */ '[','a','b','s','o','l','u','t','e',' ','%','2',']',EOL,
+        /*  513 */ '%','$','s','t','r','u','c','n','a','m','e',':',EOL,
+        /*  526 */ p_endmacro,EOL,
+        /*  528 */ p_imacro,'e','n','d','s','t','r','u','c',' ','0','.','n','o','l','i','s','t',EOL,
+        /*  547 */ '%','{','$','s','t','r','u','c','n','a','m','e','}','_','s','i','z','e',' ','e','q','u',' ','(','$','-','%','$','s','t','r','u','c','n','a','m','e',')',EOL,
+        /*  586 */ p_pop,EOL,
+        /*  588 */ '_','_','?','S','E','C','T','?','_','_',EOL,
+        /*  599 */ p_endmacro,EOL,
+        /*  601 */ p_imacro,'i','s','t','r','u','c',' ','1','.','n','o','l','i','s','t',EOL,
+        /*  618 */ p_push,EOL,
+        /*  620 */ p_define,'%','$','s','t','r','u','c','n','a','m','e',' ','%','1',EOL,
+        /*  636 */ '%','$','s','t','r','u','c','s','t','a','r','t',':',EOL,
+        /*  650 */ p_endmacro,EOL,
+        /*  652 */ p_imacro,'a','t',' ','1','-','2','+','.','n','o','l','i','s','t',EOL,
+        /*  668 */ p_defstr,'%','$','m','e','m','b','e','r',' ','%','1',EOL,
+        /*  681 */ p_substr,'%','$','m','e','m','b','e','r','1',' ','%','$','m','e','m','b','e','r',' ','1',EOL,
+        /*  703 */ p_ifidn,'%','$','m','e','m','b','e','r','1',',',' ','\'','.','\'',EOL,
+        /*  719 */ 't','i','m','e','s',' ','(','%','$','s','t','r','u','c','n','a','m','e','%','1','-','%','$','s','t','r','u','c','n','a','m','e',')','-','(','$','-','%','$','s','t','r','u','c','s','t','a','r','t',')',' ','d','b',' ','0',EOL,
+        /*  775 */ p_else,EOL,
+        /*  777 */ 't','i','m','e','s',' ','(','%','1','-','%','$','s','t','r','u','c','n','a','m','e',')','-','(','$','-','%','$','s','t','r','u','c','s','t','a','r','t',')',' ','d','b',' ','0',EOL,
+        /*  822 */ p_endif,EOL,
+        /*  824 */ '%','2',EOL,
+        /*  827 */ p_endmacro,EOL,
+        /*  829 */ p_imacro,'i','e','n','d',' ','0','.','n','o','l','i','s','t',EOL,
+        /*  844 */ 't','i','m','e','s',' ','%','{','$','s','t','r','u','c','n','a','m','e','}','_','s','i','z','e','-','(','$','-','%','$','s','t','r','u','c','s','t','a','r','t',')',' ','d','b',' ','0',EOL,
+        /*  891 */ p_pop,EOL,
+        /*  893 */ p_endmacro,EOL,
+        /*  895 */ p_imacro,'a','l','i','g','n',' ','1','-','2','+','.','n','o','l','i','s','t',' ','n','o','p',EOL,
+        /*  918 */ p_if,'_','_','?','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','?','_','_',EOL,
+        /*  957 */ 's','e','c','t','a','l','i','g','n',' ','%','1',EOL,
+        /*  970 */ p_endif,EOL,
+        /*  972 */ 't','i','m','e','s',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',' ','%','2',EOL,
+        /* 1015 */ p_endmacro,EOL,
+        /* 1017 */ p_imacro,'a','l','i','g','n','b',' ','1','-','2','+','.','n','o','l','i','s','t',EOL,
+        /* 1037 */ p_if,'_','_','?','S','E','C','T','A','L','I','G','N','_','A','L','I','G','N','_','U','P','D','A','T','E','S','_','S','E','C','T','I','O','N','?','_','_',EOL,
+        /* 1076 */ 's','e','c','t','a','l','i','g','n',' ','%','1',EOL,
+        /* 1089 */ p_endif,EOL,
+        /* 1091 */ p_ifempty,'%','2',EOL,
+        /* 1095 */ '[','w','a','r','n','i','n','g',' ','p','u','s','h',']',EOL,
+        /* 1110 */ '[','w','a','r','n','i','n','g',' ','-','z','e','r','o','i','n','g',']',EOL,
+        /* 1129 */ 'r','e','s','b',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',EOL,
+        /* 1168 */ '[','w','a','r','n','i','n','g',' ','p','o','p',']',EOL,
+        /* 1182 */ p_else,EOL,
+        /* 1184 */ 't','i','m','e','s',' ','(','(','(','%','1',')',' ','-',' ','(','(','$','-','$','$',')',' ','%',' ','(','%','1',')',')',')',' ','%',' ','(','%','1',')',')',' ','%','2',EOL,
+        /* 1227 */ p_endif,EOL,
+        /* 1229 */ p_endmacro,EOL,
+        /* 1231 */ p_imacro,'b','i','t','s',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /* 1247 */ '[','b','i','t','s',' ','%','1',']',EOL,
+        /* 1257 */ p_endmacro,EOL,
+        /* 1259 */ p_imacro,'u','s','e','1','6',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 1275 */ '[','b','i','t','s',' ','1','6',']',EOL,
+        /* 1285 */ p_endmacro,EOL,
+        /* 1287 */ p_imacro,'u','s','e','3','2',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 1303 */ '[','b','i','t','s',' ','3','2',']',EOL,
+        /* 1313 */ p_endmacro,EOL,
+        /* 1315 */ p_imacro,'u','s','e','6','4',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 1331 */ '[','b','i','t','s',' ','6','4',']',EOL,
+        /* 1341 */ p_endmacro,EOL,
+        /* 1343 */ p_imacro,'e','x','t','e','r','n',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /* 1362 */ p_rep,'%','0',EOL,
+        /* 1366 */ '[','e','x','t','e','r','n',' ','%','1',']',EOL,
+        /* 1378 */ p_rotate,'1',EOL,
+        /* 1381 */ p_endrep,EOL,
+        /* 1383 */ p_endmacro,EOL,
+        /* 1385 */ p_imacro,'s','t','a','t','i','c',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /* 1404 */ p_rep,'%','0',EOL,
+        /* 1408 */ '[','s','t','a','t','i','c',' ','%','1',']',EOL,
+        /* 1420 */ p_rotate,'1',EOL,
+        /* 1423 */ p_endrep,EOL,
+        /* 1425 */ p_endmacro,EOL,
+        /* 1427 */ p_imacro,'g','l','o','b','a','l',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /* 1446 */ p_rep,'%','0',EOL,
+        /* 1450 */ '[','g','l','o','b','a','l',' ','%','1',']',EOL,
+        /* 1462 */ p_rotate,'1',EOL,
+        /* 1465 */ p_endrep,EOL,
+        /* 1467 */ p_endmacro,EOL,
+        /* 1469 */ p_imacro,'r','e','q','u','i','r','e','d',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /* 1490 */ p_rep,'%','0',EOL,
+        /* 1494 */ '[','r','e','q','u','i','r','e','d',' ','%','1',']',EOL,
+        /* 1508 */ p_rotate,'1',EOL,
+        /* 1511 */ p_endrep,EOL,
+        /* 1513 */ p_endmacro,EOL,
+        /* 1515 */ p_imacro,'c','o','m','m','o','n',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /* 1534 */ p_rep,'%','0',EOL,
+        /* 1538 */ '[','c','o','m','m','o','n',' ','%','1',']',EOL,
+        /* 1550 */ p_rotate,'1',EOL,
+        /* 1553 */ p_endrep,EOL,
+        /* 1555 */ p_endmacro,EOL,
+        /* 1557 */ p_imacro,'c','p','u',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /* 1572 */ '[','c','p','u',' ','%','1',']',EOL,
+        /* 1581 */ p_endmacro,EOL,
+        /* 1583 */ p_define,'_','_','?','F','L','O','A','T','_','D','A','Z','?','_','_',' ','n','o','d','a','z',EOL,
+        /* 1606 */ p_define,'_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',' ','n','e','a','r',EOL,
+        /* 1630 */ p_define,'_','_','?','F','L','O','A','T','?','_','_',' ','_','_','?','F','L','O','A','T','_','D','A','Z','?','_','_',',','_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',EOL,
+        /* 1677 */ p_defalias,'_','_','F','L','O','A','T','_','D','A','Z','_','_',' ','_','_','?','F','L','O','A','T','_','D','A','Z','?','_','_',EOL,
+        /* 1708 */ p_defalias,'_','_','F','L','O','A','T','_','R','O','U','N','D','_','_',' ','_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',EOL,
+        /* 1743 */ p_defalias,'_','_','F','L','O','A','T','_','_',' ','_','_','?','F','L','O','A','T','?','_','_',EOL,
+        /* 1766 */ p_imacro,'f','l','o','a','t',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /* 1784 */ p_rep,'%','0',EOL,
+        /* 1788 */ '[','f','l','o','a','t',' ','%','1',']',EOL,
+        /* 1799 */ p_ifidni,'%','1',',','d','a','z',EOL,
+        /* 1807 */ p_define,'_','_','?','F','L','O','A','T','_','D','A','Z','?','_','_',' ','d','a','z',EOL,
+        /* 1828 */ p_elifidni,'%','1',',','n','o','d','a','z',EOL,
+        /* 1838 */ p_define,'_','_','?','F','L','O','A','T','_','D','A','Z','?','_','_',' ','n','o','d','a','z',EOL,
+        /* 1861 */ p_elifidni,'%','1',',','n','e','a','r',EOL,
+        /* 1870 */ p_define,'_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',' ','n','e','a','r',EOL,
+        /* 1894 */ p_elifidni,'%','1',',','u','p',EOL,
+        /* 1901 */ p_define,'_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',' ','u','p',EOL,
+        /* 1923 */ p_elifidni,'%','1',',','d','o','w','n',EOL,
+        /* 1932 */ p_define,'_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',' ','d','o','w','n',EOL,
+        /* 1956 */ p_elifidni,'%','1',',','z','e','r','o',EOL,
+        /* 1965 */ p_define,'_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',' ','z','e','r','o',EOL,
+        /* 1989 */ p_elifidni,'%','1',',','d','e','f','a','u','l','t',EOL,
+        /* 2001 */ p_define,'_','_','?','F','L','O','A','T','_','D','A','Z','?','_','_',' ','n','o','d','a','z',EOL,
+        /* 2024 */ p_define,'_','_','?','F','L','O','A','T','_','R','O','U','N','D','?','_','_',' ','n','e','a','r',EOL,
+        /* 2048 */ p_endif,EOL,
+        /* 2050 */ p_rotate,'1',EOL,
+        /* 2053 */ p_endrep,EOL,
+        /* 2055 */ p_endmacro,EOL,
+        /* 2057 */ p_imacro,'d','e','f','a','u','l','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /* 2076 */ '[','d','e','f','a','u','l','t',' ','%','1',']',EOL,
+        /* 2089 */ p_endmacro,EOL,
+        /* 2091 */ p_imacro,'u','s','e','r','e','l',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 2108 */ '[','d','e','f','a','u','l','t',' ','r','e','l',']',EOL,
+        /* 2122 */ p_endmacro,EOL,
+        /* 2124 */ p_imacro,'u','s','e','a','b','s',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 2141 */ '[','d','e','f','a','u','l','t',' ','a','b','s',']',EOL,
+        /* 2155 */ p_endmacro,EOL,
+        /* 2157 */ p_imacro,'u','s','e','b','n','d',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 2174 */ '[','d','e','f','a','u','l','t',' ','b','n','d',']',EOL,
+        /* 2188 */ p_endmacro,EOL,
+        /* 2190 */ p_imacro,'u','s','e','n','o','b','n','d',' ','0','.','n','o','l','i','s','t',EOL,
+        /* 2209 */ '[','d','e','f','a','u','l','t',' ','n','o','b','n','d',']',EOL,
+        /* 2225 */ p_endmacro,EOL,
+        /* 2227 */ p_imacro,'i','n','c','b','i','n',' ','1','-','2','+','.','n','o','l','i','s','t',' ','0',EOL,
+        /* 2249 */ p_push,EOL,
+        /* 2251 */ p_pathsearch,'%','$','d','e','p',' ','%','1',EOL,
+        /* 2261 */ p_depend,'%','$','d','e','p',EOL,
+        /* 2268 */ '%','?',' ','%','$','d','e','p',',','%','2',EOL,
+        /* 2280 */ p_pop,EOL,
+        /* 2282 */ p_endmacro,EOL,
+        /* 2284 */ p_defalias,'_','_','N','A','S','M','_','M','A','J','O','R','_','_',' ','_','_','?','N','A','S','M','_','M','A','J','O','R','?','_','_',EOL,
+        /* 2317 */ p_defalias,'_','_','N','A','S','M','_','M','I','N','O','R','_','_',' ','_','_','?','N','A','S','M','_','M','I','N','O','R','?','_','_',EOL,
+        /* 2350 */ p_defalias,'_','_','N','A','S','M','_','S','U','B','M','I','N','O','R','_','_',' ','_','_','?','N','A','S','M','_','S','U','B','M','I','N','O','R','?','_','_',EOL,
+        /* 2389 */ p_defalias,'_','_','N','A','S','M','_','P','A','T','C','H','L','E','V','E','L','_','_',' ','_','_','?','N','A','S','M','_','P','A','T','C','H','L','E','V','E','L','?','_','_',EOL,
+        /* 2432 */ p_defalias,'_','_','N','A','S','M','_','S','N','A','P','S','H','O','T','_','_',' ','_','_','?','N','A','S','M','_','S','N','A','P','S','H','O','T','?','_','_',EOL,
+        /* 2471 */ p_defalias,'_','_','N','A','S','M','_','V','E','R','S','I','O','N','_','I','D','_','_',' ','_','_','?','N','A','S','M','_','V','E','R','S','I','O','N','_','I','D','?','_','_',EOL,
+        /* 2514 */ p_defalias,'_','_','N','A','S','M','_','V','E','R','_','_',' ','_','_','?','N','A','S','M','_','V','E','R','?','_','_',EOL,
+        /* 2543 */ p_defalias,'_','_','O','U','T','P','U','T','_','F','O','R','M','A','T','_','_',' ','_','_','?','O','U','T','P','U','T','_','F','O','R','M','A','T','?','_','_',EOL,
+        /* 2582 */ p_defalias,'_','_','D','E','B','U','G','_','F','O','R','M','A','T','_','_',' ','_','_','?','D','E','B','U','G','_','F','O','R','M','A','T','?','_','_',EOL,
+        /* 2619 */ p_defalias,'_','_','D','A','T','E','_','_',' ','_','_','?','D','A','T','E','?','_','_',EOL,
+        /* 2640 */ p_defalias,'_','_','D','A','T','E','_','N','U','M','_','_',' ','_','_','?','D','A','T','E','_','N','U','M','?','_','_',EOL,
+        /* 2669 */ p_defalias,'_','_','T','I','M','E','_','_',' ','_','_','?','T','I','M','E','?','_','_',EOL,
+        /* 2690 */ p_defalias,'_','_','T','I','M','E','_','N','U','M','_','_',' ','_','_','?','T','I','M','E','_','N','U','M','?','_','_',EOL,
+        /* 2719 */ p_defalias,'_','_','U','T','C','_','D','A','T','E','_','_',' ','_','_','?','U','T','C','_','D','A','T','E','?','_','_',EOL,
+        /* 2748 */ p_defalias,'_','_','U','T','C','_','D','A','T','E','_','N','U','M','_','_',' ','_','_','?','U','T','C','_','D','A','T','E','_','N','U','M','?','_','_',EOL,
+        /* 2785 */ p_defalias,'_','_','U','T','C','_','T','I','M','E','_','_',' ','_','_','?','U','T','C','_','T','I','M','E','?','_','_',EOL,
+        /* 2814 */ p_defalias,'_','_','U','T','C','_','T','I','M','E','_','N','U','M','_','_',' ','_','_','?','U','T','C','_','T','I','M','E','_','N','U','M','?','_','_',EOL,
+        /* 2851 */ p_defalias,'_','_','P','O','S','I','X','_','T','I','M','E','_','_',' ','_','_','?','P','O','S','I','X','_','T','I','M','E','?','_','_',EOL,
+        /* 2884 */ p_defalias,'_','_','F','I','L','E','_','_',' ','_','_','?','F','I','L','E','?','_','_',EOL,
+        /* 2905 */ p_defalias,'_','_','L','I','N','E','_','_',' ','_','_','?','L','I','N','E','?','_','_',EOL,
+        /* 2926 */ p_defalias,'_','_','B','I','T','S','_','_',' ','_','_','?','B','I','T','S','?','_','_',EOL,
+        /* 2947 */ p_defalias,'_','_','P','T','R','_','_',' ','_','_','?','P','T','R','?','_','_',EOL,
+        /* 2966 */ p_defalias,'_','_','P','A','S','S','_','_',' ','_','_','?','P','A','S','S','?','_','_',EOL,
+        /* 2987 */ p_idefine,'_','_','?','i','n','f','i','n','i','t','y','?','_','_',' ','%','?',EOL,
+        /* 3006 */ p_idefine,'_','_','?','n','a','n','?','_','_',' ','%','?',EOL,
+        /* 3020 */ p_idefine,'_','_','?','q','n','a','n','?','_','_',' ','%','?',EOL,
+        /* 3035 */ p_idefine,'_','_','?','s','n','a','n','?','_','_',' ','%','?',EOL,
+        /* 3050 */ p_idefine,'_','_','?','f','l','o','a','t','8','?','_','_',' ','%','?',EOL,
+        /* 3067 */ p_idefine,'_','_','?','f','l','o','a','t','1','6','?','_','_',' ','%','?',EOL,
+        /* 3085 */ p_idefine,'_','_','?','f','l','o','a','t','3','2','?','_','_',' ','%','?',EOL,
+        /* 3103 */ p_idefine,'_','_','?','f','l','o','a','t','6','4','?','_','_',' ','%','?',EOL,
+        /* 3121 */ p_idefine,'_','_','?','f','l','o','a','t','8','0','m','?','_','_',' ','%','?',EOL,
+        /* 3140 */ p_idefine,'_','_','?','f','l','o','a','t','8','0','e','?','_','_',' ','%','?',EOL,
+        /* 3159 */ p_idefine,'_','_','?','f','l','o','a','t','1','2','8','l','?','_','_',' ','%','?',EOL,
+        /* 3179 */ p_idefine,'_','_','?','f','l','o','a','t','1','2','8','h','?','_','_',' ','%','?',EOL,
+        /* 3199 */ p_idefine,'_','_','?','u','t','f','1','6','?','_','_',' ','%','?',EOL,
+        /* 3215 */ p_idefine,'_','_','?','u','t','f','1','6','l','e','?','_','_',' ','%','?',EOL,
+        /* 3233 */ p_idefine,'_','_','?','u','t','f','1','6','b','e','?','_','_',' ','%','?',EOL,
+        /* 3251 */ p_idefine,'_','_','?','u','t','f','3','2','?','_','_',' ','%','?',EOL,
+        /* 3267 */ p_idefine,'_','_','?','u','t','f','3','2','l','e','?','_','_',' ','%','?',EOL,
+        /* 3285 */ p_idefine,'_','_','?','u','t','f','3','2','b','e','?','_','_',' ','%','?',EOL,
+        /* 3303 */ p_idefine,'_','_','?','i','l','o','g','2','e','?','_','_',' ','%','?',EOL,
+        /* 3320 */ p_idefine,'_','_','?','i','l','o','g','2','w','?','_','_',' ','%','?',EOL,
+        /* 3337 */ p_idefine,'_','_','?','i','l','o','g','2','f','?','_','_',' ','%','?',EOL,
+        /* 3354 */ p_idefine,'_','_','?','i','l','o','g','2','c','?','_','_',' ','%','?',EOL,
+        /* 3371 */ p_idefalias,'_','_','i','n','f','i','n','i','t','y','_','_',' ','_','_','?','i','n','f','i','n','i','t','y','?','_','_',EOL,
+        /* 3400 */ p_idefalias,'_','_','n','a','n','_','_',' ','_','_','?','n','a','n','?','_','_',EOL,
+        /* 3419 */ p_idefalias,'_','_','q','n','a','n','_','_',' ','_','_','?','q','n','a','n','?','_','_',EOL,
+        /* 3440 */ p_idefalias,'_','_','s','n','a','n','_','_',' ','_','_','?','s','n','a','n','?','_','_',EOL,
+        /* 3461 */ p_idefalias,'_','_','f','l','o','a','t','8','_','_',' ','_','_','?','f','l','o','a','t','8','?','_','_',EOL,
+        /* 3486 */ p_idefalias,'_','_','f','l','o','a','t','1','6','_','_',' ','_','_','?','f','l','o','a','t','1','6','?','_','_',EOL,
+        /* 3513 */ p_idefalias,'_','_','f','l','o','a','t','3','2','_','_',' ','_','_','?','f','l','o','a','t','3','2','?','_','_',EOL,
+        /* 3540 */ p_idefalias,'_','_','f','l','o','a','t','6','4','_','_',' ','_','_','?','f','l','o','a','t','6','4','?','_','_',EOL,
+        /* 3567 */ p_idefalias,'_','_','f','l','o','a','t','8','0','m','_','_',' ','_','_','?','f','l','o','a','t','8','0','m','?','_','_',EOL,
+        /* 3596 */ p_idefalias,'_','_','f','l','o','a','t','8','0','e','_','_',' ','_','_','?','f','l','o','a','t','8','0','e','?','_','_',EOL,
+        /* 3625 */ p_idefalias,'_','_','f','l','o','a','t','1','2','8','l','_','_',' ','_','_','?','f','l','o','a','t','1','2','8','l','?','_','_',EOL,
+        /* 3656 */ p_idefalias,'_','_','f','l','o','a','t','1','2','8','h','_','_',' ','_','_','?','f','l','o','a','t','1','2','8','h','?','_','_',EOL,
+        /* 3687 */ p_idefalias,'_','_','u','t','f','1','6','_','_',' ','_','_','?','u','t','f','1','6','?','_','_',EOL,
+        /* 3710 */ p_idefalias,'_','_','u','t','f','1','6','l','e','_','_',' ','_','_','?','u','t','f','1','6','l','e','?','_','_',EOL,
+        /* 3737 */ p_idefalias,'_','_','u','t','f','1','6','b','e','_','_',' ','_','_','?','u','t','f','1','6','b','e','?','_','_',EOL,
+        /* 3764 */ p_idefalias,'_','_','u','t','f','3','2','_','_',' ','_','_','?','u','t','f','3','2','?','_','_',EOL,
+        /* 3787 */ p_idefalias,'_','_','u','t','f','3','2','l','e','_','_',' ','_','_','?','u','t','f','3','2','l','e','?','_','_',EOL,
+        /* 3814 */ p_idefalias,'_','_','u','t','f','3','2','b','e','_','_',' ','_','_','?','u','t','f','3','2','b','e','?','_','_',EOL,
+        /* 3841 */ p_idefalias,'_','_','i','l','o','g','2','e','_','_',' ','_','_','?','i','l','o','g','2','e','?','_','_',EOL,
+        /* 3866 */ p_idefalias,'_','_','i','l','o','g','2','w','_','_',' ','_','_','?','i','l','o','g','2','w','?','_','_',EOL,
+        /* 3891 */ p_idefalias,'_','_','i','l','o','g','2','f','_','_',' ','_','_','?','i','l','o','g','2','f','?','_','_',EOL,
+        /* 3916 */ p_idefalias,'_','_','i','l','o','g','2','c','_','_',' ','_','_','?','i','l','o','g','2','c','?','_','_',EOL,
+        /* 3941 */ EOL
+};
+#endif
+
+#if defined(OF_AOUT) || defined(OF_AOUTB)
+const unsigned char aout_stdmac[] = {
+    /* From ./output/outaout.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*   48 */ p_endmacro,EOL,
+        /*   50 */ EOL
+};
+#endif
+
+#if defined(OF_AS86)
+const unsigned char as86_stdmac[] = {
+    /* From ./output/outas86.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*   48 */ p_endmacro,EOL,
+        /*   50 */ EOL
+};
+#endif
+
+#if defined(OF_BIN)
+const unsigned char bin_stdmac[] = {
+    /* From ./output/outbin.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_imacro,'o','r','g',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*   43 */ '[','o','r','g',' ','%','1',']',EOL,
+        /*   52 */ p_endmacro,EOL,
+        /*   54 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*   74 */ p_endmacro,EOL,
+        /*   76 */ EOL
+};
+#endif
+
+#if defined(OF_COFF) || defined(OF_WIN32) || defined(OF_WIN64)
+const unsigned char coff_stdmac[] = {
+    /* From ./output/outcoff.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*   48 */ p_endmacro,EOL,
+        /*   50 */ p_imacro,'e','x','p','o','r','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*   68 */ '[','e','x','p','o','r','t',' ','%','1',']',EOL,
+        /*   80 */ p_endmacro,EOL,
+        /*   82 */ p_imacro,'s','a','f','e','s','e','h',' ','1','.','n','o','l','i','s','t',EOL,
+        /*  100 */ '[','s','a','f','e','s','e','h',' ','%','1',']',EOL,
+        /*  113 */ p_endmacro,EOL,
+        /*  115 */ EOL
+};
+#endif
+
+#if defined(OF_DBG)
+const unsigned char dbg_stdmac[] = {
+    /* From ./output/outdbg.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_imacro,'g','r','o','u','p',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*   45 */ '[','g','r','o','u','p',' ','%','1',']',EOL,
+        /*   56 */ p_endmacro,EOL,
+        /*   58 */ p_imacro,'u','p','p','e','r','c','a','s','e',' ','0','+','.','n','o','l','i','s','t',EOL,
+        /*   79 */ p_pragma,'d','b','g',' ','u','p','p','e','r','c','a','s','e',' ','%','1',EOL,
+        /*   97 */ p_endmacro,EOL,
+        /*   99 */ p_imacro,'e','x','p','o','r','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  117 */ p_pragma,'d','b','g',' ','e','x','p','o','r','t',' ','%','1',EOL,
+        /*  132 */ p_endmacro,EOL,
+        /*  134 */ p_imacro,'i','m','p','o','r','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  152 */ p_pragma,'d','b','g',' ','i','m','p','o','r','t',' ','%','1',EOL,
+        /*  167 */ p_endmacro,EOL,
+        /*  169 */ p_imacro,'o','r','g',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  184 */ p_pragma,'d','b','g',' ','o','r','g',' ','%','1',EOL,
+        /*  196 */ p_endmacro,EOL,
+        /*  198 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*  218 */ p_endmacro,EOL,
+        /*  220 */ EOL
+};
+#endif
+
+#if defined(OF_ELF) || defined(OF_ELF32) || defined(OF_ELF64)
+const unsigned char elf_stdmac[] = {
+    /* From ./output/outelf.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*   48 */ p_define,'$','_','%','1',' ','$','%','1',EOL,
+        /*   58 */ p_endmacro,EOL,
+        /*   60 */ p_imacro,'o','s','a','b','i',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*   77 */ '[','%','?',' ','%','1',']',EOL,
+        /*   85 */ p_endmacro,EOL,
+        /*   87 */ EOL
+};
+#endif
+
+#if defined(OF_MACHO) || defined(OF_MACHO32) || defined(OF_MACHO64)
+const unsigned char macho_stdmac[] = {
+    /* From ./output/outmacho.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*   48 */ p_endmacro,EOL,
+        /*   50 */ p_imacro,'s','u','b','s','e','c','t','i','o','n','s','_','v','i','a','_','s','y','m','b','o','l','s',' ','0','.','n','o','l','i','s','t',EOL,
+        /*   84 */ p_pragma,'_','_','?','O','U','T','P','U','T','_','F','O','R','M','A','T','?','_','_',' ','%','?',EOL,
+        /*  108 */ p_endmacro,EOL,
+        /*  110 */ p_imacro,'n','o','_','d','e','a','d','_','s','t','r','i','p',' ','1','-','*','.','n','o','l','i','s','t',EOL,
+        /*  136 */ p_rep,'%','0',EOL,
+        /*  140 */ p_pragma,'_','_','?','O','U','T','P','U','T','_','F','O','R','M','A','T','?','_','_',' ','%','?',' ','%','1',EOL,
+        /*  167 */ p_rotate,'1',EOL,
+        /*  170 */ p_endrep,EOL,
+        /*  172 */ p_endmacro,EOL,
+        /*  174 */ EOL
+};
+#endif
+
+#if defined(OF_OBJ)
+const unsigned char obj_stdmac[] = {
+    /* From ./output/outobj.mac */
+        /*    0 */ p_define,'_','_','?','S','E','C','T','?','_','_',' ','[','s','e','c','t','i','o','n',' ','.','t','e','x','t',']',EOL,
+        /*   28 */ p_imacro,'g','r','o','u','p',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*   45 */ '[','g','r','o','u','p',' ','%','1',']',EOL,
+        /*   56 */ p_endmacro,EOL,
+        /*   58 */ p_imacro,'u','p','p','e','r','c','a','s','e',' ','0','+','.','n','o','l','i','s','t',EOL,
+        /*   79 */ '[','u','p','p','e','r','c','a','s','e',' ','%','1',']',EOL,
+        /*   94 */ p_endmacro,EOL,
+        /*   96 */ p_imacro,'e','x','p','o','r','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  114 */ '[','e','x','p','o','r','t',' ','%','1',']',EOL,
+        /*  126 */ p_endmacro,EOL,
+        /*  128 */ p_imacro,'i','m','p','o','r','t',' ','1','+','.','n','o','l','i','s','t',EOL,
+        /*  146 */ '[','i','m','p','o','r','t',' ','%','1',']',EOL,
+        /*  158 */ p_endmacro,EOL,
+        /*  160 */ p_macro,'_','_','?','N','A','S','M','_','C','D','e','c','l','?','_','_',' ','1',EOL,
+        /*  180 */ p_endmacro,EOL,
+        /*  182 */ EOL
+};
+#endif
+const int use_package_count = 5;
+
+const struct use_package *nasm_find_use_package(const char *name)
+{
+    static const struct use_package packages[5] = {
+        { "altreg", nasm_usemac_altreg, 0 },
+        { "fp", nasm_usemac_fp, 1 },
+        { "ifunc", nasm_usemac_ifunc, 2 },
+        { "masm", nasm_usemac_masm, 3 },
+        { "smartalign", nasm_usemac_smartalign, 4 },
+    };
+#define INVALID_HASH_ENTRY (65535/3)
+    static const int16_t hashdata[16] = {
+        INVALID_HASH_ENTRY,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        2,
+        0,
+        INVALID_HASH_ENTRY,
+        3,
+        0,
+        1,
+        0,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+        4,
+        INVALID_HASH_ENTRY,
+        INVALID_HASH_ENTRY,
+    };
+    uint32_t k1, k2;
+    uint64_t crc;
+    uint16_t ix;
+
+    crc = crc64i(UINT64_C(0x076259c3e291c26c), name);
+    k1 = ((uint32_t)crc & 0xe) + 0;
+    k2 = ((uint32_t)(crc >> 32) & 0xe) + 1;
+
+    ix = hashdata[k1] + hashdata[k2];
+    if (ix >= 5)
+        return NULL;
+
+    if (nasm_stricmp(packages[ix].package, name))
+        return NULL;
+
+    return &packages[ix];
+}
diff --git a/vere/ext/nasm/macros/macros.pl b/vere/ext/nasm/macros/macros.pl
new file mode 100755
index 0000000..03a6486
--- /dev/null
+++ b/vere/ext/nasm/macros/macros.pl
@@ -0,0 +1,311 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# macros.pl   produce macros.c from standard.mac
+#
+
+require 'phash.ph';
+require 'asm/pptok.ph';
+
+use bytes;
+
+my $fname;
+my $line = 0;
+my $index      = 0;
+my $tasm_count = 0;
+my @pname;
+
+# Default names for various bytes
+for (my $o = 0; $o < 256; $o++) {
+    my $c = chr($o);
+    if ($o < 32 || $o > 126) {
+	$pname[$o] = sprintf("%d", $o);
+    } elsif ($c =~ /^[\'\"\\]$/) {
+	$pname[$o] = "\'\\".$c."\'";
+    } else {
+	$pname[$o] = "\'".$c."\'";
+    }
+}
+
+#
+# Print out a string as a character array
+#
+sub charcify(@) {
+    my $l = '';
+    my ($c, $o);
+    my $space = 1;
+    my $quote = 0;
+
+    foreach $o (unpack("C*", join('',@_))) {
+	$c = pack("C", $o);
+	if ($quote) {
+	    if ($o == $quote) {
+		$quote = 0;
+	    }
+	} elsif ($c =~ /^[\'\"\`]$/) {
+	    $quote = $o;
+	} else {
+	    if ($c eq ' ') {
+		next if ($space);
+		$o = 32;
+		$c = ' ';
+		$space = 1;
+	    } elsif ($o < 32 || $o > 126) {
+		$space = 1;	# Implicit space after compacted directive
+	    } else {
+		$space = 0;
+	    }
+	}
+	$l .= $pname[$o];
+	$l .= ',';
+    }
+    return $l;
+}
+
+
+#
+# Generate macros.c
+#
+open(OUT, '>', 'macros/macros.c') or die "unable to open macros.c\n";
+
+print OUT "/*\n";
+print OUT " * Do not edit - this file auto-generated by macros.pl from:\n";
+print OUT " *   ", join("\n *   ", @ARGV), "\n";
+print OUT " */\n";
+print OUT "\n";
+print OUT "#include \"tables.h\"\n";
+print OUT "#include \"nasmlib.h\"\n";
+print OUT "#include \"hashtbl.h\"\n";
+print OUT "#include \"outform.h\"\n";
+print OUT "\n";
+
+my $name = undef;
+my $npkg = 0;
+my @pkg_list   = ();
+my %pkg_number = ();
+my $pkg;
+my @out_list   = ();
+my @std_list   = ();
+my $outfmt;
+my $lastname;
+my $z;
+
+my @pptok_list = sort { $pptok_hash{$a} <=> $pptok_hash{$b} } keys %pptok_hash;
+my %pnum;
+
+foreach my $pt (@pptok_list) {
+    my $n = $pptok_hash{$pt};
+    if ($pt !~ /[A-Z]/ && $n < 256-96) {
+	$n = ($n+128) & 255;
+	(my $et = $pt) =~ s/^\%/p_/;
+	printf OUT "#define %-24s %3d\n", $et, $n;
+	$pnum{$pt} = $n;
+	$pname[$n] = $et;
+    }
+}
+printf OUT "#define %-24s %3d\n\n", 'EOL', 127;
+
+foreach $args ( @ARGV ) {
+    my @file_list = glob ( $args );
+    foreach $fname ( @file_list ) {
+        open(INPUT,'<', $fname) or die "$0: $fname: $!\n";
+	while (<INPUT>) {
+	    $line++;
+	    chomp;
+	    while (/^(.*)\\$/) {
+		$_ = $1;
+		$_ .= <INPUT>;
+		chomp;
+		$line++;
+	    }
+	    s/^\s*(([^\'\"\;]|\"[^\"]*\"|\'[^\']*\')*?)\s*(\;.*)?$/$1/;
+	    s/\s+/ /g;
+	    next if ($_ eq '');
+
+	    if (m/^OUT:\s*(\S.*)$/) {
+		undef $pkg;
+		my @out_alias = split(/\s+/, $1);
+		if (defined($name)) {
+		    printf OUT "        /* %4d */ EOL\n", $index++;
+		    print OUT "};\n#endif\n";
+		    undef $name;
+		}
+		$index = 0;
+		print OUT "\n";
+		my $pfx = '#if';
+		foreach my $al (@out_alias) {
+		    print OUT $pfx, " defined(OF_\U${al}\E)";
+		    $pfx = ' ||';
+		}
+		$name = $out_alias[0] . '_stdmac';
+		print OUT "\nconst unsigned char ${name}[] = {\n";
+		print OUT "    /* From $fname */\n";
+		$lastname = $fname;
+	    } elsif (m/^STD:\s*(\S+)$/) {
+		undef $pkg;
+		my $std = $1;
+		if (defined($name)) {
+		    printf OUT "        /* %4d */ EOL\n", $index++;
+		    print OUT "};\n#endif\n";
+		    undef $name;
+		}
+		$index = 0;
+		print OUT "\n#if 1";
+		$name = 'nasm_stdmac_' . $std;
+		print OUT "\nconst unsigned char ${name}[] = {\n";
+		print OUT "    /* From $fname */\n";
+		$lastname = $fname;
+	    } elsif (m/^USE:\s*(\S+)$/) {
+		$pkg = $1;
+		if (defined($pkg_number{$pkg})) {
+		    die "$0: $fname: duplicate package: $pkg\n";
+		}
+		if (defined($name)) {
+		    printf OUT "        /* %4d */ EOL\n", $index++;
+		    print OUT "};\n#endif\n";
+		    undef $name;
+		}
+		$index = 0;
+		print OUT "\n#if 1";
+		$name = 'nasm_usemac_' . $pkg;
+		print OUT "\nstatic const unsigned char ${name}[] = {\n";
+		print OUT "    /* From $fname */\n";
+		$lastname = $fname;
+		push(@pkg_list, $pkg);
+		$pkg_number{$pkg} = $npkg++;
+		$z = pack("C", $pnum{'%define'})."__?USE_\U$pkg\E?__";
+		printf OUT "        /* %4d */ %sEOL,\n", $index, charcify($z);
+		$z = pack("C", $pnum{'%defalias'})."__USE_\U$pkg\E__ __?USE\U$pkg\E?__";
+		printf OUT "        /* %4d */ %sEOL,\n", $index, charcify($z);
+		$index += length($z)+1;
+	    } else {
+		my($s1, $s2, $pd, $ws);
+
+		if (!defined($name)) {
+		    die "$0: $fname: macro declarations outside a known block\n";
+		}
+
+		$s1 = $_;
+		$s2 = '';
+		while ($s1 =~ /(\%[a-zA-Z_][a-zA-Z0-9_]*)((\s+)(.*)|)$/) {
+		    $s2 .= "$'";
+		    $pd = $1;
+		    $ws = $3;
+		    $s1 = $4;
+		    if (defined($pnum{$pd})) {
+			$s2 .= pack("C", $pnum{$pd});
+		    } else {
+			$s2 .= $pd.$ws;
+		    }
+		}
+		$s2 .= $s1;
+		if (length($s2) > 0) {
+		    if ($lastname ne $fname) {
+			print OUT "\n    /* From $fname */\n";
+			$lastname = $fname;
+		    }
+		    printf OUT "        /* %4d */ %sEOL,\n",
+			$index, charcify($s2);
+		    $index += length($s2)+1;
+		}
+	    }
+	}
+        close(INPUT);
+    }
+}
+
+if (defined($name)) {
+    printf OUT "        /* %4d */ EOL\n", $index++;
+    print OUT "};\n#endif\n";
+    undef $name;
+}
+
+my @hashinfo = gen_perfect_hash(\%pkg_number);
+if (!@hashinfo) {
+    die "$0: no hash found\n";
+}
+# Paranoia...
+verify_hash_table(\%pkg_number, \@hashinfo);
+my ($n, $sv, $g) = @hashinfo;
+die if ($n & ($n-1));
+$n <<= 1;
+
+printf OUT "const int use_package_count = %d;\n\n", $npkg;
+
+print OUT "const struct use_package *nasm_find_use_package(const char *name)\n";
+print OUT "{\n";
+print OUT "    static const struct use_package packages[$npkg] = {\n";
+my $ix = 0;
+foreach $pkg (@pkg_list) {
+    printf OUT "        { \"%s\", nasm_usemac_%s, %d },\n",
+	$pkg, $pkg, $ix++;
+}
+print OUT "    };\n";
+
+# Put a large value in unused slots.  This makes it extremely unlikely
+# that any combination that involves unused slot will pass the range test.
+# This speeds up rejection of unrecognized tokens, i.e. identifiers.
+print OUT "#define INVALID_HASH_ENTRY (65535/3)\n";
+
+print OUT "    static const int16_t hashdata[$n] = {\n";
+for ($i = 0; $i < $n; $i++) {
+    my $h = ${$g}[$i];
+    print OUT "        ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n";
+}
+print OUT "    };\n";
+
+print OUT  "    uint32_t k1, k2;\n";
+print OUT  "    uint64_t crc;\n";
+# For correct overflow behavior, "ix" should be unsigned of the same
+# width as the hash arrays.
+print OUT  "    uint16_t ix;\n";
+print OUT  "\n";
+
+printf OUT "    crc = crc64i(UINT64_C(0x%08x%08x), name);\n",
+    $$sv[0], $$sv[1];
+printf OUT "    k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2;
+printf OUT "    k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2;
+print  OUT "\n";
+printf OUT "    ix = hashdata[k1] + hashdata[k2];\n";
+printf OUT "    if (ix >= %d)\n", scalar(@pkg_list);
+print OUT  "        return NULL;\n";
+print OUT  "\n";
+print OUT  "    if (nasm_stricmp(packages[ix].package, name))\n";
+print OUT  "        return NULL;\n";
+print OUT  "\n";
+print OUT  "    return &packages[ix];\n";
+print OUT  "}\n";
+
+close(OUT);
diff --git a/vere/ext/nasm/macros/masm.mac b/vere/ext/nasm/macros/masm.mac
new file mode 100644
index 0000000..f476364
--- /dev/null
+++ b/vere/ext/nasm/macros/masm.mac
@@ -0,0 +1,82 @@
+;; --------------------------------------------------------------------------
+;;
+;;   Copyright 2019 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;;
+;; masm.mac
+;;
+;; Very limited MASM compatibility package; intended to be used
+;; primarily with machine-generated code. It does not include any
+;; "programmer friendly" shortcuts, nor does it in any way support
+;; ASSUME, symbol typing, or MASM-style structures.
+;;
+
+USE: masm
+
+%unimacro segment 1+
+
+%imacro segment 0-1+.nolist
+  %define __?SECT?__ [segment %00 %1]
+	__?SECT?__
+%endmacro
+
+%imacro ends 0+.nolist
+  %null ends %00
+%endmacro
+
+%imacro proc 0-*.nolist
+  %rep %0
+    %ifidni %1,far
+      %idefine ret retf
+    %else
+      %idefine ret retn
+    %endif
+    %rotate 1
+  %endrep
+%endmacro
+
+%imacro endp 0.nolist
+  %null endp %00
+  %undef ret
+%endmacro
+
+%idefine ptr __?masm_ptr?__
+%idefine flat __?masm_flat?__	; is %idefine really correct here?
+%idefine offset
+
+%imacro end 0+.nolist
+	; Nothing
+%endmacro
+
+%idefine tbyte tword
+
+	default rel
diff --git a/vere/ext/nasm/macros/smartalign.mac b/vere/ext/nasm/macros/smartalign.mac
new file mode 100644
index 0000000..abd496e
--- /dev/null
+++ b/vere/ext/nasm/macros/smartalign.mac
@@ -0,0 +1,191 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;
+; Smart alignment macros
+;
+USE: smartalign
+
+%imacro alignmode 1-2.nolist
+  %ifidni %1,nop
+    %define __?ALIGN_JMP_THRESHOLD?__ 16
+
+    %define __?ALIGN_16BIT_1B?__ 0x90
+    %define __?ALIGN_16BIT_GROUP?__ 1
+
+    %define __?ALIGN_32BIT_1B?__ 0x90
+    %define __?ALIGN_32BIT_GROUP?__ 1
+
+    %define __?ALIGN_64BIT_1B?__ 0x90
+    %define __?ALIGN_64BIT_GROUP?__ 1
+  %elifidni %1,generic
+    %define __?ALIGN_JMP_THRESHOLD?__ 8
+
+    %define __?ALIGN_16BIT_1B?__ 0x90
+    %define __?ALIGN_16BIT_2B?__ 0x89,0xf6
+    %define __?ALIGN_16BIT_3B?__ 0x8d,0x74,0x00
+    %define __?ALIGN_16BIT_4B?__ 0x8d,0xb4,0x00,0x00
+    %define __?ALIGN_16BIT_5B?__ 0x8d,0xb4,0x00,0x00,0x90
+    %define __?ALIGN_16BIT_6B?__ 0x8d,0xb4,0x00,0x00,0x89,0xff
+    %define __?ALIGN_16BIT_7B?__ 0x8d,0xb4,0x00,0x00,0x8d,0x7d,0x00
+    %define __?ALIGN_16BIT_8B?__ 0x8d,0xb4,0x00,0x00,0x8d,0xbd,0x00,0x00
+    %define __?ALIGN_16BIT_GROUP?__ 8
+
+    %define __?ALIGN_32BIT_1B?__ 0x90
+    %define __?ALIGN_32BIT_2B?__ 0x89,0xf6
+    %define __?ALIGN_32BIT_3B?__ 0x8d,0x76,0x00
+    %define __?ALIGN_32BIT_4B?__ 0x8d,0x74,0x26,0x00
+    %define __?ALIGN_32BIT_5B?__ 0x90,0x8d,0x74,0x26,0x00
+    %define __?ALIGN_32BIT_6B?__ 0x8d,0xb6,0x00,0x00,0x00,0x00
+    %define __?ALIGN_32BIT_7B?__ 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00
+    %define __?ALIGN_32BIT_GROUP?__ 7
+
+    %define __?ALIGN_64BIT_1B?__ 0x90
+    %define __?ALIGN_64BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_64BIT_3B?__ 0x66,0x66,0x90
+    %define __?ALIGN_64BIT_4B?__ 0x66,0x66,0x66,0x90
+    %define __?ALIGN_64BIT_GROUP?__ 4
+  %elifidni %1,k8
+    %define __?ALIGN_JMP_THRESHOLD?__ 16
+
+    %define __?ALIGN_16BIT_1B?__ 0x90
+    %define __?ALIGN_16BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_16BIT_3B?__ 0x66,0x66,0x90
+    %define __?ALIGN_16BIT_4B?__ 0x66,0x66,0x66,0x90
+    %define __?ALIGN_16BIT_GROUP?__ 4
+
+    %define __?ALIGN_32BIT_1B?__ 0x90
+    %define __?ALIGN_32BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_32BIT_3B?__ 0x66,0x66,0x90
+    %define __?ALIGN_32BIT_4B?__ 0x66,0x66,0x66,0x90
+    %define __?ALIGN_32BIT_GROUP?__ 4
+
+    %define __?ALIGN_64BIT_1B?__ 0x90
+    %define __?ALIGN_64BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_64BIT_3B?__ 0x66,0x66,0x90
+    %define __?ALIGN_64BIT_4B?__ 0x66,0x66,0x66,0x90
+    %define __?ALIGN_64BIT_GROUP?__ 4
+  %elifidni %1,k7
+    %define __?ALIGN_JMP_THRESHOLD?__ 16
+
+    %define __?ALIGN_16BIT_1B?__ 0x90
+    %define __?ALIGN_16BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_16BIT_3B?__ 0x66,0x66,0x90
+    %define __?ALIGN_16BIT_4B?__ 0x66,0x66,0x66,0x90
+    %define __?ALIGN_64BIT_GROUP?__ 4
+
+    %define __?ALIGN_32BIT_1B?__ 0x90
+    %define __?ALIGN_32BIT_2B?__ 0x8b,0xc0
+    %define __?ALIGN_32BIT_3B?__ 0x8d,0x04,0x20
+    %define __?ALIGN_32BIT_4B?__ 0x8d,0x44,0x20,0x00
+    %define __?ALIGN_32BIT_5B?__ 0x8d,0x44,0x20,0x00,0x90
+    %define __?ALIGN_32BIT_6B?__ 0x8d,0x80,0x00,0x00,0x00,0x00
+    %define __?ALIGN_32BIT_7B?__ 0x8d,0x04,0x05,0x00,0x00,0x00,0x00
+    %define __?ALIGN_32BIT_GROUP?__ 7
+
+    %define __?ALIGN_64BIT_1B?__ 0x90
+    %define __?ALIGN_64BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_64BIT_3B?__ 0x66,0x66,0x90
+    %define __?ALIGN_64BIT_4B?__ 0x66,0x66,0x66,0x90
+    %define __?ALIGN_64BIT_GROUP?__ 4
+  %elifidni %1,p6
+    %define __?ALIGN_JMP_THRESHOLD?__ 16
+
+    %define __?ALIGN_16BIT_1B?__ 0x90
+    %define __?ALIGN_16BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_16BIT_3B?__ 0x0f,0x1f,0x00
+    %define __?ALIGN_16BIT_4B?__ 0x0f,0x1f,0x40,0x00
+    %define __?ALIGN_16BIT_GROUP?__ 4
+
+    %define __?ALIGN_32BIT_1B?__ 0x90
+    %define __?ALIGN_32BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_32BIT_3B?__ 0x0f,0x1f,0x00
+    %define __?ALIGN_32BIT_4B?__ 0x0f,0x1f,0x40,0x00
+    %define __?ALIGN_32BIT_5B?__ 0x0f,0x1f,0x44,0x00,0x00
+    %define __?ALIGN_32BIT_6B?__ 0x66,0x0f,0x1f,0x44,0x00,0x00
+    %define __?ALIGN_32BIT_7B?__ 0x0f,0x1f,0x80,0x00,0x00,0x00,0x00
+    %define __?ALIGN_32BIT_8B?__ 0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00
+    %define __?ALIGN_32BIT_GROUP?__ 8
+
+    %define __?ALIGN_64BIT_1B?__ 0x90
+    %define __?ALIGN_64BIT_2B?__ 0x66,0x90
+    %define __?ALIGN_64BIT_3B?__ 0x0f,0x1f,0x00
+    %define __?ALIGN_64BIT_4B?__ 0x0f,0x1f,0x40,0x00
+    %define __?ALIGN_64BIT_5B?__ 0x0f,0x1f,0x44,0x00,0x00
+    %define __?ALIGN_64BIT_6B?__ 0x66,0x0f,0x1f,0x44,0x00,0x00
+    %define __?ALIGN_64BIT_7B?__ 0x0f,0x1f,0x80,0x00,0x00,0x00,0x00
+    %define __?ALIGN_64BIT_8B?__ 0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00
+    %define __?ALIGN_64BIT_GROUP?__ 8
+  %else
+    %error unknown alignment mode: %1
+  %endif
+  %ifnempty %2
+    %ifidni %2,nojmp
+      %xdefine __?ALIGN_JMP_THRESHOLD?__ -1
+    %else
+      %xdefine __?ALIGN_JMP_THRESHOLD?__ %2
+    %endif
+  %endif
+  %xdefine __?ALIGNMODE?__ %1,__?ALIGN_JMP_THRESHOLD?__
+%endmacro
+
+%defalias __ALIGNMODE__ __?ALIGNMODE?__
+
+%unimacro align 1-2+.nolist
+%imacro align 1-2+.nolist
+  sectalign %1   ; align a segment as well
+  %ifnempty %2
+    times (((%1) - (($-$$) % (%1))) % (%1)) %2
+  %elif __?PASS?__ == 0 || __?PASS?__ == 3
+    times (((%1) - (($-$$) % (%1))) % (%1)) nop
+  %else
+    %push
+    %assign %$pad (((%1) - (($-$$) % (%1))) % (%1))
+    %if __?ALIGN_JMP_THRESHOLD?__ != -1 && %$pad > __?ALIGN_JMP_THRESHOLD?__
+      jmp %$end
+      ; We can't re-use %$pad here as $ will have changed!
+      times (((%1) - (($-$$) % (%1))) % (%1)) nop
+    %else
+      times (%$pad / __?ALIGN_%[__?BITS?__]BIT_GROUP?__) \
+        db __?ALIGN_%[__?BITS?__]BIT_%[__?ALIGN_%[__?BITS?__]BIT_GROUP?__]B?__
+      %assign %$pad %$pad % __?ALIGN_%[__?BITS?__]BIT_GROUP?__
+      %if %$pad > 0
+        db __?ALIGN_%[__?BITS?__]BIT_%[%$pad]B?__
+      %endif
+    %endif
+%$end:
+    %pop
+  %endif
+%endmacro
+
+	alignmode generic
diff --git a/vere/ext/nasm/macros/standard.mac b/vere/ext/nasm/macros/standard.mac
new file mode 100644
index 0000000..3d875e3
--- /dev/null
+++ b/vere/ext/nasm/macros/standard.mac
@@ -0,0 +1,331 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2019 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+; Standard macro set for NASM -*- nasm -*-
+
+; Macros to make NASM ignore some TASM directives
+STD: tasm
+    %idefine IDEAL
+    %idefine JUMPS
+    %idefine P386
+    %idefine P486
+    %idefine P586
+    %idefine END
+
+; The normal standard macros
+STD: nasm
+
+; Note that although some user-level forms of directives are defined
+; here, not all of them are: the user-level form of a format-specific
+; directive should be defined in the module for that directive.
+
+%define __?SECT?__            ; it ought to be defined, even if as nothing
+%defalias __SECT__ __?SECT?__
+
+%imacro section 1+.nolist
+    %define __?SECT?__ [section %1]
+    __?SECT?__
+%endmacro
+
+%imacro segment 1+.nolist
+    %define __?SECT?__ [segment %1]
+    __?SECT?__
+%endmacro
+
+%define __?SECTALIGN_ALIGN_UPDATES_SECTION?__ 1
+%imacro sectalign 1+.nolist
+    %ifidni %1,off
+        %define __?SECTALIGN_ALIGN_UPDATES_SECTION?__ 0
+    %elifidni %1,on
+        %define __?SECTALIGN_ALIGN_UPDATES_SECTION?__ 1
+    %else
+        [sectalign %1]
+    %endif
+%endmacro
+%defalias __SECTALIGN_ALIGN_UPDATES_SECTION__ __?SECTALIGN_ALIGN_UPDATES_SECTION?__
+
+%imacro absolute 1+.nolist
+    %define __?SECT?__ [absolute %1]
+    __?SECT?__
+%endmacro
+
+%imacro struc 1-2.nolist 0
+    %push
+        %define %$strucname %1
+        [absolute %2]
+        %$strucname:        ; allow definition of `.member' to work sanely
+%endmacro
+
+%imacro endstruc 0.nolist
+        %{$strucname}_size equ ($-%$strucname)
+    %pop
+    __?SECT?__
+%endmacro
+
+%imacro istruc 1.nolist
+    %push
+        %define %$strucname %1
+        %$strucstart:
+%endmacro
+
+%imacro at 1-2+.nolist
+    %defstr %$member %1
+    %substr %$member1 %$member 1
+    %ifidn %$member1, '.'
+        times (%$strucname%1-%$strucname)-($-%$strucstart) db 0
+    %else
+        times (%1-%$strucname)-($-%$strucstart) db 0
+    %endif
+    %2
+%endmacro
+
+%imacro iend 0.nolist
+        times %{$strucname}_size-($-%$strucstart) db 0
+    %pop
+%endmacro
+
+%imacro align 1-2+.nolist nop
+    %if __?SECTALIGN_ALIGN_UPDATES_SECTION?__
+        sectalign %1
+    %endif
+    times (((%1) - (($-$$) % (%1))) % (%1)) %2
+%endmacro
+
+%imacro alignb 1-2+.nolist
+    %if __?SECTALIGN_ALIGN_UPDATES_SECTION?__
+        sectalign %1
+    %endif
+    %ifempty %2
+        [warning push]
+        [warning -zeroing]
+        resb (((%1) - (($-$$) % (%1))) % (%1))
+        [warning pop]
+    %else
+        times (((%1) - (($-$$) % (%1))) % (%1)) %2
+    %endif
+%endmacro
+
+%imacro bits 1+.nolist
+    [bits %1]
+%endmacro
+
+%imacro use16 0.nolist
+    [bits 16]
+%endmacro
+
+%imacro use32 0.nolist
+    [bits 32]
+%endmacro
+
+%imacro use64 0.nolist
+    [bits 64]
+%endmacro
+
+%imacro extern 1-*.nolist
+    %rep %0
+        [extern %1]
+        %rotate 1
+    %endrep
+%endmacro
+
+%imacro static 1-*.nolist
+    %rep %0
+        [static %1]
+        %rotate 1
+    %endrep
+%endmacro
+
+%imacro global 1-*.nolist
+    %rep %0
+        [global %1]
+        %rotate 1
+    %endrep
+%endmacro
+
+%imacro required 1-*.nolist
+    %rep %0
+        [required %1]
+        %rotate 1
+    %endrep
+%endmacro
+
+%imacro common 1-*.nolist
+    %rep %0
+        [common %1]
+        %rotate 1
+    %endrep
+%endmacro
+
+%imacro cpu 1+.nolist
+    [cpu %1]
+%endmacro
+
+%define __?FLOAT_DAZ?__ nodaz
+%define __?FLOAT_ROUND?__ near
+; __?FLOAT?__ contains the whole floating-point configuration so it can
+; be saved and restored
+%define __?FLOAT?__ __?FLOAT_DAZ?__,__?FLOAT_ROUND?__
+
+%defalias __FLOAT_DAZ__ __?FLOAT_DAZ?__
+%defalias __FLOAT_ROUND__ __?FLOAT_ROUND?__
+%defalias __FLOAT__ __?FLOAT?__
+
+%imacro float 1-*.nolist
+    %rep %0
+        [float %1]
+        %ifidni %1,daz
+            %define __?FLOAT_DAZ?__ daz
+        %elifidni %1,nodaz
+            %define __?FLOAT_DAZ?__ nodaz
+        %elifidni %1,near
+            %define __?FLOAT_ROUND?__ near
+        %elifidni %1,up
+            %define __?FLOAT_ROUND?__ up
+        %elifidni %1,down
+            %define __?FLOAT_ROUND?__ down
+        %elifidni %1,zero
+            %define __?FLOAT_ROUND?__ zero
+        %elifidni %1,default
+            %define __?FLOAT_DAZ?__ nodaz
+            %define __?FLOAT_ROUND?__ near
+        %endif
+        %rotate 1
+    %endrep
+%endmacro
+
+%imacro default 1+.nolist
+    [default %1]
+%endmacro
+
+%imacro userel 0.nolist
+    [default rel]
+%endmacro
+%imacro useabs 0.nolist
+    [default abs]
+%endmacro
+%imacro usebnd 0.nolist
+    [default bnd]
+%endmacro
+%imacro usenobnd 0.nolist
+    [default nobnd]
+%endmacro
+
+%imacro incbin 1-2+.nolist 0
+    %push
+        %pathsearch %$dep %1
+        %depend %$dep
+        %? %$dep,%2
+    %pop
+%endmacro
+
+; Compatibility macro aliases
+%defalias __NASM_MAJOR__      __?NASM_MAJOR?__
+%defalias __NASM_MINOR__      __?NASM_MINOR?__
+%defalias __NASM_SUBMINOR__   __?NASM_SUBMINOR?__
+%defalias __NASM_PATCHLEVEL__ __?NASM_PATCHLEVEL?__
+%defalias __NASM_SNAPSHOT__   __?NASM_SNAPSHOT?__
+%defalias __NASM_VERSION_ID__ __?NASM_VERSION_ID?__
+%defalias __NASM_VER__        __?NASM_VER?__
+
+%defalias __OUTPUT_FORMAT__   __?OUTPUT_FORMAT?__
+%defalias __DEBUG_FORMAT__    __?DEBUG_FORMAT?__
+
+%defalias __DATE__            __?DATE?__
+%defalias __DATE_NUM__        __?DATE_NUM?__
+%defalias __TIME__            __?TIME?__
+%defalias __TIME_NUM__        __?TIME_NUM?__
+%defalias __UTC_DATE__        __?UTC_DATE?__
+%defalias __UTC_DATE_NUM__    __?UTC_DATE_NUM?__
+%defalias __UTC_TIME__        __?UTC_TIME?__
+%defalias __UTC_TIME_NUM__    __?UTC_TIME_NUM?__
+%defalias __POSIX_TIME__      __?POSIX_TIME?__
+
+%defalias __FILE__            __?FILE?__
+%defalias __LINE__            __?LINE?__
+%defalias __BITS__            __?BITS?__
+%defalias __PTR__             __?PTR?__
+%defalias __PASS__            __?PASS?__
+
+; Backwards compatibility aliases for tokens. The extra level of indirection here
+; means %aliases on|off will do the right thing for these as well.
+%idefine __?infinity?__ %?
+%idefine __?nan?__ %?
+%idefine __?qnan?__ %?
+%idefine __?snan?__ %?
+
+%idefine __?float8?__ %?
+%idefine __?float16?__ %?
+%idefine __?float32?__ %?
+%idefine __?float64?__ %?
+%idefine __?float80m?__ %?
+%idefine __?float80e?__ %?
+%idefine __?float128l?__ %?
+%idefine __?float128h?__ %?
+
+%idefine __?utf16?__ %?
+%idefine __?utf16le?__ %?
+%idefine __?utf16be?__ %?
+%idefine __?utf32?__ %?
+%idefine __?utf32le?__ %?
+%idefine __?utf32be?__ %?
+
+%idefine __?ilog2e?__ %?
+%idefine __?ilog2w?__ %?
+%idefine __?ilog2f?__ %?
+%idefine __?ilog2c?__ %?
+
+%idefalias __infinity__ __?infinity?__
+%idefalias __nan__ __?nan?__
+%idefalias __qnan__ __?qnan?__
+%idefalias __snan__ __?snan?__
+
+%idefalias __float8__ __?float8?__
+%idefalias __float16__ __?float16?__
+%idefalias __float32__ __?float32?__
+%idefalias __float64__ __?float64?__
+%idefalias __float80m__ __?float80m?__
+%idefalias __float80e__ __?float80e?__
+%idefalias __float128l__ __?float128l?__
+%idefalias __float128h__ __?float128h?__
+
+%idefalias __utf16__ __?utf16?__
+%idefalias __utf16le__ __?utf16le?__
+%idefalias __utf16be__ __?utf16be?__
+%idefalias __utf32__ __?utf32?__
+%idefalias __utf32le__ __?utf32le?__
+%idefalias __utf32be__ __?utf32be?__
+
+%idefalias __ilog2e__ __?ilog2e?__
+%idefalias __ilog2w__ __?ilog2w?__
+%idefalias __ilog2f__ __?ilog2f?__
+%idefalias __ilog2c__ __?ilog2c?__
diff --git a/vere/ext/nasm/misc/Doxyfile b/vere/ext/nasm/misc/Doxyfile
new file mode 100644
index 0000000..d3bd8d2
--- /dev/null
+++ b/vere/ext/nasm/misc/Doxyfile
@@ -0,0 +1,752 @@
+# Doxyfile 1.2.5
+
+# This file describes the settings to be used by doxygen for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project. 
+
+PROJECT_NAME           = "NASM - the Netwide Assembler"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = 0.98
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = doxy
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Dutch, French, Italian, Czech, Swedish, German, Finnish, Japanese, 
+# Korean, Hungarian, Norwegian, Spanish, Romanian, Russian, Croatian, 
+# Polish, Portuguese and Slovene.
+
+OUTPUT_LANGUAGE        = English
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES 
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation. 
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation. 
+
+EXTRACT_STATIC         = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled. 
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these class will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled. 
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this. 
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed. 
+
+REPEAT_BRIEF           = YES
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description. 
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used. 
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. It is allowed to use relative paths in the argument list.
+
+STRIP_FROM_PATH        = 
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation. 
+
+INTERNAL_DOCS          = NO
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a class diagram (in Html and LaTeX) for classes with base or 
+# super classes. Setting the tag to NO turns the diagrams off. 
+
+CLASS_DIAGRAMS         = YES
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation. 
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible. 
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower case letters. If set to YES upper case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden. 
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this. 
+
+VERBATIM_HEADERS       = YES
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put list of the files that are included by a file in the documentation 
+# of that file. 
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments  will behave just like the Qt-style comments (thus requiring an 
+# explicit @brief command for a brief description. 
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# reimplements. 
+
+INHERIT_DOCS           = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members. 
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order. 
+
+SORT_MEMBER_DOCS       = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments. 
+
+TAB_SIZE               = 4
+
+# The ENABLE_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif. 
+
+ENABLED_SECTIONS       = 
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines. 
+
+ALIASES                = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consist of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting. 
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources 
+# only. Doxygen will then generate output that is more tailored for C. 
+# For instance some of the names that are used will be different. The list 
+# of all members will be omitted, etc. 
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used. 
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used. 
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled. 
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. 
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr. 
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces. 
+
+INPUT                  = .
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included. 
+
+FILE_PATTERNS          =  *.c *.h
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used. 
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag. 
+
+EXCLUDE                = 
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. 
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command). 
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included. 
+
+EXAMPLE_PATTERNS       = 
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command). 
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output. 
+
+INPUT_FILTER           = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse. 
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces. 
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20]) 
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers. 
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output. 
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path. 
+
+HTML_OUTPUT            = html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet 
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used. 
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
+# of the generated HTML documentation. 
+
+GENERATE_HTMLHELP      = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it. 
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation. 
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript and frames is required (for instance Netscape 4.0+ 
+# or Internet explorer 4.0+). 
+
+GENERATE_TREEVIEW      = YES
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown. 
+
+TREEVIEW_WIDTH         = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output. 
+
+GENERATE_LATEX         = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path. 
+
+LATEX_OUTPUT           = latex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general. 
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used. 
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output. 
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing! 
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer. 
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation. 
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML. 
+
+LATEX_BATCHMODE        = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimised for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = YES
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path. 
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general. 
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using a WORD or other. 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links. 
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value. 
+
+RTF_STYLESHEET_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages 
+
+GENERATE_MAN           = YES
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path. 
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3) 
+
+MAN_EXTENSION          = .3
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files. 
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES. 
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_PREDEFINED tags. 
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found. 
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor. 
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used. 
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. 
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition. 
+
+EXPAND_AS_DEFINED      = 
+
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tagfiles. 
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads. 
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed. 
+
+ALLEXTERNALS           = NO
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl'). 
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default) 
+
+HAVE_DOT               = NO
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes. 
+
+COLLABORATION_GRAPH    = YES
+
+# If the ENABLE_PREPROCESSING, INCLUDE_GRAPH, and HAVE_DOT tags are set to 
+# YES then doxygen will generate a graph for each documented file showing 
+# the direct and indirect include dependencies of the file with other 
+# documented files. 
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, INCLUDED_BY_GRAPH, and HAVE_DOT tags are set to 
+# YES then doxygen will generate a graph for each documented header file showing 
+# the documented files that directly or indirectly include this file 
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one. 
+
+GRAPHICAL_HIERARCHY    = YES
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found on the path. 
+
+DOT_PATH               = 
+
+# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images. 
+
+MAX_DOT_GRAPH_WIDTH    = 1024
+
+# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images. 
+
+MAX_DOT_GRAPH_HEIGHT   = 1024
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs. 
+
+GENERATE_LEGEND        = YES
+
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored. 
+
+SEARCHENGINE           = NO
+
+# The CGI_NAME tag should be the name of the CGI script that 
+# starts the search engine (doxysearch) with the correct parameters. 
+# A script with this name will be generated by doxygen. 
+
+CGI_NAME               = search.cgi
+
+# The CGI_URL tag should be the absolute URL to the directory where the 
+# cgi binaries are located. See the documentation of your http daemon for 
+# details. 
+
+CGI_URL                = 
+
+# The DOC_URL tag should be the absolute URL to the directory where the 
+# documentation is located. If left blank the absolute path to the 
+# documentation, with file:// prepended to it, will be used. 
+
+DOC_URL                = 
+
+# The DOC_ABSPATH tag should be the absolute path to the directory where the 
+# documentation is located. If left blank the directory on the local machine 
+# will be used. 
+
+DOC_ABSPATH            = 
+
+# The BIN_ABSPATH tag must point to the directory where the doxysearch binary 
+# is installed. 
+
+BIN_ABSPATH            = /usr/local/bin/
+
+# The EXT_DOC_PATHS tag can be used to specify one or more paths to 
+# documentation generated for other projects. This allows doxysearch to search 
+# the documentation for these projects as well. 
+
+EXT_DOC_PATHS          = 
diff --git a/vere/ext/nasm/misc/Nindent b/vere/ext/nasm/misc/Nindent
new file mode 100755
index 0000000..a6c806c
--- /dev/null
+++ b/vere/ext/nasm/misc/Nindent
@@ -0,0 +1,18 @@
+#!/bin/sh
+PARAM="-npro -kr -i8 -ts8 -sob -l80 -ss -ncs -cp1"
+RES=`indent --version`
+V1=`echo $RES | cut -d' ' -f3 | cut -d'.' -f1`
+V2=`echo $RES | cut -d' ' -f3 | cut -d'.' -f2`
+V3=`echo $RES | cut -d' ' -f3 | cut -d'.' -f3`
+if [ $V1 -gt 2 ]; then
+  PARAM="$PARAM -il0"
+elif [ $V1 -eq 2 ]; then
+  if [ $V2 -gt 2 ]; then
+    PARAM="$PARAM -il0";
+  elif [ $V2 -eq 2 ]; then
+    if [ $V3 -ge 10 ]; then
+      PARAM="$PARAM -il0"
+    fi
+  fi
+fi
+exec indent $PARAM "$@"
diff --git a/vere/ext/nasm/misc/README b/vere/ext/nasm/misc/README
new file mode 100644
index 0000000..f39ba4d
--- /dev/null
+++ b/vere/ext/nasm/misc/README
@@ -0,0 +1,2 @@
+There are various helpful bits and pieces for NASM,
+including but not limited to Simon photograph =)
diff --git a/vere/ext/nasm/misc/c16.mac b/vere/ext/nasm/misc/c16.mac
new file mode 100644
index 0000000..50b5d5e
--- /dev/null
+++ b/vere/ext/nasm/misc/c16.mac
@@ -0,0 +1,82 @@
+; NASM macro set to make interfacing to 16-bit programs easier -*- nasm -*-
+
+
+
+%imacro proc 1			; begin a procedure definition
+
+%push proc
+
+	  global %1
+
+%1:	  push bp
+
+	  mov bp,sp
+
+%ifdef FARCODE PASCAL		; arguments may start at bp+4 or bp+6
+
+%assign %$arg 6
+
+%define %$firstarg 6
+
+%else
+
+%assign %$arg 4
+
+%define %$firstarg 4
+
+%endif
+
+%define %$procname %1
+
+%endmacro
+
+
+
+%imacro arg 0-1 2		; used with the argument name as a label
+
+%00	  equ %$arg
+
+				; we could possibly be adding some
+
+				; debug information at this point...?
+
+%assign %$arg %1+%$arg
+
+%endmacro
+
+
+
+%imacro endproc 0
+
+%ifnctx proc
+
+%error Mismatched `endproc'/`proc'
+
+%else
+
+          mov sp,bp
+
+          pop bp
+
+%ifdef PASCAL
+
+          retf %$arg - %$firstarg
+
+%elifdef FARCODE
+
+	  retf
+
+%else
+
+	  retn
+
+%endif
+
+__end_%$procname:		; useful for calculating function size
+
+%pop
+
+%endif
+
+%endmacro
+
diff --git a/vere/ext/nasm/misc/c32.mac b/vere/ext/nasm/misc/c32.mac
new file mode 100644
index 0000000..f0c116b
--- /dev/null
+++ b/vere/ext/nasm/misc/c32.mac
@@ -0,0 +1,52 @@
+; NASM macro set to make interfacing to 32-bit programs easier -*- nasm -*-
+
+
+
+%imacro proc 1			; begin a procedure definition
+
+%push proc
+
+          global %1
+
+%1:       push ebp
+
+          mov ebp,esp
+
+%assign %$arg 8
+
+%define %$procname %1
+
+%endmacro
+
+
+
+%imacro arg 0-1 4		; used with the argument name as a label
+
+%00	  equ %$arg
+
+%assign %$arg %1+%$arg
+
+%endmacro
+
+
+
+%imacro endproc 0
+
+%ifnctx proc
+
+%error Mismatched `endproc'/`proc'
+
+%else
+
+	  leave
+
+	  ret
+
+__end_%$procname:		; useful for calculating function size
+
+%pop
+
+%endif
+
+%endmacro
+
diff --git a/vere/ext/nasm/misc/crcgen.c b/vere/ext/nasm/misc/crcgen.c
new file mode 100644
index 0000000..f11e252
--- /dev/null
+++ b/vere/ext/nasm/misc/crcgen.c
@@ -0,0 +1,44 @@
+#include <inttypes.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    /* Polynomial in bit-reversed notation */
+    uint64_t poly;
+    uint64_t crctab[256], v;
+    int i, j;
+
+    poly = strtoumax(argv[1], NULL, 0);
+
+    printf("/* C */\n");
+    printf("static const uint64_t crc64_tab[256] = {\n");
+    for (i = 0; i < 256; i++) {
+	v = i;
+	for (j = 0; j < 8; j++)
+	    v = (v >> 1) ^ ((v & 1) ? poly : 0);
+	crctab[i] = v;
+    }
+
+    for (i = 0; i < 256; i += 2) {
+	printf("    /* %02x */ UINT64_C(0x%016"PRIx64"), "
+	       "UINT64_C(0x%016"PRIx64")%s\n",
+	       i, crctab[i], crctab[i+1], (i == 254) ? "" : ",");
+    }
+    printf("};\n\n");
+
+    printf("# perl\n");
+    printf("@crc64_tab = (\n");
+    for (i = 0; i < 256; i += 2) {
+	printf("    [0x%08"PRIx32", 0x%08"PRIx32"], "
+	       "[0x%08"PRIx32", 0x%08"PRIx32"]%-1s    # %02x\n",
+	       (uint32_t)(crctab[i] >> 32),
+	       (uint32_t)(crctab[i]),
+	       (uint32_t)(crctab[i+1] >> 32),
+	       (uint32_t)(crctab[i+1]),
+	       (i == 254) ? "" : ",",
+	       i);
+    }
+    printf(");\n");
+
+    return 0;
+}
diff --git a/vere/ext/nasm/misc/emacstbl.pl b/vere/ext/nasm/misc/emacstbl.pl
new file mode 100755
index 0000000..341810d
--- /dev/null
+++ b/vere/ext/nasm/misc/emacstbl.pl
@@ -0,0 +1,215 @@
+#!/usr/bin/perl
+#
+# Automatically produce some tables useful for a NASM major mode
+#
+
+use integer;
+use strict;
+use File::Spec;
+
+my($outfile, $srcdir, $objdir) = @ARGV;
+
+if (!defined($outfile)) {
+    die "Usage: $0 outfile srcdir objdir\n";
+}
+
+$srcdir = File::Spec->curdir() unless (defined($srcdir));
+$objdir = $srcdir unless (defined($objdir));
+
+my %tokens = ();
+
+sub xpush($@) {
+    my $ref = shift @_;
+
+    $$ref = [] unless (defined($$ref));
+    return push(@$$ref, @_);
+}
+
+# Combine some specific token types
+my %override = ( 'id' => 'special',
+		 'float' => 'function',
+		 'floatize' => 'function',
+		 'strfunc' => 'function',
+		 'ifunc' => 'function',
+		 'insn' => 'instruction',
+		 'reg' => 'register',
+		 'seg' => 'special',
+		 'wrt' => 'special' );
+
+sub read_tokhash_c($) {
+    my($tokhash_c) = @_;
+
+    open(my $th, '<', $tokhash_c)
+	or die "$0:$tokhash_c: $!\n";
+
+    my $l;
+    my $tokendata = 0;
+    while (defined($l = <$th>)) {
+	if ($l =~ /\bstruct tokendata tokendata\[/) {
+	    $tokendata = 1;
+	    next;
+	} elsif (!$tokendata) {
+	    next;
+	}
+
+	last if ($l =~ /\}\;/);
+
+	if ($l =~ /^\s*\{\s*\"(.*?)\",.*?,\s*TOKEN_(\w+),.*\}/) {
+	    my $token = $1;
+	    my $type  = lc($2);
+
+	    if ($override{$type}) {
+		$type = $override{$type};
+	    } elsif ($token !~ /^\w/) {
+		$type = 'operator';
+	    } elsif ($token =~ /^__\?masm_.*\?__$/) {
+		next;
+	    }
+	    xpush(\$tokens{$type}, $token);
+	    if ($token =~ /^__\?(.*)\?__$/) {
+		# Also encode the "user" (macro) form without __?...?__
+		xpush(\$tokens{$type}, $1);
+	    }
+	}
+    }
+    close($th);
+}
+
+sub read_pptok_c($) {
+    my($pptok_c) = @_;
+
+    open(my $pt, '<', $pptok_c)
+	or die "$0:$pptok_c: $!\n";
+
+    my $l;
+    my $pp_dir = 0;
+
+    while (defined($l = <$pt>)) {
+	if ($l =~ /\bpp_directives\[/) {
+	    $pp_dir = 1;
+	    next;
+	} elsif (!$pp_dir) {
+	    next;
+	}
+
+	last if ($l =~ /\}\;/);
+
+	if ($l =~ /^\s*\"(.*?)\"/) {
+	    xpush(\$tokens{'pp-directive'}, $1);
+	}
+    }
+    close($pt);
+}
+
+sub read_directiv_dat($) {
+    my($directiv_dat) = @_;
+
+    open(my $dd, '<', $directiv_dat)
+	or die "$0:$directiv_dat: $!\n";
+
+    my $l;
+    my $directiv = 0;
+
+    while (defined($l = <$dd>)) {
+	if ($l =~ /^\; ---.*?(pragma)?/) {
+	    $directiv = ($1 ne 'pragma');
+	    next;
+	} elsif (!$directiv) {
+	    next;
+	}
+
+	if ($l =~ /^\s*(\w+)/) {
+	    xpush(\$tokens{'directive'}, $1);
+	}
+    }
+
+    close($dd);
+}
+
+my $version;
+sub read_version($) {
+    my($vfile) = @_;
+    open(my $v, '<', $vfile)
+	or die "$0:$vfile: $!\n";
+
+    $version = <$v>;
+    chomp $version;
+
+    close($v);
+}
+
+sub make_lines($$@) {
+    my $maxline = shift @_;
+    my $indent  = shift @_;
+
+    # The first line isn't explicitly indented and the last line
+    # doesn't end in "\n"; assumed the surrounding formatter wants
+    # do control that
+    my $linepos   = 0;
+    my $linewidth = $maxline - $indent;
+
+    my $line = '';
+    my @lines = ();
+
+    foreach my $w (@_) {
+	my $l = length($w);
+
+	if ($linepos > 0 && $linepos+$l+1 >= $linewidth) {
+	    $line .= "\n" . (' ' x $indent);
+	    push(@lines, $line);
+	    $linepos = 0;
+	    $line = '';
+	}
+	if ($linepos > 0) {
+	    $line .= ' ';
+	    $linepos++;
+	}
+	$line .= $w;
+	$linepos += $l;
+    }
+
+    if ($linepos > 0) {
+	push(@lines, $line);
+    }
+
+    return @lines;
+}
+
+sub quote_for_emacs(@) {
+    return map { s/[\\\"\']/\\$1/g; '"'.$_.'"' } @_;
+}
+
+sub write_output($) {
+    my($outfile) = @_;
+
+    open(my $out, '>', $outfile)
+	or die "$0:$outfile: $!\n";
+
+    my($vol,$dir,$file) = File::Spec->splitpath($outfile);
+
+    print $out ";;; ${file} --- lists of NASM assembler tokens\n";
+    print $out ";;;\n";
+    print $out ";;; This file contains list of tokens from the NASM x86\n";
+    print $out ";;; assembler, automatically extracted from NASM ${version}.\n";
+    print $out ";;;\n";
+    print $out ";;; This file is intended to be (require)d from a `nasm-mode\'\n";
+    print $out ";;; major mode definition.\n";
+
+    foreach my $type (sort keys(%tokens)) {
+	print $out "\n(defconst nasm-${type}\n";
+	print $out "  \'(";
+
+	print $out make_lines(78, 4, quote_for_emacs(sort @{$tokens{$type}}));
+	print $out ")\n";
+	print $out "  \"NASM ${version} ${type} tokens for `nasm-mode\'.\")\n";
+    }
+
+    close($out);
+}
+
+read_tokhash_c(File::Spec->catfile($objdir, 'asm', 'tokhash.c'));
+read_pptok_c(File::Spec->catfile($objdir, 'asm', 'pptok.c'));
+read_directiv_dat(File::Spec->catfile($srcdir, 'asm', 'directiv.dat'));
+read_version(File::Spec->catfile($srcdir, 'version'));
+
+write_output($outfile);
diff --git a/vere/ext/nasm/misc/exebin.mac b/vere/ext/nasm/misc/exebin.mac
new file mode 100644
index 0000000..8d1eaf8
--- /dev/null
+++ b/vere/ext/nasm/misc/exebin.mac
@@ -0,0 +1,57 @@
+; -*- nasm -*-
+; NASM macro file to allow the `bin' output format to generate
+; simple .EXE files by constructing the EXE header by hand.
+; Adapted from a contribution by Yann Guidon <whygee_corp@hol.fr>
+
+%define EXE_stack_size EXE_realstacksize
+
+%macro EXE_begin 0
+	  ORG 0E0h
+	  section .text
+
+header_start:
+	  db 4Dh,5Ah		; EXE file signature
+	  dw EXE_allocsize % 512
+	  dw (EXE_allocsize + 511) / 512
+	  dw 0			; relocation information: none
+	  dw (header_end-header_start)/16 ; header size in paragraphs
+	  dw (EXE_absssize + EXE_realstacksize) / 16 ; min extra mem
+	  dw (EXE_absssize + EXE_realstacksize) / 16 ; max extra mem
+	  dw -10h		; Initial SS (before fixup)
+	  dw EXE_endbss + EXE_realstacksize ; Initial SP (1K DPMI+1K STACK)
+	  dw 0			; (no) Checksum
+	  dw 100h		; Initial IP - start just after the header
+	  dw -10h		; Initial CS (before fixup)
+	  dw 0			; file offset to relocation table: none
+	  dw 0			; (no overlay)
+	  align 16,db 0
+header_end:
+
+EXE_startcode:
+	  section .data
+EXE_startdata:
+	  section .bss
+EXE_startbss:
+%endmacro
+
+%macro EXE_stack 1
+EXE_realstacksize equ %1
+%define EXE_stack_size EXE_bogusstacksize ; defeat EQU in EXE_end
+%endmacro
+
+%macro EXE_end 0
+	  section .text
+EXE_endcode:
+	  section .data
+EXE_enddata:
+	  section .bss
+	  alignb 4
+EXE_endbss:
+
+EXE_acodesize equ (EXE_endcode-EXE_startcode+3) & (~3)
+EXE_datasize equ EXE_enddata-EXE_startdata
+EXE_absssize equ (EXE_endbss-EXE_startbss+3) & (~3)
+EXE_allocsize equ EXE_acodesize + EXE_datasize
+
+EXE_stack_size equ 0x800	; default if nothing else was used
+%endmacro
diff --git a/vere/ext/nasm/misc/exebin2.mac b/vere/ext/nasm/misc/exebin2.mac
new file mode 100644
index 0000000..89c6889
--- /dev/null
+++ b/vere/ext/nasm/misc/exebin2.mac
@@ -0,0 +1,114 @@
+; -*- nasm -*-
+
+; NASM macro file to allow the `bin' output format to generate
+
+; simple .EXE files by constructing the EXE header by hand.
+
+; Adapted from a contribution by Yann Guidon <whygee_corp@hol.fr>
+
+
+
+%define EXE_stack_size EXE_realstacksize
+
+
+
+%macro EXE_begin 0
+
+	  ORG 0E0h
+
+	  section .text
+
+
+
+header_start:
+
+	  db 4Dh,5Ah		; EXE file signature
+
+	  dw EXE_allocsize % 512
+
+	  dw (EXE_allocsize + 511) / 512
+
+	  dw 0			; relocation information: none
+
+	  dw (header_end-header_start)/16 ; header size in paragraphs
+
+	  dw (EXE_absssize + EXE_realstacksize) / 16 ; min extra mem
+
+	  dw (EXE_absssize + EXE_realstacksize) / 16 ; max extra mem
+
+	  dw -10h		; Initial SS (before fixup)
+
+	  dw EXE_endbss + EXE_realstacksize ; Initial SP (1K DPMI+1K STACK)
+
+	  dw 0			; (no) Checksum
+
+	  dw 100h		; Initial IP - start just after the header
+
+	  dw -10h		; Initial CS (before fixup)
+
+	  dw 0			; file offset to relocation table: none
+
+	  dw 0			; (no overlay)
+
+	  align 16,db 0
+
+header_end:
+
+
+
+EXE_startcode:
+
+	  section .data
+
+EXE_startdata:
+
+	  section .bss
+
+EXE_startbss:
+
+%endmacro
+
+
+
+%macro EXE_stack 1
+
+EXE_realstacksize equ %1
+
+%define EXE_stack_size EXE_bogusstacksize ; defeat EQU in EXE_end
+
+%endmacro
+
+
+
+%macro EXE_end 0
+
+	  section .text
+
+EXE_endcode:
+
+	  section .data
+
+EXE_enddata:
+
+	  section .bss
+
+	  alignb 4
+
+EXE_endbss:
+
+
+
+EXE_acodesize equ (EXE_endcode-EXE_startcode+3) & (~3)
+
+EXE_datasize equ EXE_enddata-EXE_startdata
+
+EXE_absssize equ (EXE_endbss-EXE_startbss+3) & (~3)
+
+EXE_allocsize equ EXE_acodesize + EXE_datasize
+
+
+
+EXE_stack_size equ 0x800	; default if nothing else was used
+
+%endmacro
+
diff --git a/vere/ext/nasm/misc/fmtinsns.pl b/vere/ext/nasm/misc/fmtinsns.pl
new file mode 100755
index 0000000..848ee2d
--- /dev/null
+++ b/vere/ext/nasm/misc/fmtinsns.pl
@@ -0,0 +1,40 @@
+#!/usr/bin/perl
+#
+# Re-align the columns in insns.dat, and enforce case conventions
+#
+
+@cols = (0, 16, 48, 96);
+
+while ($line = <STDIN>) {
+    chomp $line;
+    if ($line !~ /^\s*(\;.*|)$/) {
+	($ln = $line) =~ s/\s+$//;
+	if ($line =~ /^\s*(\S+)\s+(\S+)\s+(\S+|\[.*\])\s+(\S+)\s*$/) {
+	    @fields = ($1, $2, $3, $4);
+	    $fields[0] = "\U$fields[0]" unless ($fields[0] =~ /^[^a-z]+cc$/);
+	    $fields[3] =~ s/\,+$//;
+	    $fields[3] = "\U$fields[3]" unless ($fields[3] eq 'ignore');
+	    $c = 0;
+	    $line = '';
+	    for ($i = 0; $i < scalar(@fields); $i++) {
+		if ($i > 0 && $c >= $cols[$i]) {
+		    $line .= ' ';
+		    $c++;
+		}	
+		while ($c < $cols[$i]) {
+		    $line .= "\t";
+		    $c = ($c+8)	& ~7;
+		}
+		$line .= $fields[$i];
+		for ($j = 0; $j < length($fields[$i]); $j++) {
+		    if (substr($fields[$i], $j, 1) eq "\t") {
+			$c = ($c+8) & ~7;
+		    } else {
+			$c++;
+		    }
+		}
+	    }
+	}
+    }
+    print $line, "\n";
+}
diff --git a/vere/ext/nasm/misc/genfma.pl b/vere/ext/nasm/misc/genfma.pl
new file mode 100755
index 0000000..2b6a65c
--- /dev/null
+++ b/vere/ext/nasm/misc/genfma.pl
@@ -0,0 +1,63 @@
+#!/usr/bin/perl
+%packed_insns = (
+    'vfmadd'    => 0x98,
+    'vfmaddsub' => 0x96,
+    'vfmsubadd' => 0x97,
+    'vfmsub'    => 0x9a,
+    'vfnmadd'   => 0x9c,
+    'vfnmsub'   => 0x9e
+    );
+
+%scalar_insns = (
+    'vfmadd'    => 0x99,
+    'vfmsub'    => 0x9b,
+    'vfnmadd'   => 0x9d,
+    'vfnmsub'   => 0x9f
+    );
+
+foreach $pi ( sort(keys(%packed_insns)) ) {
+    $op = $packed_insns{$pi};
+    foreach $order ('132', '213', '231') {
+	$xorder = substr($order,1,1).substr($order,0,1).substr($order,2,1);
+	foreach $o ($order, $xorder) {
+	    for ($w = 0; $w < 2; $w++) {
+		$suf = $w  ? 'pd' : 'ps';
+		for ($l = 128; $l <= 256; $l <<= 1) {
+		    $sx  = ($l == 256) ? 'SY' : 'SO';
+		    $mm  = ($l == 256) ? 'ymm' : 'xmm';
+		    printf "%-15s %-31s %-8s%-39s %s\n",
+		    	"\U${pi}${o}${suf}",
+			"${mm}reg,${mm}reg,${mm}rm",
+		    	"[rvm:",
+		        sprintf("vex.dds.%d.66.0f38.w%d %02x /r]",
+			    $l, $w, $op),
+		    "FMA,FUTURE,${sx}";
+		}
+	    }
+	}
+	$op += 0x10;
+    }
+}
+
+foreach $si ( sort(keys(%scalar_insns)) ) {
+    $op = $scalar_insns{$si};
+    foreach $order ('132', '213', '231') {
+	$xorder = substr($order,1,1).substr($order,0,1).substr($order,2,1);
+	foreach $o ($order, $xorder) {
+	    for ($w = 0; $w < 2; $w++) {
+		$suf = $w ? 'sd' : 'ss';
+		$sx  = $w ? 'SQ' : 'SD';
+		$l  = 128;
+		$mm  = 'xmm';
+		printf "%-15s %-31s %-8s%-39s %s\n",
+		    "\U${si}${o}${suf}",
+		    "${mm}reg,${mm}reg,${mm}rm",
+		    '[rvm:',
+		    sprintf("vex.dds.%d.66.0f38.w%d %02x /r]",
+			$l, $w, $op),
+		"FMA,FUTURE,${sx}";
+	    }
+	}
+	$op += 0x10;
+    }
+}
diff --git a/vere/ext/nasm/misc/hints.txt b/vere/ext/nasm/misc/hints.txt
new file mode 100644
index 0000000..576e1cf
--- /dev/null
+++ b/vere/ext/nasm/misc/hints.txt
@@ -0,0 +1,26 @@
+Subject: Re: [nasm-devel] P4 insns
+Date: Sat, 05 May 2001 11:39:36 -0500
+From: Kyle Markley <kmarkley@seffera.net>
+Reply-To: nasm-devel@yahoogroups.com
+To: nasm-devel@yahoogroups.com
+
+berkus wrote:
+>
+> Use The Source, NASM!
+>
+> Do we have the P4 'probable branch taken' (3e) and 'probable branch
+> not taken' (2e) prefixes opcodes?
+
+They're just segment override prefixes: 2e is CS, 3e is DS.  You can just
+say
+"cs jnz foo" for a not-taken hint, "ds jnz foo" for a taken hint.
+
+Maybe it would be nice to have a more suggestive name, but you could just
+%define one.
+
+---
+Kyle Markley
+
+
+
+Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
diff --git a/vere/ext/nasm/misc/magic b/vere/ext/nasm/misc/magic
new file mode 100644
index 0000000..0172f4a
--- /dev/null
+++ b/vere/ext/nasm/misc/magic
@@ -0,0 +1,6 @@
+# Put the following lines in your /etc/magic file to get 'file' to recognise
+# RDOFF Object Files
+
+0       string          RDOFF           RDOFF Object File
+>5      byte            >32             version %c (little endian)
+>5      byte            <32             version %d (big endian)
diff --git a/vere/ext/nasm/misc/myC32.mac b/vere/ext/nasm/misc/myC32.mac
new file mode 100644
index 0000000..e70fc82
--- /dev/null
+++ b/vere/ext/nasm/misc/myC32.mac
@@ -0,0 +1,121 @@
+; NASM macro set to make interfacing to 32-bit programs easier
+; Also cool little macros to make NASM emulate some MASM things.
+;
+; Originally included in NASM.  Modifications by Peter Johnson, 1999.
+;
+
+%imacro proc 1                  ; begin a procedure definition
+%push proc
+          global %1
+%1:       push  ebp
+          mov   ebp, esp
+%assign %$arg 8
+;%assign %$argnum 0
+%define %$procname %1
+%endmacro
+
+%imacro arg 0-1 4               ; used with the argument name as a label
+%00       equ %$arg
+;%assign %$argnum %$argnum+1
+;.arg%$argnum   equ     %1
+%assign %$arg %1+%$arg
+%endmacro
+
+%imacro endproc 0
+%ifnctx proc
+%error Mismatched `endproc'/`proc'
+%else
+;        mov     esp, ebp
+;        pop     ebp
+%ifdef LEGACY_ENDPROC
+        ret
+%endif
+;__end_%$procname:               ; useful for calculating function size
+;          global %{$procname}_arglen
+;%{$procname}_arglen    equ     %$arg-8
+;%assign %$i 1
+;%rep %$argnum
+;          global %{$procname}_arg%$i
+;%{$procname}_arg%$i    equ     %{$procname}.arg%$i
+;%assign %$i %$i+1
+;%endrep
+%pop
+%endif
+%endmacro
+
+; redefine ret instructions for in-proc cases
+%imacro ret 0-1
+%ifnctx proc
+	ret	%1
+%else
+	mov	esp, ebp
+	pop	ebp
+	ret	%1
+%endif
+%endmacro
+
+%imacro retf 0-1
+%ifnctx proc
+	retf	%1
+%else
+	mov	esp, ebp
+	pop	ebp
+	retf	%1
+%endif
+%endmacro
+
+%imacro retn 0-1
+%ifnctx proc
+	retn	%1
+%else
+	mov	esp, ebp
+	pop	ebp
+	retn	%1
+%endif
+%endmacro
+
+; invoke calls a C function
+; defaults to word (16 bit) size parameters
+%macro invoke 1-*
+%rotate -1
+;%define invoketype word
+%rep (%0-1)
+;       %ifidni %1,dword
+;               %define invoketype dword
+;       %elifidni %1,word
+;               %define invoketype word
+;       %elifidni %1,byte
+;               %define invoketype byte
+;       %else
+        %ifidni %1, cs
+                o16 push %1
+        %elifidni %1, ds
+                o16 push %1
+        %elifidni %1, es
+                o16 push %1
+        %elifidni %1, fs
+                o16 push %1
+        %elifidni %1, gs
+                o16 push %1
+        %elifidni %1, word cs
+                o16 push %1
+        %elifidni %1, word ds
+                o16 push %1
+        %elifidni %1, word es
+                o16 push %1
+        %elifidni %1, word fs
+                o16 push %1
+        %elifidni %1, word gs
+                o16 push %1
+        %else
+                push %1
+        %endif
+;       %endif
+        %rotate -1
+%endrep
+call %1
+%if (%0!=1)
+        add esp, byte %{1}_arglen
+%endif
+%endmacro
+
diff --git a/vere/ext/nasm/misc/nasm.sl b/vere/ext/nasm/misc/nasm.sl
new file mode 100644
index 0000000..2ddb5c1
--- /dev/null
+++ b/vere/ext/nasm/misc/nasm.sl
@@ -0,0 +1,320 @@
+% This file defines a NASM editor mode for the JED editor.
+% JED's home page is http://space.mit.edu/~davis/jed.html.
+%
+% To install, copy this file into your JED_LIBRARY directory
+% (/usr/local/jed/lib or C:\JED\LIB or whatever), then add the
+% following lines to your .jedrc or jed.rc file:
+%   autoload("nasm_mode", "nasm");
+%   add_mode_for_extension("nasm", "asm");
+% (you can of course replace "asm" with whatever file extension
+% you like to use for your NASM source files).
+
+variable Nasm_Instruction_Indent = 10;
+variable Nasm_Comment_Column = 33;
+variable Nasm_Comment_Space = 1;
+
+variable nasm_kw_2 = strcat("ahalaxbhblbpbtbxchclcscxdbdddhdidldqdsdtdwdxes",
+			    "fsgsinjajbjcjejgjljojpjsjzorsispssto");
+variable nasm_kw_3 = strncat("a16a32aaaaadaamaasadcaddandbsfbsrbtcbtrbtscbw",
+			     "cdqclccldclicmccmpcr0cr2cr3cr4cwddaadasdecdiv",
+			     "dr0dr1dr2dr3dr6dr7eaxebpebxecxediedxequesiesp",
+			     "farfldfsthltincintjaejbejgejlejmpjnajnbjncjne",
+			     "jngjnljnojnpjnsjnzjpejpolarldslealeslfslgslsl",
+			     "lssltrmm0mm1mm2mm3mm4mm5mm6mm7movmulnegnopnot",
+			     "o16o32outpopporrclrcrrepretrolrorrsmsalsarsbb",
+			     "segshlshrsmist0st1st2st3st4st5st6st7stcstdsti",
+			     "strsubtr3tr4tr5tr6tr7wrtxor", 9);
+variable nasm_kw_4 = strncat("arplbytecallcltscwdeemmsfabsfaddfbldfchsfcom",
+			     "fcosfdivfenifildfistfld1fldzfmulfnopfsinfstp",
+			     "fsubftstfxamfxchibtsidivimulinsbinsdinswint1",
+			     "int3intoinvdiretjcxzjnaejnbejngejnlelahflgdt",
+			     "lidtlldtlmswlocklongloopmovdmovqnearpandpopa",
+			     "popfpushpxorreperepzresbresdresqrestreswretf",
+			     "retnsahfsalcsetasetbsetcsetesetgsetlsetosetp",
+			     "setssetzsgdtshldshrdsidtsldtsmswtestumovverr",
+			     "verwwaitwordxaddxbtsxchg", 9);
+variable nasm_kw_5 = strncat("boundbswapcmovacmovbcmovccmovecmovgcmovlcmovo",
+			     "cmovpcmovscmovzcmpsbcmpsdcmpswcpuiddwordenter",
+			     "f2xm1faddpfbstpfclexfcomifcompfdisifdivpfdivr",
+			     "ffreefiaddficomfidivfimulfinitfistpfisubfldcw",
+			     "fldpifmulpfpremfptanfsavefsqrtfstcwfstswfsubp",
+			     "fsubrfucomfyl2xicebpint01iretdiretwjecxzleave",
+			     "lodsblodsdlodswloopeloopzmovsbmovsdmovswmovsx",
+			     "movzxoutsboutsdoutswpaddbpadddpaddwpandnpopad",
+			     "popawpopfdpopfwpslldpsllqpsllwpsradpsrawpsrld",
+			     "psrlqpsrlwpsubbpsubdpsubwpushapushfqwordrdmsr",
+			     "rdpmcrdtscrepnerepnzscasbscasdscaswsetaesetbe",
+			     "setgesetlesetnasetnbsetncsetnesetngsetnlsetno",
+			     "setnpsetnssetnzsetpesetposhortstosbstosdstosw",
+			     "timestwordwrmsrxlatb", 14);
+variable nasm_kw_6 = strncat("cmovaecmovbecmovgecmovlecmovnacmovnbcmovnc",
+			     "cmovnecmovngcmovnlcmovnocmovnpcmovnscmovnz",
+			     "cmovpecmovpofcmovbfcmovefcmovufcomipfcompp",
+			     "fdivrpficompfidivrfisubrfldenvfldl2efldl2t",
+			     "fldlg2fldln2fpatanfprem1frstorfscalefsetpm",
+			     "fstenvfsubrpfucomifucompincbininvlpgloopne",
+			     "loopnzpaddsbpaddswpmulhwpmullwpsubsbpsubsw",
+			     "pushadpushawpushfdpushfwsetnaesetnbesetnge",
+			     "setnlewbinvd", 9);
+variable nasm_kw_7 = strncat("cmovnaecmovnbecmovngecmovnlecmpxchgfcmovbe",
+			     "fcmovnbfcmovnefcmovnufdecstpfincstpfrndint",
+			     "fsincosfucomipfucomppfxtractfyl2xp1loadall",
+			     "paddusbpadduswpcmpeqbpcmpeqdpcmpeqwpcmpgtb",
+			     "pcmpgtdpcmpgtwpmaddwdpsubusbpsubusw", 5);
+variable nasm_kw_8 = "fcmovnbepackssdwpacksswbpackuswb";
+variable nasm_kw_9 = strcat("cmpxchg8bpunpckhbwpunpckhdqpunpckhwdpunpcklbw",
+			    "punpckldqpunpcklwd");
+variable nasm_kw_10 = "cmpxchg486loadall286";
+
+define nasm_indent_line() {
+    variable word, len, e, c;
+
+    e = eolp();
+
+    push_spot();
+    EXIT_BLOCK {
+	pop_spot();
+	if (what_column() <= Nasm_Instruction_Indent)
+	    skip_white();
+    }
+
+    bol_skip_white();
+    c = what_column();
+
+    if (orelse
+       {looking_at_char(';')}
+       {looking_at_char('#')}
+       {looking_at_char('[')}) {
+	bol_trim();
+	pop_spot();
+	EXIT_BLOCK {
+	}
+	return;
+    }
+
+    if (looking_at_char('%')) {
+	go_right_1();
+	!if (orelse
+	    {looking_at_char('$')}
+	    {looking_at_char('%')}
+	    {looking_at_char('+')}
+	    {looking_at_char('-')}
+	    {looking_at_char('0')}
+	    {looking_at_char('1')}
+	    {looking_at_char('2')}
+	    {looking_at_char('3')}
+	    {looking_at_char('4')}
+	    {looking_at_char('5')}
+	    {looking_at_char('6')}
+	    {looking_at_char('7')}
+	    {looking_at_char('8')}
+	    {looking_at_char('9')}) {
+	    bol_trim();
+	    pop_spot();
+	    EXIT_BLOCK {
+	    }
+	    return;
+	}
+	go_left_1();
+    }
+
+    push_mark();
+    skip_chars("%$+-");
+    skip_chars("0-9a-zA-Z_.");
+    word = bufsubstr();
+
+    if (orelse
+       {c == 1}
+       {looking_at_char(':')}) {
+	push_spot();
+	bol_trim();
+	pop_spot();
+	len = strlen(word);
+	if (looking_at_char(':')) {
+	    go_right_1();
+	    len++;
+	}
+	trim();
+	if (e or not(eolp())) {
+	    if (len >= Nasm_Instruction_Indent) {
+		pop();
+		whitespace(1);
+	    } else
+		whitespace(Nasm_Instruction_Indent - len);
+	    if (e) {
+		pop_spot();
+		eol();
+		push_spot();
+	    }
+	}
+    } else {
+	bol_trim();
+	whitespace(Nasm_Instruction_Indent);
+    }
+}
+
+define nasm_newline_indent() {
+    push_spot();
+    bol_skip_white();
+    if (eolp())
+	trim();
+    pop_spot();
+    newline();
+    nasm_indent_line();
+}
+
+define nasm_bol_self_ins() {
+    push_spot();
+    bskip_white();
+    bolp();
+    pop_spot();
+
+    call("self_insert_cmd");
+
+    % Grotty: force immediate update of the syntax highlighting.
+    insert_char('.');
+    deln(left(1));
+
+    if (())
+	nasm_indent_line();
+}
+
+define nasm_self_ins_ind() {
+    call("self_insert_cmd");
+
+    % Grotty: force immediate update of the syntax highlighting.
+    insert_char('.');
+    deln(left(1));
+
+    nasm_indent_line();
+}
+
+define nasm_insert_comment() {
+    variable spc;
+
+    bol_skip_white();
+    if (looking_at_char(';')) {
+	bol_trim();
+	go_right(1);
+	skip_white();
+	return;
+    } else if (eolp()) {
+	bol_trim();
+	insert("; ");
+	return;
+    }
+
+    forever {
+	skip_chars("^;\n'\"");
+	if (looking_at_char('\'')) {
+	    go_right_1();
+	    skip_chars("^'\n");
+	    !if (eolp())
+		go_right_1();
+	} else if (looking_at_char('\"')) {
+	    go_right_1();
+	    skip_chars("^\"\n");
+	    !if (eolp())
+		go_right_1();
+	} else if (looking_at_char(';')) {
+	    !if (bolp()) {
+		go_left_1();
+		trim();
+		!if (looking_at_char(';'))
+		    go_right_1();
+	    }
+	    break;
+	} else {
+	    break;
+	}
+    }
+    spc = Nasm_Comment_Column - what_column();
+    if (spc < Nasm_Comment_Space)
+	spc = Nasm_Comment_Space;
+    whitespace(spc);
+    if (eolp()) {
+	insert("; ");
+    } else {
+	go_right_1();
+	skip_white();
+    }
+}
+
+$1 = "NASM";
+create_syntax_table($1);
+
+define_syntax (";", "", '%', $1);
+define_syntax ("([", ")]", '(', $1);
+define_syntax ('"', '"', $1);
+define_syntax ('\'', '\'', $1);
+define_syntax ("0-9a-zA-Z_.@#", 'w', $1);
+define_syntax ("-+0-9a-fA-F.xXL", '0', $1);
+define_syntax (",:", ',', $1);
+define_syntax ('%', '#', $1);
+define_syntax ("|^&<>+-*/%~", '+', $1);
+
+set_syntax_flags($1,1);
+
+#ifdef HAS_DFA_SYNTAX
+
+dfa_enable_highlight_cache("nasm.dfa", $1);
+dfa_define_highlight_rule(";.*$", "comment", $1);
+dfa_define_highlight_rule("[A-Za-z_\\.\\?][A-Za-z0-9_\\.\\?\\$#@~]*",
+		      "Knormal", $1);
+dfa_define_highlight_rule("$([A-Za-z_\\.\\?][A-Za-z0-9_\\.\\?\\$#@~]*)?",
+		      "normal", $1);
+dfa_define_highlight_rule("[0-9]+(\\.[0-9]*)?([Ee][\\+\\-]?[0-9]*)?",
+		      "number", $1);
+dfa_define_highlight_rule("[0-9]+[QqBb]", "number", $1);
+dfa_define_highlight_rule("(0x|\\$[0-9A-Fa-f])[0-9A-Fa-f]*", "number", $1);
+dfa_define_highlight_rule("[0-9A-Fa-f]+[Hh]", "number", $1);
+dfa_define_highlight_rule("\"[^\"]*\"", "string", $1);
+dfa_define_highlight_rule("\"[^\"]*$", "string", $1);
+dfa_define_highlight_rule("'[^']*'", "string", $1);
+dfa_define_highlight_rule("'[^']*$", "string", $1);
+dfa_define_highlight_rule("[\\(\\)\\[\\],:]*", "delimiter", $1);
+dfa_define_highlight_rule("^[ \t]*#", "PQpreprocess", $1);
+dfa_define_highlight_rule("^[ \t]*\\%{?[^%\\$\\+\\-0-9]", "PQpreprocess", $1);
+dfa_define_highlight_rule("^%$", "preprocess", $1);
+dfa_define_highlight_rule("[\\|\\^&<>\\+\\-\\*/%~]*", "operator", $1);
+dfa_define_highlight_rule("%([%\\$]?-?[0-9A-Za-z_\\.\\?\\$~@]+|{[^}]*}?)",
+		      "preprocess", $1);
+dfa_define_highlight_rule("[ \t]*", "normal", $1);
+dfa_define_highlight_rule(".", "normal", $1);
+dfa_build_highlight_table($1);
+#endif
+
+define_keywords_n($1, nasm_kw_2, 2, 0);
+define_keywords_n($1, nasm_kw_3, 3, 0);
+define_keywords_n($1, nasm_kw_4, 4, 0);
+define_keywords_n($1, nasm_kw_5, 5, 0);
+define_keywords_n($1, nasm_kw_6, 6, 0);
+define_keywords_n($1, nasm_kw_7, 7, 0);
+define_keywords_n($1, nasm_kw_8, 8, 0);
+define_keywords_n($1, nasm_kw_9, 9, 0);
+define_keywords_n($1, nasm_kw_10, 10, 0);
+
+define_keywords_n($1, "org", 3, 1);
+define_keywords_n($1, "bitsiend", 4, 1);
+define_keywords_n($1, "aligngroupstruc", 5, 1);
+define_keywords_n($1, "alignbcommonexternglobalistruc", 6, 1);
+define_keywords_n($1, "sectionsegmentlibrary", 7, 1);
+define_keywords_n($1, "absoluteendstruc", 8, 1);
+define_keywords_n($1, "uppercase", 9, 1);
+
+!if (keymap_p ($1)) make_keymap ($1);
+definekey("nasm_bol_self_ins", ";", $1);
+definekey("nasm_bol_self_ins", "#", $1);
+definekey("nasm_bol_self_ins", "%", $1);
+definekey("nasm_bol_self_ins", "[", $1);
+definekey("nasm_self_ins_ind", ":", $1);
+definekey("nasm_insert_comment", "^[;", $1);
+
+define nasm_mode() {
+    set_mode("NASM", 4);
+    use_keymap ("NASM");
+    use_syntax_table ("NASM");
+    set_buffer_hook ("indent_hook", "nasm_indent_line");
+    set_buffer_hook ("newline_indent_hook", "nasm_newline_indent");
+    runhooks("nasm_mode_hook");
+}
diff --git a/vere/ext/nasm/misc/nasmstab b/vere/ext/nasm/misc/nasmstab
new file mode 100644
index 0000000..32ef67e
--- /dev/null
+++ b/vere/ext/nasm/misc/nasmstab
@@ -0,0 +1,296 @@
+#!/usr/bin/perl
+ 
+sub StabLine  ($ $ $ $ $ $) {
+        local ($comment,$n_strx,$type,$other,$desc,$value) = @_;
+        print $comment;
+        print "","dd",$n_strx;
+        print "","db",$type;
+        print "","db",$other;
+        print "","dw",$desc;
+        print "","dd","0" . $value . "h";
+}
+
+sub RStabLine  ($ $ $ $ $) {
+        local ($comment,$offset,$info,$type,$symbol) = @_;
+        print $comment;
+        print "","dd",$offset;
+        print "","db",$type;
+        print "","db",$symbol;
+        print "","dw",$info;
+}
+
+#this sub exists because i've no idea how to print non-ascii numbers in perl
+
+sub OutBin ( $ $ ) {
+        local ($offset, $shnum) = @_;
+        seek(FINAL,$offset,0);
+        if ( $shnum == 2 ) { printf FINAL "\x02" } ;
+        if ( $shnum == 3 ) { printf FINAL "\x03" } ;
+        if ( $shnum == 4 ) { printf FINAL "\x04" } ;
+        if ( $shnum == 5 ) { printf FINAL "\x05" } ;
+        if ( $shnum == 6 ) { printf FINAL "\x06" } ;
+        if ( $shnum == 7 ) { printf FINAL "\x07" } ;
+        if ( $shnum == 8 ) { printf FINAL "\x08" } ;
+        if ( $shnum == 9 ) { printf FINAL "\x09" } ;
+        if ( $shnum == 10 ) { printf FINAL "\x0a" } ;
+        if ( $shnum == 11 ) { printf FINAL "\x0b" } ;
+        if ( $shnum == 12 ) { printf FINAL "\x0c" } ;
+        if ( $shnum == 13 ) { printf FINAL "\x0d" } ;
+        if ( $shnum == 14 ) { printf FINAL "\x0e" } ;
+        if ( $shnum == 15 ) { printf FINAL "\x0f" } ;
+}
+
+sub DispHelp () {
+        $\="\n";
+        print "Usage:";
+        print "\t-f,--input-file";
+        print "\t\tThe input file name (only required option)";
+        print "\t-o,--output-file";
+        print "\t\tThe output file name (if not specified, *.asm becomes *.o";
+        print "\t\tand anything else becomes a.out)";
+        print "\t-l,--list-file";
+        print "\t\tThe listing file's name (default: trailing .asm is
+removed";
+        print "\t\tif there and .lst is appended)";
+        print "\t-s,--second-asm-file";
+        print "\t\tThe second asm file's name (default: trailing .asm is";
+        print "\t\tremoved if there and .nasm is appended)";
+        print "\n";
+        exit ;
+}
+
+if ( $ARGV[0] eq "" ) { $ARGV[0] = "-h" };
+
+$i = 0;
+$filename = "";
+$outname  = "";
+
+while ( $ARGV[$i] ne "" ) {
+        $_ = $ARGV[$i];
+        if ( m/^-/ ) {
+                if ( m/^-f$/ ) { $filename = $ARGV[++$i] };
+                if ( m/^-o$/ ) { $outname  = $ARGV[++$i] };
+                if ( m/^-l$/ ) { $listname = $ARGV[++$i] };
+                if ( m/^-s$/ ) { $asmname  = $ARGV[++$i] };
+                if ( m/^-h$/ ) { DispHelp };
+        } elsif ( m/^--\w+/ ) {
+                if ( m/^--input-file$/ )      { $filename = $ARGV[++$i] };
+                if ( m/^--output-file$/ )     { $outname  = $ARGV[++$i] };
+                if ( m/^--list-file$/ )       { $listname = $ARGV[++$i] };
+                if ( m/^--second-asm-file$/ ) { $asmname  = $ARGV[++$i] };
+                if ( m/^--help/ ) { DispHelp };
+        } elsif ( m/^--$/ ) {
+                while ( $ARGV[++$i] ) {
+                        $NasmOptions .= " ";
+                        $NasmOptions .= $_;
+                };
+        } else {
+                DispHelp()
+        };
+        $i++;
+};
+
+if ( $filename eq "" ) { DispHelp() };
+
+if ( $outname eq "" ) {
+        $outname = $filename;
+        $outname =~ s/\.asm/.o/;
+        if ( $outname eq $filename ) { $outname = "a.out" };
+};
+
+if ( $listname eq "" ) {
+        $listname = $filename;
+        $listname =~ s/\.asm//;
+        $listname .= ".lst";
+};
+
+if ( $asmname eq "" ) {
+        $asmname = $filename;
+        $asmname =~ s/\.asm//;
+        $asmname .= ".nasm";
+};
+
+$err = `nasm -f elf ${filename} -l ${listname} -o ${outname} `;
+
+if ( $err ) { die "\n$err\n"};
+
+open(LISTFILE,"${listname}") or die "\n $0: Could not reopen list file!\n";
+open(ASMFILE,">${asmname}")  or die "\n $0: Could not open asm file!\n";
+
+select ASMFILE;
+
+open(OLDASM,$filename) or die "\n$0: Cannot open file $filename\n";
+
+while ( $x = <OLDASM> ) {
+        print $x;
+}
+
+@stab = ("n_desc", "value");
+@rel_stab = ("offset");
+$i = 0;
+$current_section = "";
+$has_text = 'FALSE';
+$midst_of_macro = 'FALSE';
+$line_dec = 0 ;
+
+while ( $x = <LISTFILE> ) {
+        if ( $x =~ m/[^;]*%include/ ) {
+                $x = <LISTFILE>;
+                while ( $x =~ m/\s+\d+\s+\<\d+\>\s+/ ) {
+                        $x = <LISTFILE>;
+                        $line_dec++;
+                }
+        }
+        if ( $current_section eq ".text" ) {
+                if ( $x =~ m/^\s+(\S+)\s+(\S+)\s+(\S+)\s+[^<]+$/ ) {
+                        $stab[$i++] = $1-$line_dec;     #linenum
+                        $stab[$i++] = $2;               #offset
+                        $count++;
+                        if ( $3 =~ m/-/ ) {
+                                $x = <LISTFILE>;
+                                $line_dec++;
+                        }
+                        $midst_of_macro = 'FALSE';
+                } elsif ( $x =~ m/^\s+(\S+)\s+(\S+)\s+(\S+)\s+<\d+>/ ) {
+                        if ( $midst_of_macro eq 'TRUE' ) {
+                                $stab[$i] = $stab[$i-2]; #same linenum
+                                $line_dec++;
+                        } else {
+                                $stab[$i] = $1 - ++$line_dec;
+                                $midst_of_macro = 'TRUE';
+                        }
+                        $count++;
+                        $i++;
+                        $stab[$i++] = $2;
+                        if ( $3 =~ m/-/ ) {
+                                $x = <LISTFILE>;
+                                $line_dec++;
+                        }
+
+                }
+                $has_text = 'TRUE';
+        } elsif ( $x =~ m/\s+\S+\s+\S+\s+\S+\s+<\d+>/ ) { # is it a macro?
+                $line_dec++;
+        }
+        if ( $x =~ s/(section|segment)\s+([^\s]+)/$2/ ) {
+                        $current_section = $2;
+        }
+};
+
+close LISTFILE;
+
+unless ( $has_text eq "TRUE" ) {
+        $err = `nasm -f elf ${asmname} -o ${outname}`;
+        print STDERR $err;
+        exit;
+}
+
+#Write Stab section
+$, = "\t";      #output field separator
+$\ = "\n";      #output record separator
+
+print "section .stab noalloc";
+StabLine(";header",1,0,0,$count+1,length($filename)*2+3);
+StabLine(";so",length($asmname)+2,"064h",0,0,0);
+
+$offset = 12;
+$i = 0;
+$j = 0;
+$rel_stab[$j++] = $offset + 8;
+
+while ( $stab[$i] ) {
+        StabLine(";N_SLINE" . " " . ( ($i+2) / 2 ), 0, "044h", 0,
+                $stab[$i++], $stab[$i++]);
+        $offset += 12;
+        $rel_stab[$j++] = $offset + 8;
+}
+
+#Write .rel.stab section
+print "\n\nsection .rel.stab noalloc";
+
+open (READELF,"readelf -s ${outname} |") or die "\n$0: Could not run readelf\n";
+
+while ( $x = <READELF> ) {
+   if ( $x =~ m/\s+(\d+):\s+00000000\s+\d+\s+SECTION\s+\w+\s+\w+\s+1\s+/){ $textsymnum = $1;
+   };
+};
+close READELF;
+
+$i = 0;
+
+while ( $rel_stab[$i] ne "" ) {
+        RStabLine(";relocation for N_SLINE " . ($i), $rel_stab[$i], 0, 1, $textsymnum);
+        $i++;
+} ;
+
+#Write .stabstr section
+
+print "\n\nsection .stabstr noalloc";
+
+print "","db","0";
+print "","db",'"' . $asmname . '"';
+print "","db","0";
+print "","db",'"' . $asmname . '"' ;
+print "","db","0";
+
+close ASMFILE;
+
+$err = `nasm -f elf ${asmname} -o ${outname}`;
+
+if ( $err ) { die "\n$err\n" } ;
+
+open (READELF,"readelf -h -S ${outname} |") or die "\n$0: Could not run readelf\n";
+
+
+while ( $x = <READELF> ) {
+        if ( $x =~ m/Start\s+of\s+section\s+headers:\s+(\d+)\s+/ ) {
+                $shoff = $1;
+        }
+        if ( $x =~ m/Size\s+of\s+section\s+headers:\s+(\d+)\s+/ ) {
+                $shentsize = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.rel.stab\s+/ ) {
+                $relnum = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.stab\s+/ ) {
+                $stabnum = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.stabstr\s+/ ) {
+                $stabstrnum = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.symtab\s+/ ) {
+                $symtabnum = $1;
+        }
+}
+close READELF;
+
+sysopen (FINAL,"${outname}",2,0) or die "\n$0: Could not open ${outname}";
+$, = "";        #output field separator
+$\ = "";        #output record separator
+
+#set .rel.stab->type to rel
+OutBin($shoff + ($shentsize * $relnum) + 4,9);
+
+#set .rel.stab->link to .symtab
+OutBin($shoff + ($shentsize * $relnum) + 24,$symtabnum);
+
+#set .rel.stab->info to .stab
+OutBin($shoff + ($shentsize * $relnum) + 28,$stabnum);
+
+#set .rel.stab->entsize to 8
+OutBin($shoff + ($shentsize * $relnum) + 36,8);
+
+#set .stab->link to .stabstr
+OutBin($shoff + ($shentsize * $stabnum) + 24,$stabstrnum);
+
+#set .stab->entsize to 12
+OutBin($shoff + ($shentsize * $stabnum) + 36,12);
+
+#set .stabstr->type to strtab
+OutBin($shoff + ($shentsize * $stabstrnum) + 4,3);
+
+close FINAL;
+
+#Date: 17 Mar 2002 15:51:20 -0800
+#From: kitsred@hotmail.com (kired)
+#Newsgroups: alt.lang.asm
diff --git a/vere/ext/nasm/misc/omfdump.c b/vere/ext/nasm/misc/omfdump.c
new file mode 100644
index 0000000..b27e7c9
--- /dev/null
+++ b/vere/ext/nasm/misc/omfdump.c
@@ -0,0 +1,516 @@
+/*
+ * omfdump.c
+ *
+ * Very simple program to dump the contents of an OMF (OBJ) file
+ *
+ * This assumes a littleendian, unaligned-load-capable host and a
+ * C compiler which handles basic C99.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+const char *progname;
+
+static const char *record_types[256] =
+{
+    [0x80] = "THEADR",
+    [0x82] = "LHEADR",
+    [0x88] = "COMENT",
+    [0x8a] = "MODEND16",
+    [0x8b] = "MODEND32",
+    [0x8c] = "EXTDEF",
+    [0x90] = "PUBDEF16",
+    [0x91] = "PUBDEF32",
+    [0x94] = "LINNUM16",
+    [0x95] = "LINNUM32",
+    [0x96] = "LNAMES",
+    [0x98] = "SEGDEF16",
+    [0x99] = "SEGDEF32",
+    [0x9a] = "GRPDEF",
+    [0x9c] = "FIXUPP16",
+    [0x9d] = "FIXUPP32",
+    [0xa0] = "LEDATA16",
+    [0xa1] = "LEDATA32",
+    [0xa2] = "LIDATA16",
+    [0xa3] = "LIDATA32",
+    [0xb0] = "COMDEF",
+    [0xb2] = "BAKPAT16",
+    [0xb3] = "BAKPAT32",
+    [0xb4] = "LEXTDEF",
+    [0xb6] = "LPUBDEF16",
+    [0xb7] = "LPUBDEF32",
+    [0xb8] = "LCOMDEF",
+    [0xbc] = "CEXTDEF",
+    [0xc2] = "COMDAT16",
+    [0xc3] = "COMDAT32",
+    [0xc4] = "LINSYM16",
+    [0xc5] = "LINSYM32",
+    [0xc6] = "ALIAS",
+    [0xc8] = "NBKPAT16",
+    [0xc9] = "NBKPAT32",
+    [0xca] = "LLNAMES",
+    [0xcc] = "VERNUM",
+    [0xce] = "VENDEXT",
+    [0xf0] = "LIBHDR",
+    [0xf1] = "LIBEND",
+};
+
+typedef void (*dump_func)(uint8_t, const uint8_t *, size_t);
+
+/* Ordered collection type */
+struct collection {
+    size_t n;			/* Elements in collection (not including 0) */
+    size_t s;			/* Elements allocated (not including 0) */
+    const void **p;		/* Element pointers */
+};
+
+struct collection c_names, c_lsegs, c_groups, c_extsym;
+
+static void nomem(void)
+{
+    fprintf(stderr, "%s: memory allocation error\n", progname);
+    exit(1);
+}
+
+#define INIT_SIZE 64
+static void add_collection(struct collection *c, const void *p)
+{
+    if (c->n >= c->s) {
+	size_t cs = c->s ? (c->s << 1) : INIT_SIZE;
+	const void **cp = realloc(c->p, cs*sizeof(const void *));
+
+	if (!cp)
+	    nomem();
+
+	c->p = cp;
+	c->s = cs;
+
+	memset(cp + c->n, 0, (cs - c->n)*sizeof(const void *));
+    }
+
+    c->p[++c->n] = p;
+}
+
+static const void *get_collection(struct collection *c, size_t index)
+{
+    if (index >= c->n)
+	return NULL;
+
+    return c->p[index];
+}
+
+static void hexdump_data(unsigned int offset, const uint8_t *data,
+                         size_t n, size_t field)
+{
+    unsigned int i, j;
+
+    for (i = 0; i < n; i += 16) {
+	printf("   %04x: ", i+offset);
+	for (j = 0; j < 16; j++) {
+            char sep = (j == 7) ? '-' : ' ';
+	    if (i+j < field)
+		printf("%02x%c", data[i+j], sep);
+	    else if (i+j < n)
+                printf("xx%c", sep); /* Beyond end of... */
+            else
+		printf("   ");  /* No separator */
+	}
+	printf(" :  ");
+	for (j = 0; j < 16; j++) {
+            if (i+j < n)
+                putchar((i+j >= field) ? 'x' :
+                        isprint(data[i+j]) ? data[i+j] : '.');
+	}
+	putchar('\n');
+    }
+}
+
+static void dump_unknown(uint8_t type, const uint8_t *data, size_t n)
+{
+    (void)type;
+    hexdump_data(0, data, n, n);
+}
+
+static void print_dostime(const uint8_t *p)
+{
+    uint16_t da = (p[3] << 8) + p[2];
+    uint16_t ti = (p[1] << 8) + p[0];
+
+    printf("%04u-%02u-%02u %02u:%02u:%02u",
+           (da >> 9) + 1980, (da >> 5) & 15, da & 31,
+           (ti >> 11), (ti >> 5) & 63, (ti << 1) & 63);
+}
+
+static void dump_coment_depfile(uint8_t type, const uint8_t *data, size_t n)
+{
+    if (n > 4 && data[4] == n-5) {
+        printf("   # ");
+        print_dostime(data);
+        printf("  %.*s\n", n-5, data+5);
+    }
+
+    hexdump_data(2, data, n, n);
+}
+
+static const dump_func dump_coment_class[256] = {
+    [0xe9] = dump_coment_depfile
+};
+
+static void dump_coment(uint8_t type, const uint8_t *data, size_t n)
+{
+    uint8_t class;
+    static const char *coment_class[256] = {
+	[0x00] = "Translator",
+	[0x01] = "Copyright",
+	[0x81] = "Library specifier",
+	[0x9c] = "MS-DOS version",
+	[0x9d] = "Memory model",
+	[0x9e] = "DOSSEG",
+	[0x9f] = "Library search",
+	[0xa0] = "OMF extensions",
+	[0xa1] = "New OMF extension",
+	[0xa2] = "Link pass separator",
+	[0xa3] = "LIBMOD",
+	[0xa4] = "EXESTR",
+	[0xa6] = "INCERR",
+	[0xa7] = "NOPAD",
+	[0xa8] = "WKEXT",
+	[0xa9] = "LZEXT",
+	[0xda] = "Comment",
+	[0xdb] = "Compiler",
+	[0xdc] = "Date",
+	[0xdd] = "Timestamp",
+	[0xdf] = "User",
+        [0xe3] = "Type definition",
+        [0xe8] = "Filename",
+	[0xe9] = "Dependency file",
+	[0xff] = "Command line"
+    };
+
+    if (n < 2) {
+	hexdump_data(type, data, 2, n);
+	return;
+    }
+
+    type  = data[0];
+    class = data[1];
+
+    printf("   [NP=%d NL=%d UD=%02X] %02X %s\n",
+	   (type >> 7) & 1,
+	   (type >> 6) & 1,
+	   type & 0x3f,
+	   class,
+	   coment_class[class] ? coment_class[class] : "???");
+
+    if (dump_coment_class[class])
+        dump_coment_class[class](class, data+2, n-2);
+    else
+        hexdump_data(2, data+2, n-2, n-2);
+}
+
+/* Parse an index field */
+static uint16_t get_index(const uint8_t **pp)
+{
+    uint8_t c;
+
+    c = *(*pp)++;
+    if (c & 0x80) {
+        return ((c & 0x7f) << 8) + *(*pp)++;
+    } else {
+        return c;
+    }
+}
+
+static uint16_t get_16(const uint8_t **pp)
+{
+    uint16_t v = *(const uint16_t *)(*pp);
+    (*pp) += 2;
+
+    return v;
+}
+
+static uint32_t get_32(const uint8_t **pp)
+{
+    const uint32_t v = *(const uint32_t *)(*pp);
+    (*pp) += 4;
+
+    return v;
+}
+
+/* Returns a name as a C string in a newly allocated buffer */
+char *lname(int index)
+{
+    char *s;
+    const char *p = get_collection(&c_names, index);
+    size_t len;
+
+    if (!p)
+	return NULL;
+
+    len = (uint8_t)p[0];
+
+    s = malloc(len+1);
+    if (!s)
+	nomem();
+
+    memcpy(s, p+1, len);
+    s[len] = '\0';
+
+    return s;
+}
+
+/* LNAMES or LLNAMES */
+static void dump_lnames(uint8_t type, const uint8_t *data, size_t n)
+{
+    const uint8_t *p = data;
+    const uint8_t *end = data + n;
+
+    while (p < end) {
+        size_t l = *p+1;
+        if (l > n) {
+	    add_collection(&c_names, NULL);
+            printf("   # %4u 0x%04x: \"%.*s... <%zu missing bytes>\n",
+                   c_names.n, c_names.n, n-1, p+1, l-n);
+        } else {
+	    add_collection(&c_names, p);
+            printf("   # %4u 0x%04x: \"%.*s\"\n",
+		   c_names.n, c_names.n, l-1, p+1);
+        }
+        hexdump_data(p-data, p, l, n);
+        p += l;
+        n -= l;
+    }
+}
+
+/* SEGDEF16 or SEGDEF32 */
+static void dump_segdef(uint8_t type, const uint8_t *data, size_t n)
+{
+    bool big = type & 1;
+    const uint8_t *p = data;
+    const uint8_t *end = data+n;
+    uint8_t attr;
+    static const char * const alignment[8] =
+	{ "ABS", "BYTE", "WORD", "PARA", "PAGE", "DWORD", "LTL", "?ALIGN" };
+    static const char * const combine[8] =
+	{ "PRIVATE", "?COMMON", "PUBLIC", "?COMBINE", "?PUBLIC", "STACK", "COMMON", "?PUBLIC" };
+    uint16_t idx;
+    char *s;
+
+    if (p >= end)
+	return;
+
+    attr = *p++;
+
+    printf("   # %s (A%u) %s (C%u) %s%s",
+	   alignment[(attr >> 5) & 7], (attr >> 5) & 7,
+	   combine[(attr >> 2) & 7], (attr >> 2) & 7,
+	   (attr & 0x02) ? "MAXSIZE " : "",
+	   (attr & 0x01) ? "USE32" : "USE16");
+
+    if (((attr >> 5) & 7) == 0) {
+	/* Absolute segment */
+	if (p+3 > end)
+	    goto dump;
+	printf(" AT %04x:", get_16(&p));
+	printf("%02x", *p++);
+    }
+
+    if (big) {
+	if (p+4 > end)
+	    goto dump;
+	printf(" size 0x%08x", get_32(&p));
+    } else {
+	if (p+2 > end)
+	    goto dump;
+	printf(" size 0x%04x", get_16(&p));
+    }
+
+    idx = get_index(&p);
+    if (p > end)
+	goto dump;
+    s = lname(idx);
+    printf(" name '%s'", s);
+
+    idx = get_index(&p);
+    if (p > end)
+	goto dump;
+    s = lname(idx);
+    printf(" class '%s'", s);
+
+    idx = get_index(&p);
+    if (p > end)
+	goto dump;
+    s = lname(idx);
+    printf(" ovl '%s'", s);
+
+dump:
+    putchar('\n');
+    hexdump_data(0, data, n, n);
+}
+
+/* FIXUPP16 or FIXUPP32 */
+static void dump_fixupp(uint8_t type, const uint8_t *data, size_t n)
+{
+    bool big = type & 1;
+    const uint8_t *p = data;
+    const uint8_t *end = data + n;
+    static const char * const method_base[4] =
+        { "SEGDEF", "GRPDEF", "EXTDEF", "frame#" };
+
+    while (p < end) {
+        const uint8_t *start = p;
+        uint8_t op = *p++;
+        uint16_t index;
+        uint32_t disp;
+
+        if (!(op & 0x80)) {
+            /* THREAD record */
+            bool frame = !!(op & 0x40);
+
+            printf("   THREAD %-7s%d%s method %c%d (%s)",
+                   frame ? "frame" : "target", op & 3,
+                   (op & 0x20) ? " +flag5?" : "",
+                   (op & 0x40) ? 'F' : 'T',
+                   op & 3, method_base[op & 3]);
+
+            if ((op & 0x50) != 0x50) {
+                printf(" index 0x%04x", get_index(&p));
+            }
+            putchar('\n');
+        } else {
+            /* FIXUP subrecord */
+            uint8_t fix;
+
+            printf("   FIXUP  %s-rel location %2d offset 0x%03x",
+                   (op & 0x40) ? "seg" : "self",
+                   (op & 0x3c) >> 2,
+                   ((op & 3) << 8) + *p++);
+
+            fix = *p++;
+            printf("\n          frame %s%d%s",
+                   (fix & 0x80) ? "thread " : "F",
+                   ((fix & 0x70) >> 4),
+                   ((fix & 0xc0) == 0xc0) ? "?" : "");
+
+            if ((fix & 0xc0) == 0)
+                printf(" datum 0x%04x", get_index(&p));
+
+            printf("\n          target %s%d",
+                   (fix & 0x10) ? "thread " : "method T",
+                   fix & 3);
+
+            if ((fix & 0x10) == 0)
+                printf(" (%s)", method_base[fix & 3]);
+
+            printf(" datum 0x%04x", get_index(&p));
+
+            if ((fix & 0x08) == 0) {
+                if (big) {
+                    printf(" disp 0x%08x", get_32(&p));
+                } else {
+                    printf(" disp 0x%04x", get_16(&p));
+                }
+            }
+            putchar('\n');
+        }
+        hexdump_data(start-data, start, p-start, n-(start-data));
+    }
+}
+
+static const dump_func dump_type[256] =
+{
+    [0x88] = dump_coment,
+    [0x96] = dump_lnames,
+    [0x98] = dump_segdef,
+    [0x99] = dump_segdef,
+    [0x9c] = dump_fixupp,
+    [0x9d] = dump_fixupp,
+    [0xca] = dump_lnames,
+};
+
+int dump_omf(int fd)
+{
+    struct stat st;
+    size_t len, n;
+    uint8_t type;
+    const uint8_t *p, *data;
+
+    if (fstat(fd, &st))
+	return -1;
+
+    len = st.st_size;
+
+    data = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (data == MAP_FAILED)
+	return -1;
+
+    p = data;
+    while (len >= 3) {
+	uint8_t csum;
+	int i;
+
+	type = p[0];
+	n = *(uint16_t *)(p+1);
+
+	printf("%02x %-10s %4zd bytes",
+	       type,
+	       record_types[type] ? record_types[type] : "???",
+	       n);
+
+	if (len < n+3) {
+	    printf("\n  (truncated, only %zd bytes left)\n", len-3);
+	    break;		/* Truncated */
+	}
+
+	p += 3;	      /* Header doesn't count in the length */
+	n--;	      /* Remove checksum byte */
+
+	csum = 0;
+	for (i = -3; i < (int)n; i++)
+	    csum -= p[i];
+
+	printf(", checksum %02X", p[i]);
+	if (csum == p[i])
+	    printf(" (valid)\n");
+	else
+	    printf(" (actual = %02X)\n", csum);
+
+	if (dump_type[type])
+	    dump_type[type](type, p, n);
+	else
+	    dump_unknown(type, p, n);
+
+	p   += n+1;
+	len -= (n+4);
+    }
+
+    munmap((void *)data, st.st_size);
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+    int fd;
+    int i;
+
+    progname = argv[0];
+
+    for (i = 1; i < argc; i++) {
+	fd = open(argv[i], O_RDONLY);
+	if (fd < 0 || dump_omf(fd)) {
+	    perror(argv[i]);
+	    return 1;
+	}
+	close(fd);
+    }
+
+    return 0;
+}
diff --git a/vere/ext/nasm/misc/pmw.bat b/vere/ext/nasm/misc/pmw.bat
new file mode 100644
index 0000000..88b67a5
--- /dev/null
+++ b/vere/ext/nasm/misc/pmw.bat
@@ -0,0 +1,9 @@
+@echo off
+rem some batch file to bind nasm and ndisasm with pmode/w
+rem a mega cool dos extender for watcom done by tran
+rem 
+rem max 8 megs, dpmi stack 256*16=4096, no banner
+pmwlite.exe nasm.exe
+pmwsetup.exe /X8388608 /P256 /B0 nasm.exe
+pmwlite.exe ndisasm.exe
+pmwsetup.exe /X8388608 /P256 /B0 ndisasm.exe
diff --git a/vere/ext/nasm/misc/proc32.ash b/vere/ext/nasm/misc/proc32.ash
new file mode 100644
index 0000000..b0633ec
--- /dev/null
+++ b/vere/ext/nasm/misc/proc32.ash
@@ -0,0 +1,441 @@
+;--------=========xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=========--------
+;
+;   Copyright (C) 1999 by Andrew Zabolotny
+;   Miscellaneous NASM macros that makes use of new preprocessor features
+;
+;   This library is free software; you can redistribute it and/or
+;   modify it under the terms of the GNU Library General Public
+;   License as published by the Free Software Foundation; either
+;   version 2 of the License, or (at your option) any later version.
+;
+;   This library is distributed in the hope that it will be useful,
+;   but WITHOUT ANY WARRANTY; without even the implied warranty of
+;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;   Library General Public License for more details.
+;
+;   You should have received a copy of the GNU Library General Public
+;   License along with this library; if not, write to the Free
+;   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+;
+;--------=========xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=========--------
+
+;   The macros in this file provides support for writing 32-bit C-callable
+;   NASM routines. For a short description of every macros see the
+;   corresponding comment before every one. Simple usage example:
+;
+;	proc	sin,1
+;		targ	%$angle
+;		fld	%$angle
+;		fsin
+;	endproc	sin
+
+%ifndef __PROC32_ASH__
+%define __PROC32_ASH__
+
+[WARNING -macro-selfref]
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Mangle a name to be compatible with the C compiler
+; Arguments:
+;   The name
+; Example:
+;		cname (my_func)
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%ifdef EXTERNC_UNDERSCORE
+		%define	cname(x) _ %+ x
+%else
+		%define	cname(x) x
+%endif
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Import an external C procedure definition
+; Arguments:
+;   The name of external C procedure
+; Example:
+;		cextern	printf
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		cextern	1
+		%xdefine %1 cname(%1)
+	%ifidni __OUTPUT_FORMAT__,obj
+		extern	%1:wrt FLAT
+	%else
+		extern	%1
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Export an C procedure definition
+; Arguments:
+;   The name of C procedure
+; Example:
+;		cglobal	my_printf
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		cglobal	1
+		%xdefine %1 cname(%1)
+		global	%1
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Misc macros to deal with PIC shared libraries
+; Comment:
+;   Note that we have a different syntax for working with and without
+;   PIC shared libraries. In a PIC environment we should load first
+;   the address of the variable into a register and then work through
+;   that address, i.e: mov eax,myvar; mov [eax],1
+;   In a non-PIC environment we should directly write: mov myvar,1
+; Example:
+;		extvar	myvar
+;		GetGOT
+;	%ifdef PIC
+;		mov	ebx,myvar	; get offset of myvar into ebx
+;	%else
+;		lea	ebx,myvar
+;	%endif
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%ifdef PIC
+		cextern	_GLOBAL_OFFSET_TABLE_
+	%macro	GetGOT	0
+		%ifdef .$proc.stkofs
+			%assign .$proc.stkofs .$proc.stkofs+4
+		%endif
+		call	%$Get_GOT
+	%$Get_GOT:
+		pop	ebx
+		add	ebx,_GLOBAL_OFFSET_TABLE_ + $$ - %$Get_GOT wrt ..gotpc
+	%endmacro
+	%macro	extvar	1
+		cextern	%1
+		%xdefine %1 [ebx+%1 wrt ..got]
+	%endmacro
+%else
+	%define	GetGOT
+	%macro	extvar	1
+		cextern	%1
+	%endmacro
+%endif
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Begin a procedure definition
+;   For performance reasons we don't use stack frame pointer EBP,
+;   instead we're using the [esp+xx] addressing. Because of this
+;   you should be careful when you work with stack pointer.
+;   The push/pop instructions are macros that are defined to
+;   deal correctly with these issues.
+; Arguments:
+;   First argument - the procedure name
+;   Second optional argument - the number of bytes for local variables
+;   The following arguments could specify the registers that should be
+;   pushed at beginning of procedure and popped before exiting
+; Example:
+;   proc	MyTestProc
+;   proc	MyTestProc,4,ebx,esi,edi
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		proc	1-3+ 0
+		cglobal	%1
+		%push	%1
+		align	16
+%1:
+		%xdefine %$proc.name %1
+	; total size of local arguments
+		%assign %$proc.locsize (%2+3) & 0xFFFC
+	; offset from esp to argument
+		%assign	%$proc.argofs 4+%$proc.locsize
+	; additional offset to args (tracks push/pops)
+		%assign	.$proc.stkofs 0
+	; offset from esp to local arguments
+		%assign %$proc.locofs 0
+	; Now push the registers that we should save
+		%define %$proc.save %3
+	%if %$proc.locsize != 0
+		sub	esp,%$proc.locsize
+	%endif
+		push	%$proc.save
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Declare an argument passed on stack
+;   This macro defines two additional macros:
+;     first (with the name given by first argument) - [esp+xx]
+;     second (with a underscore appended to first argument) - esp+xx
+; Arguments:
+;   First argument defines the procedure argument name
+;   Second optional parameter defines the size of the argument
+;   Default value is 4 (a double word)
+; Example:
+;		arg	.my_float
+;		arg	.my_double,8
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		arg	1-2 4
+	%ifndef %$proc.argofs
+		%error	"`arg' not in a proc context"
+	%else
+	; Trick: temporary undefine .$proc.stkofs so that it won't be expanded
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %{1}_ esp+%$proc.argofs+.$proc.stkofs
+		%xdefine %1 [esp+%$proc.argofs+.$proc.stkofs]
+		%assign .$proc.stkofs %%.
+		%assign %$proc.argofs %2+%$proc.argofs
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Declare an local variable
+;     first (with the name given by first argument) - [esp+xx]
+;     second (with  a slash prefixing the first argument) - esp+xx
+; Arguments:
+;   First argument defines the procedure argument name
+;   Second optional parameter defines the size of the argument
+;   Default value is 4 (a double word)
+; Example:
+;		loc	.int_value
+;		loc	.double_value,8
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		loc	1-2 4
+	%ifndef %$proc.locofs
+		%error	"`loc' not in a proc context"
+	%elif %$proc.locofs + %2 > %$proc.locsize
+		%error	"local stack space exceeded"
+	%else
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %{1}_ esp+%$proc.locofs+.$proc.stkofs
+		%xdefine %1 [esp+%$proc.locofs+.$proc.stkofs]
+		%assign .$proc.stkofs %%.
+		%assign %$proc.locofs %$proc.locofs+%2
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Get the type of given size into context-local variable %$type
+; Arguments:
+;   Size of type we want (1,2,4,8 or 10)
+; Example:
+;		type	4	; gives "dword"
+;		type	10	; gives "tword"
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		type	1
+	%if %1 = 1
+		%define	%$type byte
+	%elif %1 = 2
+		%define	%$type word
+	%elif %1 = 4
+		%define	%$type dword
+	%elif %1 = 8
+		%define	%$type qword
+	%elif %1 = 10
+		%define	%$type tword
+	%else
+		%define %$. %1
+		%error "unknown type for argument size %$."
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Same as `arg' but prepends "word", "dword" etc (typed arg)
+;     first (with the name given by first argument) - dword [esp+xx]
+;     second (with  a slash prefixing the first argument) - esp+xx
+; Arguments:
+;   Same as for `arg'
+; Example:
+;		targ	.my_float	; .my_float is now "dword [esp+xxx]"
+;		targ	.my_double,8	; .my_double is now "qword [esp+xxx]"
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		targ	1-2 4
+	%ifndef %$proc.argofs
+		%error	"`targ' not in a proc context"
+	%else
+		arg	%1,%2
+		type	%2
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %1 %$type %1
+		%assign .$proc.stkofs %%.
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Same as `loc' but prepends "word", "dword" etc (typed loc)
+;     first (with the name given by first argument) - dword [esp+xx]
+;     second (with  a slash prefixing the first argument) - esp+xx
+; Arguments:
+;   Same as for `loc'
+; Example:
+;		tloc	int_value
+;		tloc	double_value,8
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		tloc	1-2 4
+	%ifndef %$proc.locofs
+		%error	"`tloc' not in a proc context"
+	%else
+		loc	%1,%2
+		type	%2
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %1 %$type %1
+		%assign .$proc.stkofs %%.
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Finish a procedure
+;   Gives an error if proc/endproc pairs mismatch
+;   Defines an label called __end_(procedure name)
+;   which is useful for calculating function size
+; Arguments:
+;   (optional) The name of procedure
+; Example:
+;   endproc	MyTestProc
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%push	tmp	; trick: define a dummy context to avoid error in next line
+%macro		endproc	0-1 %$proc.name
+	%ifndef %$proc.argofs
+		%error "`endproc' not in a proc context"
+	%elifnidn %$proc.name,%1
+		%define %$. %1
+		%error "endproc names mismatch: expected `%$proc.name'"
+		%error "but got `%$.' instead"
+	%elif %$proc.locofs < %$proc.locsize
+		%error	"unused local space declared (used %$proc.locofs, requested %$proc.locsize)"
+	%else
+%$exit:
+	; Now pop the registers that we should restore on exit
+		pop	%$proc.save
+		%if %$proc.locsize != 0
+		add	esp,%$proc.locsize
+		%endif
+		ret
+__end_%1:
+		%pop
+	%endif
+%endmacro
+%pop
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   A replacement for "push" for use within procedures
+; Arguments:
+;   any number of registers which will be push'ed successively
+; Example:
+;		push	eax,ebx,ecx,edx
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		push	0-*
+; dummy comment to avoid problems with "push" on the same line with a label
+	%rep	%0
+		push	%1
+		%rotate	1
+		%assign .$proc.stkofs .$proc.stkofs+4
+	%endrep
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   A replacement for "pop" for use within procedures
+; Arguments:
+;   any number of registers which will be pop'ed in reverse order
+; Example:
+;		pop	eax,ebx,ecx,edx
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		pop	0-*
+; dummy comment to avoid problems with "pop" on the same line with a label
+	%rep	%0
+		%rotate	-1
+		pop	%1
+		%assign .$proc.stkofs .$proc.stkofs-4
+	%endrep
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Replacements for "pushfd" and "popfd" that takes care of esp
+; Example:
+;		pushfd
+;		popfd
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		pushfd	0
+		pushfd
+		%assign .$proc.stkofs .$proc.stkofs+4
+%endmacro
+%macro		popfd	0
+		popfd
+		%assign .$proc.stkofs .$proc.stkofs-4
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Exit from current procedure (optionally on given condition)
+; Arguments:
+;   Either none or a condition code
+; Example:
+;		exit
+;		exit	nz
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		exit	0-1 mp
+		j%1	near %$exit
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   start an conditional branch
+; Arguments:
+;   A condition code
+;   second (optional) argument - "short" (by default - "near")
+; Example:
+;		if	nz
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		if	1-2 near
+; dummy comment to avoid problems with "if" on the same line with a label
+		%push	if
+		j%-1	%2 %$elseif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   define the "else" branch of a conditional statement
+; Arguments:
+;   optionally: "short" if jmp to endif is less than 128 bytes away
+; Example:
+;		else
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		else	0-1
+	%ifnctx if
+		%error	"`else' without matching `if'"
+	%else
+		jmp	%1 %$endif
+%$elseif:
+		%define	%$elseif_defined
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Finish am conditional statement
+; Arguments:
+;   none
+; Example:
+;		endif
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		endif	0
+	%ifnctx if
+		%error	"`endif' without matching `if'"
+	%else
+		%ifndef %$elseif_defined
+%$elseif:
+		%endif
+%$endif:
+		%pop
+	%endif
+%endmacro
+
+%endif ; __PROC32_ASH__
diff --git a/vere/ext/nasm/misc/scitech.mac b/vere/ext/nasm/misc/scitech.mac
new file mode 100644
index 0000000..5fe0470
--- /dev/null
+++ b/vere/ext/nasm/misc/scitech.mac
@@ -0,0 +1,1222 @@
+;****************************************************************************
+;*
+;*  ========================================================================
+;*
+;*    The contents of this file are subject to the SciTech MGL Public
+;*    License Version 1.0 (the "License"); you may not use this file
+;*    except in compliance with the License. You may obtain a copy of
+;*    the License at http://www.scitechsoft.com/mgl-license.txt
+;*
+;*    Software distributed under the License is distributed on an
+;*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+;*    implied. See the License for the specific language governing
+;*    rights and limitations under the License.
+;*
+;*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+;*
+;*    The Initial Developer of the Original Code is SciTech Software, Inc.
+;*    All Rights Reserved.
+;*
+;*  ========================================================================
+;*
+;* Language:    NetWide Assembler (NASM) or Turbo Assembler (TASM)
+;* Environment: Any Intel Environment
+;*
+;* Description: Macros to provide memory model independent assembly language
+;*              module for C programming. Supports the large and flat memory
+;*				models.
+;*
+;*		The defines that you should use when assembling modules that
+;*				use this macro package are:
+;*
+;*					__LARGE__	Assemble for 16-bit large model
+;*                  __FLAT__    Assemble for 32-bit FLAT memory model
+;*                  __NOU__		No underscore for all external C labels
+;*					__NOU_VAR__	No underscore for global variables only
+;*
+;*				The default settings are for 16-bit large memory model with
+;*				leading underscores for symbol names.
+;*
+;*				The main intent of the macro file is to enable programmers
+;*				to write _one_ set of source that can be assembled to run
+;*				in either 16 bit real and protected modes or 32 bit
+;*				protected mode without the need to riddle the code with
+;*				'if flatmodel' style conditional assembly (it is still there
+;*				but nicely hidden by a macro layer that enhances the
+;*				readability and understandability of the resulting code).
+;*
+;****************************************************************************
+
+; Include the appropriate version in here depending on the assembler. NASM
+; appears to always try and parse code, even if it is in a non-compiling
+; block of a ifdef expression, and hence crashes if we include the TASM
+; macro package in the same header file. Hence we split the macros up into
+; two separate header files.
+
+ifdef __NASM_MAJOR__
+
+;============================================================================
+; Macro package when compiling with NASM.
+;============================================================================
+
+; Turn off underscores for globals if disabled for all externals
+
+%ifdef	__NOU__
+%define	__NOU_VAR__
+%endif
+
+; Define the __WINDOWS__ symbol if we are compiling for any Windows
+; environment
+
+%ifdef	__WINDOWS16__
+%define	__WINDOWS__			1
+%endif
+%ifdef	__WINDOWS32__
+%define __WINDOWS__			1
+%define __WINDOWS32_386__	1
+%endif
+
+; Macros for accessing 'generic' registers
+
+%ifdef	__FLAT__
+%idefine _ax	eax
+%idefine _bx	ebx
+%idefine _cx	ecx
+%idefine _dx	edx
+%idefine _si	esi
+%idefine _di	edi
+%idefine _bp	ebp
+%idefine _sp	esp
+%idefine _es
+%idefine UCHAR	BYTE		; Size of a character
+%idefine USHORT WORD		; Size of a short
+%idefine UINT	DWORD		; Size of an integer
+%idefine ULONG	DWORD		; Size of a long
+%idefine BOOL	DWORD		; Size of a boolean
+%idefine DPTR	DWORD		; Size of a data pointer
+%idefine FDPTR	FWORD		; Size of a far data pointer
+%idefine NDPTR	DWORD		; Size of a near data pointer
+%idefine CPTR	DWORD		; Size of a code pointer
+%idefine FCPTR	FWORD		; Size of a far code pointer
+%idefine NCPTR	DWORD		; Size of a near code pointer
+%idefine FPTR	NEAR		; Distance for function pointers
+%idefine DUINT	dd			; Declare a integer variable
+%idefine intsize 4
+%idefine flatmodel 1
+%else
+%idefine _ax	ax
+%idefine _bx	bx
+%idefine _cx	cx
+%idefine _dx	dx
+%idefine _si	si
+%idefine _di	di
+%idefine _bp	bp
+%idefine _sp	sp
+%idefine _es	es:
+%idefine UCHAR	BYTE		; Size of a character
+%idefine USHORT WORD		; Size of a short
+%idefine UINT	WORD		; Size of an integer
+%idefine ULONG	DWORD		; Size of a long
+%idefine BOOL	WORD		; Size of a boolean
+%idefine DPTR	DWORD		; Size of a data pointer
+%idefine FDPTR	DWORD		; Size of a far data pointer
+%idefine NDPTR	WORD		; Size of a near data pointer
+%idefine CPTR	DWORD		; Size of a code pointer
+%idefine FCPTR	DWORD		; Size of a far code pointer
+%idefine NCPTR	WORD		; Size of a near code pointer
+%idefine FPTR   FAR			; Distance for function pointers
+%idefine DUINT	dw			; Declare a integer variable
+%idefine intsize 2
+%endif
+%idefine invert ~
+%idefine offset
+%idefine use_nasm
+
+; Convert all jumps to near jumps, since NASM does not so this automatically
+
+%idefine jo		jo near
+%idefine jno	jno near
+%idefine jz		jz near
+%idefine jnz	jnz near
+%idefine je		je near
+%idefine jne	jne near
+%idefine jb		jb	near
+%idefine jbe	jbe	near
+%idefine ja		ja	near
+%idefine jae	jae	near
+%idefine jl		jl	near
+%idefine jle	jle	near
+%idefine jg		jg	near
+%idefine jge	jge	near
+%idefine jc		jc	near
+%idefine jnc	jnc	near
+%idefine js		js	near
+%idefine jns	jns	near
+
+%ifdef	DOUBLE
+%idefine	REAL	QWORD
+%idefine	DREAL	dq
+%else
+%idefine	REAL	DWORD
+%idefine	DREAL	dd
+%endif
+
+; Boolean truth values (same as those in debug.h)
+
+%idefine False		0
+%idefine True		1
+%idefine No			0
+%idefine Yes		1
+
+; Macro to be invoked at the start of all modules to set up segments for
+; later use. Does nothing for NASM.
+
+%imacro header 1
+%endmacro
+
+; Macro to begin a data segment
+
+%imacro begdataseg 1
+%ifdef __GNUC__
+segment .data public class=DATA use32 flat
+%else
+%ifdef flatmodel
+segment _DATA public align=4 class=DATA use32 flat
+%else
+segment _DATA public align=4 class=DATA use16
+%endif
+%endif
+%endmacro
+
+; Macro to end a data segment
+
+%imacro enddataseg 1
+%endmacro
+
+; Macro to begin a code segment
+
+%imacro begcodeseg 1
+%ifdef __GNUC__
+segment .text public class=CODE use32 flat
+%else
+%ifdef flatmodel
+segment _TEXT public align=16 class=CODE use32 flat
+%else
+segment %1_TEXT public align=16 class=CODE use16
+%endif
+%endif
+%endmacro
+
+; Macro to begin a near code segment
+
+%imacro begcodeseg_near 0
+%ifdef __GNUC__
+segment .text public class=CODE use32 flat
+%else
+%ifdef flatmodel
+segment _TEXT public align=16 class=CODE use32 flat
+%else
+segment _TEXT public align=16 class=CODE use16
+%endif
+%endif
+%endmacro
+
+; Macro to end a code segment
+
+%imacro endcodeseg 1
+%endmacro
+
+; Macro to end a near code segment
+
+%imacro endcodeseg_near 0
+%endmacro
+
+; Macro for an extern C symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+%imacro cextern 2
+%ifdef	__NOU_VAR__
+extern %1
+%else
+extern _%1
+%define	%1 _%1
+%endif
+%endmacro
+
+%imacro cexternfunc 2
+%ifdef	__NOU__
+extern %1
+%else
+extern _%1
+%define	%1 _%1
+%endif
+%endmacro
+
+; Macro for a public C symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+%imacro cpublic 1
+%ifdef	__NOU_VAR__
+global %1
+%1:
+%else
+global _%1
+_%1:
+%define	%1 _%1
+%endif
+%endmacro
+
+; Macro for an global C symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+%imacro cglobal 1
+%ifdef	__NOU_VAR__
+global %1
+%else
+global _%1
+%define	%1 _%1
+%endif
+%endmacro
+
+; Macro for an global C function symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+%imacro cglobalfunc 1
+%ifdef	__NOU__
+global %1
+%else
+global _%1
+%define	%1 _%1
+%endif
+%endmacro
+
+; Macro to start a C callable function. This will be a far function for
+; 16-bit code, and a near function for 32-bit code.
+
+%imacro cprocstatic 1
+%push cproc
+%1:
+%ifdef flatmodel
+%stacksize flat
+%define ret	retn
+%else
+%stacksize large
+%define ret	retf
+%endif
+%assign %$localsize 0
+%endmacro
+
+%imacro cprocstart 1
+%push cproc
+	cglobalfunc %1
+%1:
+%ifdef flatmodel
+%stacksize flat
+%define ret	retn
+%else
+%stacksize large
+%define ret	retf
+%endif
+%assign %$localsize 0
+%endmacro
+
+; This macro sets up a procedure to be exported from a 16 bit DLL. Since the
+; calling conventions are always _far _pascal for 16 bit DLL's, we actually
+; rename this routine with an extra underscore with 'C' calling conventions
+; and a small DLL stub will be provided by the high level code to call the
+; assembler routine.
+
+%imacro	cprocstartdll16 1
+%ifdef	__WINDOWS16__
+cprocstart	_%1
+%else
+cprocstart	%1
+%endif
+%endmacro
+
+; Macro to start a C callable near function.
+
+%imacro cprocnear 1
+%push cproc
+	cglobalfunc %1
+%1:
+%define ret	retn
+%ifdef flatmodel
+%stacksize flat
+%else
+%stacksize small
+%endif
+%assign %$localsize 0
+%endmacro
+
+; Macro to start a C callable far function.
+
+%imacro cprocfar 1
+%push cproc
+	cglobalfunc %1
+%1:
+%define ret	retf
+%ifdef flatmodel
+%stacksize flat
+%else
+%stacksize large
+%endif
+%assign %$localsize 0
+%endmacro
+
+; Macro to end a C function
+
+%imacro cprocend 0
+%pop
+%endmacro
+
+; Macros for entering and exiting C callable functions. Note that we must
+; always save and restore the SI and DI registers for C functions, and for
+; 32 bit C functions we also need to save and restore EBX and clear the
+; direction flag.
+
+%imacro enter_c 0
+		push    _bp
+		mov     _bp,_sp
+%ifnidn	%$localsize,0
+		sub		_sp,%$localsize
+%endif
+%ifdef	flatmodel
+		push	ebx
+%endif
+		push	_si
+		push	_di
+%endmacro
+
+%imacro leave_c 0
+		pop		_di
+		pop		_si
+%ifdef	flatmodel
+		pop		ebx
+		cld
+%endif
+%ifnidn %$localsize,0
+		mov     _sp,_bp
+%endif
+		pop     _bp
+%endmacro
+
+%imacro   use_ebx 0
+%ifdef flatmodel
+		push    ebx
+%endif
+%endmacro
+
+%imacro   unuse_ebx 0
+%ifdef flatmodel
+		pop     ebx
+%endif
+%endmacro
+
+; Macros for saving and restoring the value of DS,ES,FS,GS when it is to
+; be used in assembly routines. This evaluates to nothing in the flat memory
+; model, but is saves and restores DS in the large memory model.
+
+%imacro	use_ds 0
+%ifndef flatmodel
+		push	ds
+%endif
+%endmacro
+
+%imacro	unuse_ds 0
+%ifndef flatmodel
+		pop		ds
+%endif
+%endmacro
+
+%imacro	use_es 0
+%ifndef flatmodel
+		push	es
+%endif
+%endmacro
+
+%imacro	unuse_es 0
+%ifndef flatmodel
+		pop		es
+%endif
+%endmacro
+
+; Macros for loading the address of a data pointer into a segment and
+; index register pair. The %imacro explicitly loads DS or ES in the 16 bit
+; memory model, or it simply loads the offset into the register in the flat
+; memory model since DS and ES always point to all addressable memory. You
+; must use the correct _REG (ie: _BX) %imacros for documentation purposes.
+
+%imacro	_lds	2
+%ifdef flatmodel
+		mov     %1,%2
+%else
+		lds		%1,%2
+%endif
+%endmacro
+
+%imacro   _les	2
+%ifdef flatmodel
+		mov     %1,%2
+%else
+		les		%1,%2
+%endif
+%endmacro
+
+; Macros for adding and subtracting a value from registers. Two value are
+; provided, one for 16 bit modes and another for 32 bit modes (the extended
+; register is used in 32 bit modes).
+
+%imacro   _add	3
+%ifdef flatmodel
+		add		e%1, %3
+%else
+		add		%1, %2
+%endif
+%endmacro
+
+%imacro	_sub	3
+%ifdef flatmodel
+		sub		e%1, %3
+%else
+		sub		%1, %2
+%endif
+%endmacro
+
+; Macro to clear the high order word for the 32 bit extended registers.
+; This is used to convert an unsigned 16 bit value to an unsigned 32 bit
+; value, and will evaluate to nothing in 16 bit modes.
+
+%imacro	clrhi	1
+%ifdef	flatmodel
+		movzx	e%1,%1
+%endif
+%endmacro
+
+%imacro	sgnhi	1
+%ifdef	flatmodel
+		movsx	e%1,%1
+%endif
+%endmacro
+
+; Macro to load an extended register with an integer value in either mode
+
+%imacro	loadint	2
+%ifdef flatmodel
+		mov		e%1,%2
+%else
+		xor		e%1,e%1
+		mov     %1,%2
+%endif
+%endmacro
+
+; Macros to load and store integer values with string instructions
+
+%imacro	LODSINT 0
+%ifdef flatmodel
+		lodsd
+%else
+		lodsw
+%endif
+%endmacro
+
+%imacro	STOSINT	0
+%ifdef flatmodel
+		stosd
+%else
+		stosw
+%endif
+%endmacro
+
+; Macros to provide resb, resw, resd compatibility with NASM
+
+%imacro	dclb 1
+times %1 db 0
+%endmacro
+
+%imacro	dclw 1
+times %1 dw 0
+%endmacro
+
+%imacro	dcld 1
+times %1 dd 0
+%endmacro
+
+; macros to declare assembler function stubs for function structures
+
+%imacro	BEGIN_STUBS_DEF	2
+begdataseg  _STUBS
+%ifdef	__NOU_VAR__
+extern %1
+%define	STUBS_START	%1
+%else
+extern _%1
+%define	STUBS_START	_%1
+%endif
+enddataseg  _STUBS
+begcodeseg  _STUBS
+%assign off %2
+%endmacro
+
+%imacro   DECLARE_STUB	1
+%ifdef	__NOU__
+		global %1
+%1:
+%else
+		global _%1
+_%1:
+%endif
+		jmp     [DWORD STUBS_START+off]
+%assign off off+4
+%endmacro
+
+%imacro DECLARE_STDCALL 2
+%ifdef	STDCALL_MANGLE
+		global _%1@%2
+_%1@%2:
+%else
+%ifdef __GNUC__
+		global _%1
+_%1:
+%else
+		global %1
+%1:
+%endif
+%endif
+		jmp     [DWORD STUBS_START+off]
+%assign off off+4
+%endmacro
+
+%imacro   END_STUBS_DEF 0
+endcodeseg  _STUBS
+%endmacro
+
+; macros to declare assembler import stubs for binary loadable drivers
+
+%imacro	BEGIN_IMPORTS_DEF	1
+BEGIN_STUBS_DEF	%1,4
+%endmacro
+
+%imacro   DECLARE_IMP	1
+DECLARE_STUB	%1
+%endmacro
+
+%imacro   END_IMPORTS_DEF 0
+END_STUBS_DEF
+%endmacro
+
+else	; __NASM_MAJOR__
+
+;============================================================================
+; Macro package when compiling with TASM.
+;============================================================================
+
+; Turn off underscores for globals if disabled for all externals
+
+ifdef	__NOU__
+__NOU_VAR__			= 1
+endif
+
+; Define the __WINDOWS__ symbol if we are compiling for any Windows
+; environment
+
+ifdef	__WINDOWS16__
+__WINDOWS__		= 1
+endif
+ifdef	__WINDOWS32__
+__WINDOWS__		= 1
+__WINDOWS32_386__	= 1
+endif
+ifdef	__WIN386__
+__WINDOWS__		= 1
+__WINDOWS32_386__	= 1
+endif
+ifdef	__VXD__
+__WINDOWS__		= 1
+__WINDOWS32_386__	= 1
+		MASM
+		.386
+		NO_SEGMENTS	= 1
+		include	vmm.inc			; IGNORE DEPEND
+		include vsegment.inc    ; IGNORE DEPEND
+		IDEAL
+endif
+
+; Macros for accessing 'generic' registers
+
+ifdef   __FLAT__
+		_ax			EQU	eax		; EAX is used for accumulator
+		_bx			EQU	ebx		; EBX is used for accumulator
+		_cx			EQU	ecx		; ECX is used for looping
+		_dx			EQU	edx		; EDX is used for data register
+		_si			EQU	esi		; ESI is the source index register
+		_di			EQU	edi		; EDI is the destination index register
+		_bp			EQU	ebp		; EBP is used for base pointer register
+		_sp			EQU	esp		; ESP is used for stack pointer register
+		_es			EQU			; ES and DS are the same in 32 bit PM
+		typedef UCHAR BYTE		; Size of a character
+		typedef USHORT WORD		; Size of a short
+		typedef UINT DWORD		; Size of an integer
+		typedef ULONG DWORD		; Size of a long
+		typedef BOOL DWORD      ; Size of a boolean
+		typedef DPTR DWORD		; Size of a data pointer
+		typedef FDPTR FWORD		; Size of a far data pointer
+		typedef	NDPTR DWORD		; Size of a near data pointer
+		typedef CPTR DWORD		; Size of a code pointer
+		typedef FCPTR FWORD		; Size of a far code pointer
+		typedef NCPTR DWORD		; Size of a near code pointer
+		typedef	DUINT DWORD		; Declare a integer variable
+		FPTR        EQU NEAR	; Distance for function pointers
+		intsize		=	4		; Size of an integer
+		flatmodel	=	1		; This is a flat memory model
+		P386                    ; Turn on 386 code generation
+		MODEL       FLAT        ; Set up for 32 bit simplified FLAT model
+else
+		_ax			EQU	ax		; AX is used for accumulator
+		_bx			EQU	bx		; BX is used for accumulator
+		_cx			EQU	cx		; CX is used for looping
+		_dx			EQU	dx		; DX is used for data register
+		_si			EQU	si		; SI is the source index register
+		_di			EQU	di		; DI is the destination index register
+		_bp			EQU	bp		; BP is used for base pointer register
+		_sp			EQU	sp		; SP is used for stack pointer register
+		_es			EQU es:		; ES is used for segment override
+		typedef UCHAR BYTE      ; Size of a character
+		typedef USHORT WORD		; Size of a short
+		typedef UINT WORD		; Size of an integer
+		typedef ULONG DWORD		; Size of a long
+		typedef BOOL WORD		; Size of a boolean
+		typedef DPTR DWORD		; Size of a data pointer
+		typedef FDPTR DWORD		; Size of a far data pointer
+		typedef	NDPTR WORD		; Size of a near data pointer
+		typedef CPTR DWORD		; Size of a code pointer
+		typedef FCPTR DWORD		; Size of a far code pointer
+		typedef NCPTR WORD		; Size of a near code pointer
+		typedef	DUINT WORD		; Declare a integer variable
+		FPTR        EQU FAR		; Distance for function pointers
+		intsize		=	2		; Size of an integer
+		P386					; Turn on 386 code generation
+endif
+        invert      EQU not
+
+; Provide a typedef for real floating point numbers
+
+ifdef	DOUBLE
+typedef	REAL	QWORD
+typedef	DREAL	QWORD
+else
+typedef	REAL	DWORD
+typedef	DREAL	DWORD
+endif
+
+; Macros to access the floating point stack registers to convert them
+; from NASM style to TASM style
+
+st0			EQU		st(0)
+st1			EQU		st(1)
+st2			EQU		st(2)
+st3			EQU		st(3)
+st4			EQU		st(4)
+st5			EQU		st(5)
+st6			EQU		st(6)
+st7			EQU		st(7)
+st8			EQU		st(8)
+
+; Boolean truth values (same as those in debug.h)
+
+ifndef	__VXD__
+False		=		0
+True		=		1
+No			=		0
+Yes			=		1
+Yes			=		1
+endif
+
+; Macros for the _DATA data segment. This segment contains initialised data.
+
+MACRO   begdataseg name
+ifdef	__VXD__
+		MASM
+VXD_LOCKED_DATA_SEG
+		IDEAL
+else
+ifdef   flatmodel
+		DATASEG
+else
+SEGMENT _DATA DWORD PUBLIC USE16 'DATA'
+endif
+endif
+ENDM
+
+MACRO   enddataseg name
+ifdef	__VXD__
+		MASM
+VXD_LOCKED_DATA_ENDS
+		IDEAL
+else
+ifndef  flatmodel
+ENDS    _DATA
+endif
+endif
+ENDM
+
+; Macro for the main code segment.
+
+MACRO   begcodeseg name
+ifdef	__VXD__
+		MASM
+VXD_LOCKED_CODE_SEG
+		IDEAL
+else
+ifdef   flatmodel
+		CODESEG
+		ASSUME  CS:FLAT,DS:FLAT,SS:FLAT
+else
+SEGMENT &name&_TEXT PARA PUBLIC USE16 'CODE'
+		ASSUME CS:&name&_TEXT,DS:_DATA
+endif
+endif
+ENDM
+
+; Macro for a near code segment
+
+MACRO   begcodeseg_near
+ifdef   flatmodel
+		CODESEG
+		ASSUME  CS:FLAT,DS:FLAT,SS:FLAT
+else
+SEGMENT _TEXT PARA PUBLIC USE16 'CODE'
+		ASSUME CS:_TEXT,DS:_DATA
+endif
+ENDM
+
+MACRO   endcodeseg name
+ifdef	__VXD__
+		MASM
+VXD_LOCKED_CODE_ENDS
+		IDEAL
+else
+ifndef  flatmodel
+ENDS    &name&_TEXT
+endif
+endif
+ENDM
+
+MACRO   endcodeseg_near
+ifndef  flatmodel
+ENDS    _TEXT
+endif
+ENDM
+
+; Macro to be invoked at the start of all modules to set up segments for
+; later use.
+
+MACRO   header name
+begdataseg name
+enddataseg name
+ENDM
+
+; Macro for an extern C symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+MACRO   cextern	name,size
+ifdef	__NOU_VAR__
+		EXTRN	name:size
+else
+		EXTRN	_&name&:size
+name	EQU		_&name&
+endif
+ENDM
+
+MACRO   cexternfunc	name,size
+ifdef	__NOU__
+		EXTRN	name:size
+else
+		EXTRN	_&name&:size
+name	EQU		_&name&
+endif
+ENDM
+
+MACRO   stdexternfunc	name,args,size
+ifdef	STDCALL_MANGLE
+		EXTRN	_&name&@&num_args&:size
+name	EQU		_&name&@&num_args
+else
+		EXTRN	name:size
+endif
+ENDM
+
+; Macro for a public C symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+MACRO	cpublic name
+ifdef	__NOU_VAR__
+name:
+		PUBLIC	name
+else
+_&name&:
+		PUBLIC	_&name&
+name	EQU		_&name&
+endif
+ENDM
+
+; Macro for an global C symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+MACRO	cglobal name
+ifdef	__NOU_VAR__
+		PUBLIC	name
+else
+		PUBLIC	_&name&
+name	EQU		_&name&
+endif
+ENDM
+
+; Macro for an global C function symbol. If the C compiler requires leading
+; underscores, then the underscores are added to the symbol names, otherwise
+; they are left off. The symbol name is referenced in the assembler code
+; using the non-underscored symbol name.
+
+MACRO	cglobalfunc name
+ifdef	__NOU__
+		PUBLIC	name
+else
+		PUBLIC	_&name&
+name	EQU		_&name&
+endif
+ENDM
+
+; Macro to start a C callable function. This will be a far function for
+; 16-bit code, and a near function for 32-bit code.
+
+MACRO   cprocstatic name	; Set up model independent private proc
+ifdef flatmodel
+PROC	name NEAR
+else
+PROC    name FAR
+endif
+LocalSize	= 0
+ENDM
+
+MACRO   cprocstart name		; Set up model independent proc
+ifdef flatmodel
+ifdef	__NOU__
+PROC	name NEAR
+else
+PROC	_&name& NEAR
+endif
+else
+ifdef	__NOU__
+PROC    name FAR
+else
+PROC    _&name& FAR
+endif
+endif
+LocalSize	= 0
+		cglobalfunc	name
+ENDM
+
+MACRO   cprocnear name		; Set up near proc
+ifdef	__NOU__
+PROC    name NEAR
+else
+PROC    _&name& NEAR
+endif
+LocalSize	= 0
+		cglobalfunc	name
+ENDM
+
+MACRO   cprocfar name           ; Set up far proc
+ifdef	__NOU__
+PROC    name FAR
+else
+PROC    _&name& FAR
+endif
+LocalSize	= 0
+		cglobalfunc	name
+ENDM
+
+MACRO   cprocend	           ; End procedure macro
+ENDP
+ENDM
+
+; This macro sets up a procedure to be exported from a 16 bit DLL. Since the
+; calling conventions are always _far _pascal for 16 bit DLL's, we actually
+; rename this routine with an extra underscore with 'C' calling conventions
+; and a small DLL stub will be provided by the high level code to call the
+; assembler routine.
+
+MACRO   cprocstartdll16 name
+ifdef	__WINDOWS16__
+cprocstart	_&name&
+else
+cprocstart	name
+endif
+ENDM
+
+; Macros for entering and exiting C callable functions. Note that we must
+; always save and restore the SI and DI registers for C functions, and for
+; 32 bit C functions we also need to save and restore EBX and clear the
+; direction flag.
+
+MACRO	save_c_regs
+ifdef	flatmodel
+		push	ebx
+endif
+		push	_si
+		push	_di
+ENDM
+
+MACRO	enter_c
+		push    _bp
+		mov     _bp,_sp
+	IFDIFI	<LocalSize>,<0>
+		sub		_sp,LocalSize
+	ENDIF
+		save_c_regs
+ENDM
+
+MACRO	restore_c_regs
+		pop		_di
+		pop		_si
+ifdef	flatmodel
+		pop		ebx
+endif
+ENDM
+
+MACRO	leave_c
+		restore_c_regs
+		cld
+	IFDIFI	<LocalSize>,<0>
+		mov     _sp,_bp
+	ENDIF
+		pop     _bp
+ENDM
+
+MACRO   use_ebx
+ifdef flatmodel
+		push    ebx
+endif
+ENDM
+
+MACRO   unuse_ebx
+ifdef flatmodel
+		pop     ebx
+endif
+ENDM
+
+; Macros for saving and restoring the value of DS,ES,FS,GS when it is to
+; be used in assembly routines. This evaluates to nothing in the flat memory
+; model, but is saves and restores DS in the large memory model.
+
+MACRO	use_ds
+ifndef flatmodel
+		push	ds
+endif
+ENDM
+
+MACRO	unuse_ds
+ifndef flatmodel
+		pop		ds
+endif
+ENDM
+
+MACRO	use_es
+ifndef flatmodel
+		push	es
+endif
+ENDM
+
+MACRO	unuse_es
+ifndef flatmodel
+		pop		es
+endif
+ENDM
+
+; Macros for loading the address of a data pointer into a segment and
+; index register pair. The macro explicitly loads DS or ES in the 16 bit
+; memory model, or it simply loads the offset into the register in the flat
+; memory model since DS and ES always point to all addressable memory. You
+; must use the correct _REG (ie: _BX) macros for documentation purposes.
+
+MACRO	_lds	reg, addr
+ifdef flatmodel
+		mov     reg,addr
+else
+		lds		reg,addr
+endif
+ENDM
+
+MACRO   _les	reg, addr
+ifdef flatmodel
+		mov     reg,addr
+else
+		les		reg,addr
+endif
+ENDM
+
+; Macros for adding and subtracting a value from registers. Two value are
+; provided, one for 16 bit modes and another for 32 bit modes (the extended
+; register is used in 32 bit modes).
+
+MACRO   _add	reg, val16, val32
+ifdef flatmodel
+		add		e&reg&, val32
+else
+		add		reg, val16
+endif
+ENDM
+
+MACRO	_sub	reg, val16, val32
+ifdef flatmodel
+		sub		e&reg&, val32
+else
+		sub		reg, val16
+endif
+ENDM
+
+; Macro to clear the high order word for the 32 bit extended registers.
+; This is used to convert an unsigned 16 bit value to an unsigned 32 bit
+; value, and will evaluate to nothing in 16 bit modes.
+
+MACRO	clrhi	reg
+ifdef	flatmodel
+		movzx	e&reg&,reg
+endif
+ENDM
+
+MACRO	sgnhi	reg
+ifdef	flatmodel
+		movsx	e&reg&,reg
+endif
+ENDM
+
+; Macro to load an extended register with an integer value in either mode
+
+MACRO	loadint	reg,val
+ifdef flatmodel
+		mov		e&reg&,val
+else
+		xor		e&reg&,e&reg&
+		mov     reg,val
+endif
+ENDM
+
+; Macros to load and store integer values with string instructions
+
+MACRO	LODSINT
+ifdef flatmodel
+		lodsd
+else
+		lodsw
+endif
+ENDM
+
+MACRO	STOSINT
+ifdef flatmodel
+		stosd
+else
+		stosw
+endif
+ENDM
+
+; Macros to provide resb, resw, resd compatibility with NASM
+
+MACRO	dclb	count
+db	count dup (0)
+ENDM
+
+MACRO	dclw	count
+dw	count dup (0)
+ENDM
+
+MACRO	dcld	count
+dd	count dup (0)
+ENDM
+
+; Macros to provide resb, resw, resd compatibility with NASM
+
+MACRO	resb	count
+db	count dup (?)
+ENDM
+
+MACRO	resw	count
+dw	count dup (?)
+ENDM
+
+MACRO	resd	count
+dd	count dup (?)
+ENDM
+
+; Macros to declare assembler stubs for function structures
+
+MACRO	BEGIN_STUBS_DEF	name, firstOffset
+begdataseg  _STUBS
+ifdef	__NOU_VAR__
+		EXTRN	name:DWORD
+STUBS_START	=   name
+else
+		EXTRN	_&name&:DWORD
+name	EQU		_&name&
+STUBS_START	=   _&name
+endif
+enddataseg  _STUBS
+begcodeseg  _STUBS
+off = firstOffset
+ENDM
+
+MACRO   DECLARE_STUB	name
+ifdef	__NOU__
+name:
+		PUBLIC  name
+else
+_&name:
+		PUBLIC  _&name
+endif
+		jmp     [DWORD STUBS_START+off]
+off = off + 4
+ENDM
+
+MACRO   DECLARE_STDCALL	name,num_args
+ifdef	STDCALL_MANGLE
+_&name&@&num_args&:
+		PUBLIC  _&name&@&num_args&
+else
+name:
+		PUBLIC  name
+endif
+		jmp     [DWORD STUBS_START+off]
+off = off + 4
+ENDM
+
+MACRO   END_STUBS_DEF
+endcodeseg  _STUBS
+ENDM
+
+MACRO	BEGIN_IMPORTS_DEF	name
+BEGIN_STUBS_DEF	name,4
+ENDM
+
+MACRO   DECLARE_IMP	name
+DECLARE_STUB	name
+ENDM
+
+MACRO   END_IMPORTS_DEF
+END_STUBS_DEF
+ENDM
+
+endif
diff --git a/vere/ext/nasm/misc/xcrcgen.c b/vere/ext/nasm/misc/xcrcgen.c
new file mode 100644
index 0000000..0198480
--- /dev/null
+++ b/vere/ext/nasm/misc/xcrcgen.c
@@ -0,0 +1,79 @@
+/*
+ * Produce a "generalized CRC" table.  Assumes a platform with
+ * /dev/urandom -- otherwise reimplement get_random_byte().
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static uint8_t get_random_byte(void)
+{
+    static int fd = -1;
+    uint8_t buf;
+    int rv;
+
+    if (fd < 0)
+	fd = open("/dev/urandom", O_RDONLY);
+
+    do {
+	errno = 0;
+	rv = read(fd, &buf, 1);
+	if (rv < 1 && errno != EAGAIN)
+	    abort();
+    } while (rv < 1);
+
+    return buf;
+}
+
+static void random_permute(uint8_t *buf)
+{
+    int i, j, k;
+    int m;
+
+    for (i = 0; i < 256; i++)
+	buf[i] = i;
+
+    m = 255;
+    for (i = 255; i > 0; i--) {
+	if (i <= (m >> 1))
+	    m >>= 1;
+	do {
+	    j = get_random_byte() & m;
+	} while (j > i);
+	k = buf[i];
+	buf[i] = buf[j];
+	buf[j] = k;
+    }
+}
+
+static void xcrc_table(uint64_t *buf)
+{
+    uint8_t perm[256];
+    int i, j;
+
+    memset(buf, 0, 8*256);	/* Make static checkers happy */
+
+    for (i = 0; i < 8; i++) {
+	random_permute(perm);
+	for (j = 0; j < 256; j++)
+	    buf[j] = (buf[j] << 8) | perm[j];
+    }
+}
+
+int main(void)
+{
+    int i;
+    uint64_t buf[256];
+
+    xcrc_table(buf);
+
+    for (i = 0; i < 256; i++) {
+	printf("%016"PRIx64"\n", buf[i]);
+    }
+
+    return 0;
+}
diff --git a/vere/ext/nasm/nasmlib/alloc.c b/vere/ext/nasm/nasmlib/alloc.c
new file mode 100644
index 0000000..e25e0e0
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/alloc.c
@@ -0,0 +1,197 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2019 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "alloc.h"
+
+size_t _nasm_last_string_size;
+
+fatal_func nasm_alloc_failed(void)
+{
+    nasm_critical("out of memory!");
+}
+
+void *nasm_malloc(size_t size)
+{
+    void *p;
+
+again:
+    p = malloc(size);
+
+    if (unlikely(!p)) {
+        if (!size) {
+            size = 1;
+            goto again;
+        }
+        nasm_alloc_failed();
+    }
+    return p;
+}
+
+void *nasm_calloc(size_t nelem, size_t size)
+{
+    void *p;
+
+again:
+    p = calloc(nelem, size);
+
+    if (unlikely(!p)) {
+        if (!nelem || !size) {
+            nelem = size = 1;
+            goto again;
+        }
+        nasm_alloc_failed();
+    }
+
+    return p;
+}
+
+void *nasm_zalloc(size_t size)
+{
+    return nasm_calloc(size, 1);
+}
+
+/*
+ * Unlike the system realloc, we do *not* allow size == 0 to be
+ * the equivalent to free(); we guarantee returning a non-NULL pointer.
+ *
+ * The check for calling malloc() is theoretically redundant, but be
+ * paranoid about the system library...
+ */
+void *nasm_realloc(void *q, size_t size)
+{
+    if (unlikely(!size))
+        size = 1;
+    q = q ? realloc(q, size) : malloc(size);
+    return validate_ptr(q);
+}
+
+void nasm_free(void *q)
+{
+    if (q)
+        free(q);
+}
+
+char *nasm_strdup(const char *s)
+{
+    char *p;
+    const size_t size = strlen(s) + 1;
+
+    _nasm_last_string_size = size;
+    p = nasm_malloc(size);
+    return memcpy(p, s, size);
+}
+
+char *nasm_strndup(const char *s, size_t len)
+{
+    char *p;
+
+    len = strnlen(s, len);
+    _nasm_last_string_size = len + 1;
+    p = nasm_malloc(len+1);
+    p[len] = '\0';
+    return memcpy(p, s, len);
+}
+
+char *nasm_strcat(const char *one, const char *two)
+{
+    char *rslt;
+    const size_t l1 = strlen(one);
+    const size_t s2 = strlen(two) + 1;
+
+    _nasm_last_string_size = l1 + s2;
+    rslt = nasm_malloc(l1 + s2);
+    memcpy(rslt, one, l1);
+    memcpy(rslt + l1, two, s2);
+    return rslt;
+}
+
+char *nasm_strcatn(const char *str1, ...)
+{
+    va_list ap;
+    char *rslt;                 /* Output buffer */
+    size_t s;                   /* Total buffer size */
+    size_t n;                   /* Number of arguments */
+    size_t *ltbl;               /* Table of lengths */
+    size_t l, *lp;              /* Length for current argument */
+    const char *p;              /* Currently examined argument */
+    char *q;                    /* Output pointer */
+
+    n = 0;                      /* No strings encountered yet */
+    p = str1;
+    va_start(ap, str1);
+    while (p) {
+        n++;
+        p = va_arg(ap, const char *);
+    }
+    va_end(ap);
+
+    ltbl = nasm_malloc(n * sizeof(size_t));
+
+    s = 1;                      /* Space for final NULL */
+    p = str1;
+    lp = ltbl;
+    va_start(ap, str1);
+    while (p) {
+        *lp++ = l = strlen(p);
+        s += l;
+        p = va_arg(ap, const char *);
+    }
+    va_end(ap);
+
+    _nasm_last_string_size = s;
+
+    q = rslt = nasm_malloc(s);
+
+    p = str1;
+    lp = ltbl;
+    va_start(ap, str1);
+    while (p) {
+        l = *lp++;
+        memcpy(q, p, l);
+        q += l;
+        p = va_arg(ap, const char *);
+    }
+    va_end(ap);
+    *q = '\0';
+
+    nasm_free(ltbl);
+
+    return rslt;
+}
diff --git a/vere/ext/nasm/nasmlib/alloc.h b/vere/ext/nasm/nasmlib/alloc.h
new file mode 100644
index 0000000..9b8ad19
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/alloc.h
@@ -0,0 +1,50 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASMLIB_ALLOC_H
+#define NASMLIB_ALLOC_H
+
+#include "compiler.h"
+
+fatal_func nasm_alloc_failed(void);
+
+static inline void *validate_ptr(void *p)
+{
+    if (unlikely(!p))
+        nasm_alloc_failed();
+    return p;
+}
+
+extern size_t _nasm_last_string_size;
+
+#endif /* NASMLIB_ALLOC_H */
diff --git a/vere/ext/nasm/nasmlib/asprintf.c b/vere/ext/nasm/nasmlib/asprintf.c
new file mode 100644
index 0000000..0b8e49d
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/asprintf.c
@@ -0,0 +1,94 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "alloc.h"
+
+/*
+ * nasm_[v]asprintf() are variants of the semi-standard [v]asprintf()
+ * functions, except that we return the pointer instead of a count.
+ * The length of the string (with or without the final NUL) is available
+ * by calling nasm_last_string_{len,size}() afterwards.
+ *
+ * nasm_[v]axprintf() are similar, but allocates a user-defined amount
+ * of storage before the string, and returns a pointer to the
+ * allocated buffer. The size of that area is not included in the value
+ * returned by nasm_last_string_size().
+ */
+
+void *nasm_vaxprintf(size_t extra, const char *fmt, va_list ap)
+{
+    char *strp;
+    va_list xap;
+    size_t bytes;
+
+    va_copy(xap, ap);
+    bytes = vsnprintf(NULL, 0, fmt, xap) + 1;
+    _nasm_last_string_size = bytes;
+    va_end(xap);
+
+    strp = nasm_malloc(extra+bytes);
+    memset(strp, 0, extra);
+    vsnprintf(strp+extra, bytes, fmt, ap);
+    return strp;
+}
+
+char *nasm_vasprintf(const char *fmt, va_list ap)
+{
+    return nasm_vaxprintf(0, fmt, ap);
+}
+
+void *nasm_axprintf(size_t extra, const char *fmt, ...)
+{
+    va_list ap;
+    void *strp;
+
+    va_start(ap, fmt);
+    strp = nasm_vaxprintf(extra, fmt, ap);
+    va_end(ap);
+
+    return strp;
+}
+
+char *nasm_asprintf(const char *fmt, ...)
+{
+    va_list ap;
+    char *strp;
+
+    va_start(ap, fmt);
+    strp = nasm_vaxprintf(0, fmt, ap);
+    va_end(ap);
+
+    return strp;
+}
diff --git a/vere/ext/nasm/nasmlib/badenum.c b/vere/ext/nasm/nasmlib/badenum.c
new file mode 100644
index 0000000..6f880c8
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/badenum.c
@@ -0,0 +1,43 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "nasmlib.h"
+
+/* Used to avoid returning NULL to a debug printing function */
+const char *invalid_enum_str(int x)
+{
+    static char buf[64];
+
+    snprintf(buf, sizeof buf, "<invalid %d>", x);
+    return buf;
+}
diff --git a/vere/ext/nasm/nasmlib/bsi.c b/vere/ext/nasm/nasmlib/bsi.c
new file mode 100644
index 0000000..ae31f48
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/bsi.c
@@ -0,0 +1,76 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+
+#include "nasmlib.h"
+
+/*
+ * Binary search.
+ */
+int bsi(const char *string, const char **array, int size)
+{
+    int i = -1, j = size;       /* always, i < index < j */
+    while (j - i >= 2) {
+        int k = (i + j) / 2;
+        int l = strcmp(string, array[k]);
+        if (l < 0)              /* it's in the first half */
+            j = k;
+        else if (l > 0)         /* it's in the second half */
+            i = k;
+        else                    /* we've got it :) */
+            return k;
+    }
+    return -1;                  /* we haven't got it :( */
+}
+
+int bsii(const char *string, const char **array, int size)
+{
+    int i = -1, j = size;       /* always, i < index < j */
+    while (j - i >= 2) {
+        int k = (i + j) / 2;
+        int l = nasm_stricmp(string, array[k]);
+        if (l < 0)              /* it's in the first half */
+            j = k;
+        else if (l > 0)         /* it's in the second half */
+            i = k;
+        else                    /* we've got it :) */
+            return k;
+    }
+    return -1;                  /* we haven't got it :( */
+}
diff --git a/vere/ext/nasm/nasmlib/crc32.c b/vere/ext/nasm/nasmlib/crc32.c
new file mode 100644
index 0000000..9b4068e
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/crc32.c
@@ -0,0 +1,115 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2021 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+#include "hashtbl.h"
+
+const uint32_t crc32_tab[256] = {
+    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
+    0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+    0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+    0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
+    0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+    0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
+    0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
+    0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+    0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
+    0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+    0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
+    0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
+    0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+    0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
+    0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+    0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
+    0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+    0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
+    0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+};
+
+uint32_t crc32b(uint32_t crc, const void *data, size_t len)
+{
+    register const uint8_t *p = data;
+    register uint32_t hashval = crc;
+
+    while (len--)
+    {
+        hashval = (hashval >> 8) ^ crc32_tab[(hashval ^ *p++) & 0xff];
+    }
+
+    return hashval;
+}
diff --git a/vere/ext/nasm/nasmlib/crc64.c b/vere/ext/nasm/nasmlib/crc64.c
new file mode 100644
index 0000000..e37e07b
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/crc64.c
@@ -0,0 +1,207 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2014 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+#include "nctype.h"
+#include "hashtbl.h"
+
+const uint64_t crc64_tab[256] = {
+    UINT64_C(0x0000000000000000), UINT64_C(0x7ad870c830358979),
+    UINT64_C(0xf5b0e190606b12f2), UINT64_C(0x8f689158505e9b8b),
+    UINT64_C(0xc038e5739841b68f), UINT64_C(0xbae095bba8743ff6),
+    UINT64_C(0x358804e3f82aa47d), UINT64_C(0x4f50742bc81f2d04),
+    UINT64_C(0xab28ecb46814fe75), UINT64_C(0xd1f09c7c5821770c),
+    UINT64_C(0x5e980d24087fec87), UINT64_C(0x24407dec384a65fe),
+    UINT64_C(0x6b1009c7f05548fa), UINT64_C(0x11c8790fc060c183),
+    UINT64_C(0x9ea0e857903e5a08), UINT64_C(0xe478989fa00bd371),
+    UINT64_C(0x7d08ff3b88be6f81), UINT64_C(0x07d08ff3b88be6f8),
+    UINT64_C(0x88b81eabe8d57d73), UINT64_C(0xf2606e63d8e0f40a),
+    UINT64_C(0xbd301a4810ffd90e), UINT64_C(0xc7e86a8020ca5077),
+    UINT64_C(0x4880fbd87094cbfc), UINT64_C(0x32588b1040a14285),
+    UINT64_C(0xd620138fe0aa91f4), UINT64_C(0xacf86347d09f188d),
+    UINT64_C(0x2390f21f80c18306), UINT64_C(0x594882d7b0f40a7f),
+    UINT64_C(0x1618f6fc78eb277b), UINT64_C(0x6cc0863448deae02),
+    UINT64_C(0xe3a8176c18803589), UINT64_C(0x997067a428b5bcf0),
+    UINT64_C(0xfa11fe77117cdf02), UINT64_C(0x80c98ebf2149567b),
+    UINT64_C(0x0fa11fe77117cdf0), UINT64_C(0x75796f2f41224489),
+    UINT64_C(0x3a291b04893d698d), UINT64_C(0x40f16bccb908e0f4),
+    UINT64_C(0xcf99fa94e9567b7f), UINT64_C(0xb5418a5cd963f206),
+    UINT64_C(0x513912c379682177), UINT64_C(0x2be1620b495da80e),
+    UINT64_C(0xa489f35319033385), UINT64_C(0xde51839b2936bafc),
+    UINT64_C(0x9101f7b0e12997f8), UINT64_C(0xebd98778d11c1e81),
+    UINT64_C(0x64b116208142850a), UINT64_C(0x1e6966e8b1770c73),
+    UINT64_C(0x8719014c99c2b083), UINT64_C(0xfdc17184a9f739fa),
+    UINT64_C(0x72a9e0dcf9a9a271), UINT64_C(0x08719014c99c2b08),
+    UINT64_C(0x4721e43f0183060c), UINT64_C(0x3df994f731b68f75),
+    UINT64_C(0xb29105af61e814fe), UINT64_C(0xc849756751dd9d87),
+    UINT64_C(0x2c31edf8f1d64ef6), UINT64_C(0x56e99d30c1e3c78f),
+    UINT64_C(0xd9810c6891bd5c04), UINT64_C(0xa3597ca0a188d57d),
+    UINT64_C(0xec09088b6997f879), UINT64_C(0x96d1784359a27100),
+    UINT64_C(0x19b9e91b09fcea8b), UINT64_C(0x636199d339c963f2),
+    UINT64_C(0xdf7adabd7a6e2d6f), UINT64_C(0xa5a2aa754a5ba416),
+    UINT64_C(0x2aca3b2d1a053f9d), UINT64_C(0x50124be52a30b6e4),
+    UINT64_C(0x1f423fcee22f9be0), UINT64_C(0x659a4f06d21a1299),
+    UINT64_C(0xeaf2de5e82448912), UINT64_C(0x902aae96b271006b),
+    UINT64_C(0x74523609127ad31a), UINT64_C(0x0e8a46c1224f5a63),
+    UINT64_C(0x81e2d7997211c1e8), UINT64_C(0xfb3aa75142244891),
+    UINT64_C(0xb46ad37a8a3b6595), UINT64_C(0xceb2a3b2ba0eecec),
+    UINT64_C(0x41da32eaea507767), UINT64_C(0x3b024222da65fe1e),
+    UINT64_C(0xa2722586f2d042ee), UINT64_C(0xd8aa554ec2e5cb97),
+    UINT64_C(0x57c2c41692bb501c), UINT64_C(0x2d1ab4dea28ed965),
+    UINT64_C(0x624ac0f56a91f461), UINT64_C(0x1892b03d5aa47d18),
+    UINT64_C(0x97fa21650afae693), UINT64_C(0xed2251ad3acf6fea),
+    UINT64_C(0x095ac9329ac4bc9b), UINT64_C(0x7382b9faaaf135e2),
+    UINT64_C(0xfcea28a2faafae69), UINT64_C(0x8632586aca9a2710),
+    UINT64_C(0xc9622c4102850a14), UINT64_C(0xb3ba5c8932b0836d),
+    UINT64_C(0x3cd2cdd162ee18e6), UINT64_C(0x460abd1952db919f),
+    UINT64_C(0x256b24ca6b12f26d), UINT64_C(0x5fb354025b277b14),
+    UINT64_C(0xd0dbc55a0b79e09f), UINT64_C(0xaa03b5923b4c69e6),
+    UINT64_C(0xe553c1b9f35344e2), UINT64_C(0x9f8bb171c366cd9b),
+    UINT64_C(0x10e3202993385610), UINT64_C(0x6a3b50e1a30ddf69),
+    UINT64_C(0x8e43c87e03060c18), UINT64_C(0xf49bb8b633338561),
+    UINT64_C(0x7bf329ee636d1eea), UINT64_C(0x012b592653589793),
+    UINT64_C(0x4e7b2d0d9b47ba97), UINT64_C(0x34a35dc5ab7233ee),
+    UINT64_C(0xbbcbcc9dfb2ca865), UINT64_C(0xc113bc55cb19211c),
+    UINT64_C(0x5863dbf1e3ac9dec), UINT64_C(0x22bbab39d3991495),
+    UINT64_C(0xadd33a6183c78f1e), UINT64_C(0xd70b4aa9b3f20667),
+    UINT64_C(0x985b3e827bed2b63), UINT64_C(0xe2834e4a4bd8a21a),
+    UINT64_C(0x6debdf121b863991), UINT64_C(0x1733afda2bb3b0e8),
+    UINT64_C(0xf34b37458bb86399), UINT64_C(0x8993478dbb8deae0),
+    UINT64_C(0x06fbd6d5ebd3716b), UINT64_C(0x7c23a61ddbe6f812),
+    UINT64_C(0x3373d23613f9d516), UINT64_C(0x49aba2fe23cc5c6f),
+    UINT64_C(0xc6c333a67392c7e4), UINT64_C(0xbc1b436e43a74e9d),
+    UINT64_C(0x95ac9329ac4bc9b5), UINT64_C(0xef74e3e19c7e40cc),
+    UINT64_C(0x601c72b9cc20db47), UINT64_C(0x1ac40271fc15523e),
+    UINT64_C(0x5594765a340a7f3a), UINT64_C(0x2f4c0692043ff643),
+    UINT64_C(0xa02497ca54616dc8), UINT64_C(0xdafce7026454e4b1),
+    UINT64_C(0x3e847f9dc45f37c0), UINT64_C(0x445c0f55f46abeb9),
+    UINT64_C(0xcb349e0da4342532), UINT64_C(0xb1eceec59401ac4b),
+    UINT64_C(0xfebc9aee5c1e814f), UINT64_C(0x8464ea266c2b0836),
+    UINT64_C(0x0b0c7b7e3c7593bd), UINT64_C(0x71d40bb60c401ac4),
+    UINT64_C(0xe8a46c1224f5a634), UINT64_C(0x927c1cda14c02f4d),
+    UINT64_C(0x1d148d82449eb4c6), UINT64_C(0x67ccfd4a74ab3dbf),
+    UINT64_C(0x289c8961bcb410bb), UINT64_C(0x5244f9a98c8199c2),
+    UINT64_C(0xdd2c68f1dcdf0249), UINT64_C(0xa7f41839ecea8b30),
+    UINT64_C(0x438c80a64ce15841), UINT64_C(0x3954f06e7cd4d138),
+    UINT64_C(0xb63c61362c8a4ab3), UINT64_C(0xcce411fe1cbfc3ca),
+    UINT64_C(0x83b465d5d4a0eece), UINT64_C(0xf96c151de49567b7),
+    UINT64_C(0x76048445b4cbfc3c), UINT64_C(0x0cdcf48d84fe7545),
+    UINT64_C(0x6fbd6d5ebd3716b7), UINT64_C(0x15651d968d029fce),
+    UINT64_C(0x9a0d8ccedd5c0445), UINT64_C(0xe0d5fc06ed698d3c),
+    UINT64_C(0xaf85882d2576a038), UINT64_C(0xd55df8e515432941),
+    UINT64_C(0x5a3569bd451db2ca), UINT64_C(0x20ed197575283bb3),
+    UINT64_C(0xc49581ead523e8c2), UINT64_C(0xbe4df122e51661bb),
+    UINT64_C(0x3125607ab548fa30), UINT64_C(0x4bfd10b2857d7349),
+    UINT64_C(0x04ad64994d625e4d), UINT64_C(0x7e7514517d57d734),
+    UINT64_C(0xf11d85092d094cbf), UINT64_C(0x8bc5f5c11d3cc5c6),
+    UINT64_C(0x12b5926535897936), UINT64_C(0x686de2ad05bcf04f),
+    UINT64_C(0xe70573f555e26bc4), UINT64_C(0x9ddd033d65d7e2bd),
+    UINT64_C(0xd28d7716adc8cfb9), UINT64_C(0xa85507de9dfd46c0),
+    UINT64_C(0x273d9686cda3dd4b), UINT64_C(0x5de5e64efd965432),
+    UINT64_C(0xb99d7ed15d9d8743), UINT64_C(0xc3450e196da80e3a),
+    UINT64_C(0x4c2d9f413df695b1), UINT64_C(0x36f5ef890dc31cc8),
+    UINT64_C(0x79a59ba2c5dc31cc), UINT64_C(0x037deb6af5e9b8b5),
+    UINT64_C(0x8c157a32a5b7233e), UINT64_C(0xf6cd0afa9582aa47),
+    UINT64_C(0x4ad64994d625e4da), UINT64_C(0x300e395ce6106da3),
+    UINT64_C(0xbf66a804b64ef628), UINT64_C(0xc5bed8cc867b7f51),
+    UINT64_C(0x8aeeace74e645255), UINT64_C(0xf036dc2f7e51db2c),
+    UINT64_C(0x7f5e4d772e0f40a7), UINT64_C(0x05863dbf1e3ac9de),
+    UINT64_C(0xe1fea520be311aaf), UINT64_C(0x9b26d5e88e0493d6),
+    UINT64_C(0x144e44b0de5a085d), UINT64_C(0x6e963478ee6f8124),
+    UINT64_C(0x21c640532670ac20), UINT64_C(0x5b1e309b16452559),
+    UINT64_C(0xd476a1c3461bbed2), UINT64_C(0xaeaed10b762e37ab),
+    UINT64_C(0x37deb6af5e9b8b5b), UINT64_C(0x4d06c6676eae0222),
+    UINT64_C(0xc26e573f3ef099a9), UINT64_C(0xb8b627f70ec510d0),
+    UINT64_C(0xf7e653dcc6da3dd4), UINT64_C(0x8d3e2314f6efb4ad),
+    UINT64_C(0x0256b24ca6b12f26), UINT64_C(0x788ec2849684a65f),
+    UINT64_C(0x9cf65a1b368f752e), UINT64_C(0xe62e2ad306bafc57),
+    UINT64_C(0x6946bb8b56e467dc), UINT64_C(0x139ecb4366d1eea5),
+    UINT64_C(0x5ccebf68aecec3a1), UINT64_C(0x2616cfa09efb4ad8),
+    UINT64_C(0xa97e5ef8cea5d153), UINT64_C(0xd3a62e30fe90582a),
+    UINT64_C(0xb0c7b7e3c7593bd8), UINT64_C(0xca1fc72bf76cb2a1),
+    UINT64_C(0x45775673a732292a), UINT64_C(0x3faf26bb9707a053),
+    UINT64_C(0x70ff52905f188d57), UINT64_C(0x0a2722586f2d042e),
+    UINT64_C(0x854fb3003f739fa5), UINT64_C(0xff97c3c80f4616dc),
+    UINT64_C(0x1bef5b57af4dc5ad), UINT64_C(0x61372b9f9f784cd4),
+    UINT64_C(0xee5fbac7cf26d75f), UINT64_C(0x9487ca0fff135e26),
+    UINT64_C(0xdbd7be24370c7322), UINT64_C(0xa10fceec0739fa5b),
+    UINT64_C(0x2e675fb4576761d0), UINT64_C(0x54bf2f7c6752e8a9),
+    UINT64_C(0xcdcf48d84fe75459), UINT64_C(0xb71738107fd2dd20),
+    UINT64_C(0x387fa9482f8c46ab), UINT64_C(0x42a7d9801fb9cfd2),
+    UINT64_C(0x0df7adabd7a6e2d6), UINT64_C(0x772fdd63e7936baf),
+    UINT64_C(0xf8474c3bb7cdf024), UINT64_C(0x829f3cf387f8795d),
+    UINT64_C(0x66e7a46c27f3aa2c), UINT64_C(0x1c3fd4a417c62355),
+    UINT64_C(0x935745fc4798b8de), UINT64_C(0xe98f353477ad31a7),
+    UINT64_C(0xa6df411fbfb21ca3), UINT64_C(0xdc0731d78f8795da),
+    UINT64_C(0x536fa08fdfd90e51), UINT64_C(0x29b7d047efec8728),
+};
+
+uint64_t crc64(uint64_t crc, const char *str)
+{
+    uint8_t c;
+
+    while ((c = *str++) != 0)
+        crc = crc64_byte(crc, c);
+
+    return crc;
+}
+
+uint64_t crc64i(uint64_t crc, const char *str)
+{
+    uint8_t c;
+
+    while ((c = *str++) != 0)
+	crc = crc64_byte(crc, nasm_tolower(c));
+
+    return crc;
+}
+
+uint64_t crc64b(uint64_t crc, const void *data, size_t len)
+{
+    const uint8_t *str = data;
+
+    while (len--)
+        crc = crc64_byte(crc, *str++);
+
+    return crc;
+}
+
+uint64_t crc64ib(uint64_t crc, const void *data, size_t len)
+{
+    const uint8_t *str = data;
+
+    while (len--)
+        crc = crc64_byte(crc, nasm_tolower(*str++));
+
+    return crc;
+}
diff --git a/vere/ext/nasm/nasmlib/errfile.c b/vere/ext/nasm/nasmlib/errfile.c
new file mode 100644
index 0000000..a2c5e4f
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/errfile.c
@@ -0,0 +1,4 @@
+#include "compiler.h"
+
+FILE *error_file;
+
diff --git a/vere/ext/nasm/nasmlib/file.c b/vere/ext/nasm/nasmlib/file.c
new file mode 100644
index 0000000..62b854d
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/file.c
@@ -0,0 +1,352 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "file.h"
+
+void nasm_read(void *ptr, size_t size, FILE *f)
+{
+    size_t n = fread(ptr, 1, size, f);
+    if (ferror(f)) {
+        nasm_fatal("unable to read input: %s", strerror(errno));
+    } else if (n != size || feof(f)) {
+        nasm_fatal("fatal short read on input");
+    }
+}
+
+void nasm_write(const void *ptr, size_t size, FILE *f)
+{
+    size_t n = fwrite(ptr, 1, size, f);
+    if (n != size || ferror(f) || feof(f))
+        nasm_fatal("unable to write output: %s", strerror(errno));
+}
+
+void fwriteint16_t(uint16_t data, FILE * fp)
+{
+    data = cpu_to_le16(data);
+    nasm_write(&data, 2, fp);
+}
+
+void fwriteint32_t(uint32_t data, FILE * fp)
+{
+    data = cpu_to_le32(data);
+    nasm_write(&data, 4, fp);
+}
+
+void fwriteint64_t(uint64_t data, FILE * fp)
+{
+    data = cpu_to_le64(data);
+    nasm_write(&data, 8, fp);
+}
+
+void fwriteaddr(uint64_t data, int size, FILE * fp)
+{
+    data = cpu_to_le64(data);
+    nasm_write(&data, size, fp);
+}
+
+void fwritezero(off_t bytes, FILE *fp)
+{
+    size_t blksize;
+
+#ifdef os_ftruncate
+    if (bytes >= BUFSIZ && !ferror(fp) && !feof(fp)) {
+	off_t pos = ftello(fp);
+	if (pos != (off_t)-1) {
+            off_t end = pos + bytes;
+	    if (!fflush(fp) && !os_ftruncate(fileno(fp), end)) {
+                fseeko(fp, 0, SEEK_END);
+                pos = ftello(fp);
+                if (pos != (off_t)-1)
+                    bytes = end - pos; /* This SHOULD be zero */
+            }
+	}
+    }
+#endif
+
+    while (bytes > 0) {
+	blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
+
+	nasm_write(zero_buffer, blksize, fp);
+	bytes -= blksize;
+    }
+}
+
+#ifdef _WIN32
+
+/*
+ * On Windows, we want to use _wfopen(), as fopen() has a much smaller limit
+ * on the path length that it supports.
+ *
+ * Previously we tried to prefix the path name with \\?\ in order to
+ * let the Windows kernel know that we are not limited to PATH_MAX
+ * characters, but it breaks relative paths among other things, and
+ * apparently Windows 10 contains a registry option to override this
+ * limit anyway. One day maybe they will even implement UTF-8 as byte
+ * characters so we can use the standard file API even on this OS.
+ */
+
+os_filename os_mangle_filename(const char *filename)
+{
+    mbstate_t ps;
+    size_t wclen;
+    wchar_t *buf;
+    const char *p;
+
+    /*
+     * Note: mbsrtowcs() return (size_t)-1 on error, otherwise
+     * the length of the string *without* final NUL in wchar_t
+     * units. Thus we add 1 for the final NUL; the error value
+     * now becomes 0.
+     */
+    memset(&ps, 0, sizeof ps);  /* Begin in the initial state */
+    p = filename;
+    wclen = mbsrtowcs(NULL, &p, 0, &ps) + 1;
+    if (!wclen)
+        return NULL;
+
+    buf = nasm_malloc(wclen * sizeof(wchar_t));
+
+    memset(&ps, 0, sizeof ps);  /* Begin in the initial state */
+    p = filename;
+    if (mbsrtowcs(buf, &p, wclen, &ps) + 1 != wclen || p) {
+        nasm_free(buf);
+        return NULL;
+    }
+
+    return buf;
+}
+
+#endif
+
+void nasm_set_binary_mode(FILE *f)
+{
+	os_set_binary_mode(f);
+}
+
+FILE *nasm_open_read(const char *filename, enum file_flags flags)
+{
+    FILE *f = NULL;
+    os_filename osfname;
+
+    osfname = os_mangle_filename(filename);
+    if (osfname) {
+        os_fopenflag fopen_flags[4];
+        memset(fopen_flags, 0, sizeof fopen_flags);
+
+        fopen_flags[0] = 'r';
+        fopen_flags[1] = (flags & NF_TEXT) ? 't' : 'b';
+
+#if defined(__GLIBC__) || defined(__linux__)
+        /*
+         * Try to open this file with memory mapping for speed, unless we are
+         * going to do it "manually" with nasm_map_file()
+         */
+        if (!(flags & NF_FORMAP))
+            fopen_flags[2] = 'm';
+#endif
+
+        while (true) {
+            f = os_fopen(osfname, fopen_flags);
+            if (f || errno != EINVAL || !fopen_flags[2])
+                break;
+
+            /* We got EINVAL but with 'm'; try again without 'm' */
+            fopen_flags[2] = '\0';
+        }
+
+        os_free_filename(osfname);
+    }
+
+    if (!f && (flags & NF_FATAL))
+        nasm_fatalf(ERR_NOFILE, "unable to open input file: `%s': %s",
+                    filename, strerror(errno));
+
+    return f;
+}
+
+FILE *nasm_open_write(const char *filename, enum file_flags flags)
+{
+    FILE *f = NULL;
+    os_filename osfname;
+
+    osfname = os_mangle_filename(filename);
+    if (osfname) {
+        os_fopenflag fopen_flags[3];
+
+        fopen_flags[0] = 'w';
+        fopen_flags[1] = (flags & NF_TEXT) ? 't' : 'b';
+        fopen_flags[2] = '\0';
+
+        f = os_fopen(osfname, fopen_flags);
+        os_free_filename(osfname);
+    }
+
+    if (!f && (flags & NF_FATAL))
+        nasm_fatalf(ERR_NOFILE, "unable to open output file: `%s': %s",
+                    filename, strerror(errno));
+
+    switch (flags & NF_BUF_MASK) {
+    case NF_IONBF:
+        setvbuf(f, NULL, _IONBF, 0);
+        break;
+    case NF_IOLBF:
+        setvbuf(f, NULL, _IOLBF, 0);
+        break;
+    case NF_IOFBF:
+        setvbuf(f, NULL, _IOFBF, 0);
+        break;
+    default:
+        break;
+    }
+
+    return f;
+}
+
+/* The appropriate "rb" strings for os_fopen() */
+static const os_fopenflag fopenflags_rb[3] = { 'r', 'b', 0 };
+
+/*
+ * Report the existence of a file
+ */
+bool nasm_file_exists(const char *filename)
+{
+#ifndef os_access
+    FILE *f;
+#endif
+    os_filename osfname;
+    bool exists;
+
+    osfname = os_mangle_filename(filename);
+    if (!osfname)
+        return false;
+
+#ifdef os_access
+    exists = os_access(osfname, R_OK) == 0;
+#else
+    f = os_fopen(osfname, fopenflags_rb);
+    exists = f != NULL;
+    if (f)
+        fclose(f);
+#endif
+
+    os_free_filename(osfname);
+    return exists;
+}
+
+/*
+ * Report the file size of an open file.  This MAY move the file pointer.
+ */
+off_t nasm_file_size(FILE *f)
+{
+    off_t where, end;
+    os_struct_stat st;
+
+    if (!os_fstat(fileno(f), &st) && S_ISREG(st.st_mode))
+        return st.st_size;
+
+    /* Do it the hard way... this tests for seekability */
+
+    if (fseeko(f, 0, SEEK_CUR))
+        goto fail;              /* Not seekable, don't even try */
+
+    where = ftello(f);
+    if (where == (off_t)-1)
+        goto fail;
+
+    if (fseeko(f, 0, SEEK_END))
+        goto fail;
+
+    end = ftello(f);
+    if (end == (off_t)-1)
+        goto fail;
+
+    /*
+     * Move the file pointer back. If this fails, this is probably
+     * not a plain file.
+     */
+    if (fseeko(f, where, SEEK_SET))
+        goto fail;
+
+    return end;
+
+fail:
+    return -1;
+}
+
+/*
+ * Report file size given pathname
+ */
+off_t nasm_file_size_by_path(const char *pathname)
+{
+    os_filename osfname;
+    off_t len = -1;
+    os_struct_stat st;
+    FILE *fp;
+
+    osfname = os_mangle_filename(pathname);
+
+    if (!os_stat(osfname, &st) && S_ISREG(st.st_mode))
+        len = st.st_size;
+
+    fp = os_fopen(osfname, fopenflags_rb);
+    if (fp) {
+        len = nasm_file_size(fp);
+        fclose(fp);
+    }
+
+    return len;
+}
+
+/*
+ * Report the timestamp on a file, returns true if successful
+ */
+bool nasm_file_time(time_t *t, const char *pathname)
+{
+#ifdef os_stat
+    os_filename osfname;
+    os_struct_stat st;
+    bool rv = false;
+
+    osfname = os_mangle_filename(pathname);
+    if (!osfname)
+        return false;
+
+    rv = !os_stat(osfname, &st);
+    *t = st.st_mtime;
+    os_free_filename(osfname);
+
+    return rv;
+#else
+    return false;               /* No idea how to do this on this OS */
+#endif
+}
diff --git a/vere/ext/nasm/nasmlib/file.h b/vere/ext/nasm/nasmlib/file.h
new file mode 100644
index 0000000..140cde3
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/file.h
@@ -0,0 +1,234 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASMLIB_FILE_H
+#define NASMLIB_FILE_H
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+
+#include <errno.h>
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef HAVE_IO_H
+# include <io.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+
+#ifndef R_OK
+# define R_OK 4                 /* Classic Unix constant, same on Windows */
+#endif
+
+/* Can we adjust the file size without actually writing all the bytes? */
+#ifdef HAVE__CHSIZE_S
+# define os_ftruncate(fd,size)	_chsize_s(fd,size)
+#elif defined(HAVE__CHSIZE)
+# define os_ftruncate(fd,size)	_chsize(fd,size)
+#elif defined(HAVE_FTRUNCATE)
+# define os_ftruncate(fd,size)	ftruncate(fd,size)
+#endif
+
+/*
+ * On Windows, we want to use _wfopen(), as fopen() has a much smaller limit
+ * on the path length that it supports. Furthermore, we want to prefix the
+ * path name with \\?\ in order to let the Windows kernel know that
+ * we are not limited to PATH_MAX characters. Thus, we wrap all the functions
+ * which take filenames...
+ */
+#ifdef _WIN32
+# include <wchar.h>
+typedef wchar_t *os_filename;
+typedef wchar_t  os_fopenflag;
+
+os_filename os_mangle_filename(const char *filename);
+static inline void os_free_filename(os_filename filename)
+{
+    nasm_free(filename);
+}
+
+# define os_fopen  _wfopen
+# define os_access _waccess
+
+/*
+ * On Win32/64, we have to use the _wstati64() function. Note that
+ * we can't use _wstat64() without depending on a needlessly new
+ * version os MSVCRT.
+ */
+
+typedef struct _stati64 os_struct_stat;
+
+# define os_stat  _wstati64
+# define os_fstat _fstati64
+
+/*
+ * On Win32/64, freopen() and _wfreopen() fails when the mode string
+ * is with the letter 'b' that represents to set binary mode. On
+ * POSIX operating systems, the 'b' is ignored, without failure.
+ */
+
+#include <io.h>
+#include <fcntl.h>
+
+static inline void os_set_binary_mode(FILE *f) {
+    int ret = _setmode(_fileno(f), _O_BINARY);
+
+    if (ret == -1) {
+        nasm_fatalf(ERR_NOFILE, "unable to open file: %s",
+                    strerror(errno));
+    }
+}
+
+#else  /* not _WIN32 */
+
+typedef const char *os_filename;
+typedef char os_fopenflag;
+
+static inline os_filename os_mangle_filename(const char *filename)
+{
+    return filename;
+}
+static inline void os_free_filename(os_filename filename)
+{
+    (void)filename;             /* Nothing to do */
+}
+
+static inline void os_set_binary_mode(FILE *f) {
+    (void)f;
+}
+
+# define os_fopen  fopen
+
+#if defined(HAVE_FACCESSAT) && defined(AT_EACCESS)
+static inline int os_access(os_filename pathname, int mode)
+{
+    return faccessat(AT_FDCWD, pathname, mode, AT_EACCESS);
+}
+# define os_access os_access
+#elif defined(HAVE_ACCESS)
+# define os_access access
+#endif
+
+#ifdef HAVE_STRUCT_STAT
+typedef struct stat os_struct_stat;
+# ifdef HAVE_STAT
+#  define os_stat stat
+# endif
+# ifdef HAVE_FSTAT
+#  define os_fstat fstat
+# endif
+#else
+struct dummy_struct_stat {
+    int st_mode;
+    int st_size;
+};
+typedef struct dummy_struct_stat os_struct_stat;
+#endif
+
+#endif  /* Not _WIN32 */
+
+#ifdef S_ISREG
+/* all good */
+#elif defined(HAVE_S_ISREG)
+/* exists, but not a macro */
+# define S_ISREG S_ISREG
+#elif defined(S_IFMT) && defined(S_IFREG)
+# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#elif defined(_S_IFMT) && defined(_S_IFREG)
+# define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+#endif
+
+#ifdef fileno
+/* all good */
+#elif defined(HAVE_FILENO)
+/* exists, but not a macro */
+# define fileno fileno
+#elif defined(_fileno) || defined(HAVE__FILENO)
+# define fileno _fileno
+#endif
+
+#ifndef S_ISREG
+# undef os_stat
+# undef os_fstat
+#endif
+
+/* Disable these functions if they don't support something we need */
+#ifndef fileno
+# undef os_fstat
+# undef os_ftruncate
+# undef HAVE_MMAP
+#endif
+
+/*
+ * If we don't have functional versions of these functions,
+ * stub them out so we don't need so many #ifndefs
+ */
+#ifndef os_stat
+static inline int os_stat(os_filename osfname, os_struct_stat *st)
+{
+    (void)osfname;
+    (void)st;
+    return -1;
+}
+#endif
+
+#ifndef os_fstat
+static inline int os_fstat(int fd, os_struct_stat *st)
+{
+    (void)fd;
+    (void)st;
+    return -1;
+}
+#endif
+
+#ifndef S_ISREG
+static inline bool S_ISREG(int m)
+{
+    (void)m;
+    return false;
+}
+#endif
+
+#endif /* NASMLIB_FILE_H */
diff --git a/vere/ext/nasm/nasmlib/filename.c b/vere/ext/nasm/nasmlib/filename.c
new file mode 100644
index 0000000..172ae0b
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/filename.c
@@ -0,0 +1,63 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+
+/*
+ * Add/modify a filename extension, assumed to be a period-delimited
+ * field at the very end of the filename.  Returns a newly allocated
+ * string buffer.
+ */
+const char *filename_set_extension(const char *inname, const char *extension)
+{
+    const char *q = inname;
+    char *p;
+    size_t elen = strlen(extension);
+    size_t baselen;
+
+    q = strrchrnul(inname, '.');   /* find extension or end of string */
+    baselen = q - inname;
+
+    p = nasm_malloc(baselen + elen + 1);
+
+    memcpy(p, inname, baselen);
+    memcpy(p+baselen, extension, elen+1);
+
+    return p;
+}
diff --git a/vere/ext/nasm/nasmlib/hashtbl.c b/vere/ext/nasm/nasmlib/hashtbl.c
new file mode 100644
index 0000000..9a4c0b5
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/hashtbl.c
@@ -0,0 +1,287 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * hashtbl.c
+ *
+ * Efficient dictionary hash table class.
+ */
+
+#include "compiler.h"
+
+#include "nasm.h"
+#include "hashtbl.h"
+
+#define HASH_MAX_LOAD   2	/* Higher = more memory-efficient, slower */
+#define HASH_INIT_SIZE  16      /* Initial size (power of 2, min 4) */
+
+#define hash_calc(key,keylen)   crc64b(CRC64_INIT, (key), (keylen))
+#define hash_calci(key,keylen)  crc64ib(CRC64_INIT, (key), (keylen))
+#define hash_max_load(size)     ((size) * (HASH_MAX_LOAD - 1) / HASH_MAX_LOAD)
+#define hash_expand(size)       ((size) << 1)
+#define hash_mask(size)         ((size) - 1)
+#define hash_pos(hash, mask)    ((hash) & (mask))
+#define hash_inc(hash, mask)    ((((hash) >> 32) & (mask)) | 1) /* always odd */
+#define hash_pos_next(pos, inc, mask) (((pos) + (inc)) & (mask))
+
+static void hash_init(struct hash_table *head)
+{
+    head->size     = HASH_INIT_SIZE;
+    head->load     = 0;
+    head->max_load = hash_max_load(head->size);
+    nasm_newn(head->table, head->size);
+}
+
+/*
+ * Find an entry in a hash table.  The key can be any binary object.
+ *
+ * On failure, if "insert" is non-NULL, store data in that structure
+ * which can be used to insert that node using hash_add().
+ * See hash_add() for constraints on the uses of the insert object.
+ *
+ * On success, return a pointer to the "data" element of the hash
+ * structure.
+ */
+void **hash_findb(struct hash_table *head, const void *key,
+                  size_t keylen, struct hash_insert *insert)
+{
+    struct hash_node *np = NULL;
+    struct hash_node *tbl = head->table;
+    uint64_t hash = hash_calc(key, keylen);
+    size_t mask = hash_mask(head->size);
+    size_t pos = hash_pos(hash, mask);
+    size_t inc = hash_inc(hash, mask);
+
+    if (likely(tbl)) {
+        while ((np = &tbl[pos])->key) {
+            if (hash == np->hash &&
+                keylen == np->keylen &&
+                !memcmp(key, np->key, keylen))
+                return &np->data;
+            pos = hash_pos_next(pos, inc, mask);
+        }
+    }
+
+    /* Not found.  Store info for insert if requested. */
+    if (insert) {
+        insert->node.hash = hash;
+        insert->node.key = key;
+        insert->node.keylen = keylen;
+        insert->node.data = NULL;
+        insert->head  = head;
+        insert->where = np;
+    }
+    return NULL;
+}
+
+/*
+ * Same as hash_findb(), but for a C string.
+ */
+void **hash_find(struct hash_table *head, const char *key,
+                 struct hash_insert *insert)
+{
+    return hash_findb(head, key, strlen(key)+1, insert);
+}
+
+/*
+ * Same as hash_findb(), but for case-insensitive hashing.
+ */
+void **hash_findib(struct hash_table *head, const void *key, size_t keylen,
+                   struct hash_insert *insert)
+{
+    struct hash_node *np = NULL;
+    struct hash_node *tbl = head->table;
+    uint64_t hash = hash_calci(key, keylen);
+    size_t mask = hash_mask(head->size);
+    size_t pos = hash_pos(hash, mask);
+    size_t inc = hash_inc(hash, mask);
+
+    if (likely(tbl)) {
+        while ((np = &tbl[pos])->key) {
+            if (hash == np->hash &&
+                keylen == np->keylen &&
+                !nasm_memicmp(key, np->key, keylen))
+                return &np->data;
+            pos = hash_pos_next(pos, inc, mask);
+        }
+    }
+
+    /* Not found.  Store info for insert if requested. */
+    if (insert) {
+        insert->node.hash = hash;
+        insert->node.key = key;
+        insert->node.keylen = keylen;
+        insert->node.data = NULL;
+        insert->head  = head;
+        insert->where = np;
+    }
+    return NULL;
+}
+
+/*
+ * Same as hash_find(), but for case-insensitive hashing.
+ */
+void **hash_findi(struct hash_table *head, const char *key,
+                  struct hash_insert *insert)
+{
+    return hash_findib(head, key, strlen(key)+1, insert);
+}
+
+/*
+ * Insert node.  Return a pointer to the "data" element of the newly
+ * created hash node.
+ *
+ * The following constraints apply:
+ * 1. A call to hash_add() invalidates all other outstanding hash_insert
+ *    objects; attempting to use them causes a wild pointer reference.
+ * 2. The key provided must exactly match the key passed to hash_find*(),
+ *    but it does not have to point to the same storage address. The key
+ *    buffer provided to this function must not be freed for the lifespan
+ *    of the hash. NULL will use the same pointer that was passed to
+ *    hash_find*().
+ */
+void **hash_add(struct hash_insert *insert, const void *key, void *data)
+{
+    struct hash_table *head  = insert->head;
+    struct hash_node *np = insert->where;
+
+    if (unlikely(!np)) {
+        hash_init(head);
+        /* The hash table is empty, so we don't need to iterate here */
+        np = &head->table[hash_pos(insert->node.hash, hash_mask(head->size))];
+    }
+
+    /*
+     * Insert node.  We can always do this, even if we need to
+     * rebalance immediately after.
+     */
+    *np = insert->node;
+    np->data = data;
+    if (key)
+        np->key = key;
+
+    if (unlikely(++head->load > head->max_load)) {
+        /* Need to expand the table */
+        size_t newsize           = hash_expand(head->size);
+        struct hash_node *newtbl;
+        size_t mask              = hash_mask(newsize);
+        struct hash_node *op, *xp;
+        size_t i;
+
+        nasm_newn(newtbl, newsize);
+
+        /* Rebalance all the entries */
+        for (i = 0, op = head->table; i < head->size; i++, op++) {
+            if (op->key) {
+                size_t pos = hash_pos(op->hash, mask);
+                size_t inc = hash_inc(op->hash, mask);
+
+                while ((xp = &newtbl[pos])->key)
+                    pos = hash_pos_next(pos, inc, mask);
+
+                *xp = *op;
+                if (op == np)
+                    np = xp;
+            }
+        }
+        nasm_free(head->table);
+
+        head->table    = newtbl;
+        head->size     = newsize;
+        head->max_load = hash_max_load(newsize);
+    }
+
+    return &np->data;
+}
+
+/*
+ * Iterate over all members of a hash set. For the first call, iter
+ * should be as initialized by hash_iterator_init(). Returns a struct
+ * hash_node representing the current object, or NULL if we have
+ * reached the end of the hash table.
+ *
+ * Calling hash_add() will invalidate the iterator.
+ */
+const struct hash_node *hash_iterate(struct hash_iterator *iter)
+{
+    const struct hash_table *head = iter->head;
+    const struct hash_node *cp = iter->next;
+    const struct hash_node *ep = head->table + head->size;
+
+    /* For an empty table, cp == ep == NULL */
+    while (cp < ep) {
+        if (cp->key) {
+            iter->next = cp+1;
+            return cp;
+        }
+        cp++;
+    }
+
+    iter->next = head->table;
+    return NULL;
+}
+
+/*
+ * Free the hash itself.  Doesn't free the data elements; use
+ * hash_iterate() to do that first, if needed.  This function is normally
+ * used when the hash data entries are either freed separately, or
+ * compound objects which can't be freed in a single operation.
+ */
+void hash_free(struct hash_table *head)
+{
+    void *p = head->table;
+    memset(head, 0, sizeof *head);
+    nasm_free(p);
+}
+
+/*
+ * Frees the hash *and* all data elements.  This is applicable only in
+ * the case where the data element is a single allocation.  If the
+ * second argument is false, the key string is part of the data
+ * allocation or belongs to an allocation which will be freed
+ * separately, if it is true the keys are also freed.
+ */
+void hash_free_all(struct hash_table *head, bool free_keys)
+{
+    struct hash_iterator it;
+    const struct hash_node *np;
+
+    hash_for_each(head, it, np) {
+        if (np->data)
+            nasm_free(np->data);
+        if (free_keys && np->key)
+            nasm_free((void *)np->key);
+    }
+
+    hash_free(head);
+}
diff --git a/vere/ext/nasm/nasmlib/ilog2.c b/vere/ext/nasm/nasmlib/ilog2.c
new file mode 100644
index 0000000..cba2224
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/ilog2.c
@@ -0,0 +1,2 @@
+#define ILOG2_C
+#include "ilog2.h"
diff --git a/vere/ext/nasm/nasmlib/md5c.c b/vere/ext/nasm/nasmlib/md5c.c
new file mode 100644
index 0000000..79cf4e0
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/md5c.c
@@ -0,0 +1,246 @@
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+#include "md5.h"
+
+#ifdef WORDS_LITTLEENDIAN
+#define byteReverse(buf, len)	/* Nothing */
+#else
+static void byteReverse(unsigned char *buf, unsigned longs);
+
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+static void byteReverse(unsigned char *buf, unsigned longs)
+{
+    uint32_t t;
+    do {
+	t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+	    ((unsigned) buf[1] << 8 | buf[0]);
+	*(uint32_t *) buf = t;
+	buf += 4;
+    } while (--longs);
+}
+#endif
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void MD5Init(MD5_CTX *ctx)
+{
+    ctx->buf[0] = 0x67452301;
+    ctx->buf[1] = 0xefcdab89;
+    ctx->buf[2] = 0x98badcfe;
+    ctx->buf[3] = 0x10325476;
+
+    ctx->bits[0] = 0;
+    ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len)
+{
+    uint32_t t;
+
+    /* Update bitcount */
+
+    t = ctx->bits[0];
+    if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
+	ctx->bits[1]++;		/* Carry from low to high */
+    ctx->bits[1] += len >> 29;
+
+    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
+
+    /* Handle any leading odd-sized chunks */
+
+    if (t) {
+	unsigned char *p = (unsigned char *) ctx->in + t;
+
+	t = 64 - t;
+	if (len < t) {
+	    memcpy(p, buf, len);
+	    return;
+	}
+	memcpy(p, buf, t);
+	byteReverse(ctx->in, 16);
+	MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+	buf += t;
+	len -= t;
+    }
+    /* Process data in 64-byte chunks */
+
+    while (len >= 64) {
+	memcpy(ctx->in, buf, 64);
+	byteReverse(ctx->in, 16);
+	MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+	buf += 64;
+	len -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+
+    memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void MD5Final(unsigned char digest[16], MD5_CTX *ctx)
+{
+    unsigned count;
+    unsigned char *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (ctx->bits[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = ctx->in + count;
+    *p++ = 0x80;
+
+    /* Bytes of padding needed to make 64 bytes */
+    count = 64 - 1 - count;
+
+    /* Pad out to 56 mod 64 */
+    if (count < 8) {
+	/* Two lots of padding:  Pad the first block to 64 bytes */
+	memset(p, 0, count);
+	byteReverse(ctx->in, 16);
+	MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+
+	/* Now fill the next block with 56 bytes */
+	memset(ctx->in, 0, 56);
+    } else {
+	/* Pad block to 56 bytes */
+	memset(p, 0, count - 8);
+    }
+    byteReverse(ctx->in, 14);
+
+    /* Append length in bits and transform */
+    ((uint32_t *) ctx->in)[14] = ctx->bits[0];
+    ((uint32_t *) ctx->in)[15] = ctx->bits[1];
+
+    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+    byteReverse((unsigned char *) ctx->buf, 4);
+    memcpy(digest, ctx->buf, 16);
+    memset((char *) ctx, 0, sizeof(*ctx));	/* In case it's sensitive */
+}
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void MD5Transform(uint32_t buf[4], uint32_t const in[16])
+{
+    register uint32_t a, b, c, d;
+
+    a = buf[0];
+    b = buf[1];
+    c = buf[2];
+    d = buf[3];
+
+    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+    buf[0] += a;
+    buf[1] += b;
+    buf[2] += c;
+    buf[3] += d;
+}
diff --git a/vere/ext/nasm/nasmlib/mmap.c b/vere/ext/nasm/nasmlib/mmap.c
new file mode 100644
index 0000000..5fc5646
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/mmap.c
@@ -0,0 +1,139 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "file.h"
+
+/* ----------------------------------------------------------------------- *
+ *   Unix-style memory mapping, using mmap().
+ * ----------------------------------------------------------------------- */
+#if defined(HAVE_FILENO) && defined(HAVE_MMAP)
+
+/*
+ * System page size
+ */
+
+/* File scope since not all compilers like static data in inline functions */
+static size_t nasm_pagemask;
+
+static size_t get_pagemask(void)
+{
+    size_t ps = 0;
+
+# if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
+    ps = sysconf(_SC_PAGESIZE);
+# elif defined(HAVE_GETPAGESIZE)
+    ps = getpagesize();
+# elif defined(PAGE_SIZE)
+    ps = PAGE_SIZE;
+# endif
+
+    nasm_pagemask = ps = is_power2(ps) ? (ps - 1) : 0;
+    return ps;
+}
+
+static inline size_t pagemask(void)
+{
+    size_t pm = nasm_pagemask;
+
+    if (unlikely(!pm))
+        return get_pagemask();
+
+    return pm;
+}
+
+/*
+ * Try to map an input file into memory
+ */
+const void *nasm_map_file(FILE *fp, off_t start, off_t len)
+{
+    const char *p;
+    off_t  astart;              /* Aligned start */
+    size_t salign;              /* Amount of start adjustment */
+    size_t alen;                /* Aligned length */
+    const size_t page_mask = pagemask();
+
+    if (unlikely(!page_mask))
+        return NULL;            /* Page size undefined? */
+
+    if (unlikely(!len))
+        return NULL;            /* Mapping nothing... */
+
+    if (unlikely(len != (off_t)(size_t)len))
+        return NULL;            /* Address space insufficient */
+
+    astart = start & ~(off_t)page_mask;
+    salign = start - astart;
+    alen = (len + salign + page_mask) & ~page_mask;
+
+    p = mmap(NULL, alen, PROT_READ, MAP_SHARED, fileno(fp), astart);
+    return unlikely(p == MAP_FAILED) ? NULL : p + salign;
+}
+
+/*
+ * Unmap an input file
+ */
+void nasm_unmap_file(const void *p, size_t len)
+{
+    const size_t page_mask = pagemask();
+    uintptr_t astart;
+    size_t salign;
+    size_t alen;
+
+    if (unlikely(!page_mask))
+        return;
+
+    astart = (uintptr_t)p & ~(uintptr_t)page_mask;
+    salign = (uintptr_t)p - astart;
+    alen = (len + salign + page_mask) & ~page_mask;
+
+    munmap((void *)astart, alen);
+}
+
+/* ----------------------------------------------------------------------- *
+ *   No memory map support at all
+ *   XXX: Add a section with Windows support
+ * ----------------------------------------------------------------------- */
+#else
+
+const void *nasm_map_file(FILE *fp, off_t start, off_t len)
+{
+    (void)fp; (void)start; (void)len;
+    return NULL;
+}
+
+void nasm_unmap_file(const void *p, size_t len)
+{
+    (void)p; (void)len;
+}
+
+#endif
diff --git a/vere/ext/nasm/nasmlib/nctype.c b/vere/ext/nasm/nasmlib/nctype.c
new file mode 100644
index 0000000..f30f37e
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/nctype.c
@@ -0,0 +1,116 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "nctype.h"
+#include <ctype.h>
+
+/*
+ * Table of tolower() results.  This avoids function calls
+ * on some platforms.
+ */
+unsigned char nasm_tolower_tab[256];
+
+static void tolower_tab_init(void)
+{
+    int i;
+
+    for (i = 0; i < 256; i++)
+	nasm_tolower_tab[i] = tolower(i);
+}
+
+/*
+ * Table of character type flags; some are simply <ctype.h>,
+ * some are NASM-specific.
+ */
+
+uint16_t nasm_ctype_tab[256];
+
+#if !defined(HAVE_ISCNTRL) && !defined(iscntrl)
+# define iscntrl(x) ((x) < 32)
+#endif
+#if !defined(HAVE_ISASCII) && !defined(isascii)
+# define isascii(x) ((x) < 128)
+#endif
+
+static void ctype_tab_init(void)
+{
+    int i;
+
+    for (i = 0; i < 256; i++) {
+        enum nasm_ctype ct = 0;
+
+        if (iscntrl(i))
+            ct |= NCT_CTRL;
+
+        if (isascii(i))
+            ct |= NCT_ASCII;
+
+        if (isspace(i) && i != '\n')
+            ct |= NCT_SPACE;
+
+        if (isalpha(i)) {
+            ct |= (nasm_tolower(i) == i) ? NCT_LOWER : NCT_UPPER;
+            ct |= NCT_ID|NCT_IDSTART;
+        }
+
+        if (isdigit(i))
+            ct |= NCT_DIGIT|NCT_ID;
+
+        if (isxdigit(i))
+            ct |= NCT_HEX;
+
+        /* Non-ASCII character, but no ctype returned (e.g. Unicode) */
+        if (!ct && !ispunct(i))
+            ct |= NCT_ID|NCT_IDSTART;
+
+        nasm_ctype_tab[i] = ct;
+    }
+
+    nasm_ctype_tab['-']  |= NCT_MINUS;
+    nasm_ctype_tab['$']  |= NCT_DOLLAR|NCT_ID;
+    nasm_ctype_tab['_']  |= NCT_UNDER|NCT_ID|NCT_IDSTART;
+    nasm_ctype_tab['.']  |= NCT_ID|NCT_IDSTART;
+    nasm_ctype_tab['@']  |= NCT_ID|NCT_IDSTART;
+    nasm_ctype_tab['?']  |= NCT_ID|NCT_IDSTART;
+    nasm_ctype_tab['#']  |= NCT_ID;
+    nasm_ctype_tab['~']  |= NCT_ID;
+    nasm_ctype_tab['\''] |= NCT_QUOTE;
+    nasm_ctype_tab['\"'] |= NCT_QUOTE;
+    nasm_ctype_tab['`']  |= NCT_QUOTE;
+}
+
+void nasm_ctype_init(void)
+{
+    tolower_tab_init();
+    ctype_tab_init();
+}
diff --git a/vere/ext/nasm/nasmlib/path.c b/vere/ext/nasm/nasmlib/path.c
new file mode 100644
index 0000000..d228ed1
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/path.c
@@ -0,0 +1,186 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * path.c - host operating system specific pathname manipulation functions
+ *
+ * This file is inherently nonportable ... please help adjusting it to
+ * any new platforms that may be necessary.
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+
+#if defined(__MSDOS__) || defined(__DOS__) || \
+    defined(__WINDOWS__) || defined(_Windows) ||                        \
+    defined(__OS2__) || defined(_WIN16) || defined(WIN32) || defined(_WIN32)
+/* MS-DOS/Windows and like operating systems */
+# define separators "/\\:"
+# define cleandirend "/\\"
+# define catsep '\\'
+# define leaveonclean 2         /* Leave \\ at the start alone */
+# define curdir "."
+#elif defined(unix) || defined(__unix) || defined(__unix__) ||   \
+    defined(__UNIX__) || defined(__Unix__) || \
+    defined(__MACH__) || defined(__BEOS__)
+/* Unix and Unix-like operating systems and others using
+ * the equivalent syntax (slashes as only separators, no concept of volume)
+ *
+ * This must come after the __MSDOS__ section, since it seems that at
+ * least DJGPP defines __unix__ despite not being a Unix environment at all.
+ */
+# define separators "/"
+# define cleandirend "/"
+# define catsep '/'
+# define leaveonclean 1
+# define curdir "."
+#elif defined(Macintosh) || defined(macintosh)
+/* MacOS classic */
+# define separators ":"
+# define curdir ":"
+# define catsep ':'
+# define cleandirend ":"
+# define leaveonclean 0
+# define leave_leading 1
+#elif defined(__VMS)
+/* VMS *
+ *
+ * VMS filenames may have ;version at the end.  Assume we should count that
+ * as part of the filename anyway.
+ */
+# define separators ":]"
+# define curdir "[]"
+#else
+/* No idea what to do here, do nothing.  Feel free to add new ones. */
+# define curdir ""
+#endif
+
+/*
+ * This is an inline, because most compilers can greatly simplify this
+ * for a fixed string, like we have here.
+ */
+static inline bool ismatch(const char *charset, char ch)
+{
+    const char *p;
+
+    for (p = charset; *p; p++) {
+        if (ch == *p)
+            return true;
+    }
+
+    return false;
+}
+
+static const char *first_filename_char(const char *path)
+{
+#ifdef separators
+    const char *p = path + strlen(path);
+
+    while (p > path) {
+        if (ismatch(separators, p[-1]))
+            return p;
+        p--;
+    }
+
+    return p;
+#else
+    return path;
+#endif
+}
+
+/* Return the filename portion of a PATH as a new string */
+char *nasm_basename(const char *path)
+{
+    return nasm_strdup(first_filename_char(path));
+}
+
+/* Return the directory name portion of a PATH as a new string */
+char *nasm_dirname(const char *path)
+{
+    const char *p = first_filename_char(path);
+    const char *p0 = p;
+    (void)p0;                   /* Don't warn if unused */
+
+    if (p == path)
+        return nasm_strdup(curdir);
+
+#ifdef cleandirend
+    while (p > path+leaveonclean) {
+        if (ismatch(cleandirend, p[-1]))
+            break;
+        p--;
+    }
+#endif
+
+#ifdef leave_leading
+    /* If the directory contained ONLY separators, leave as-is */
+    if (p == path+leaveonclean)
+        p = p0;
+#endif
+
+    return nasm_strndup(path, p-path);
+}
+
+/*
+ * Concatenate a directory path and a filename.  Note that this function
+ * currently does NOT handle the case where file itself contains
+ * directory components (except on Unix platforms, because it is trivial.)
+ */
+char *nasm_catfile(const char *dir, const char *file)
+{
+#ifndef catsep
+    return nasm_strcat(dir, file);
+#else
+    size_t dl = strlen(dir);
+    size_t fl = strlen(file);
+    char *p, *pp;
+    bool dosep = true;
+
+    if (!dl || ismatch(separators, dir[dl-1])) {
+        /* No separator necessary */
+        dosep = false;
+    }
+
+    p = pp = nasm_malloc(dl + fl + dosep + 1);
+
+    memcpy(pp, dir, dl);
+    pp += dl;
+    if (dosep)
+        *pp++ = catsep;
+
+    memcpy(pp, file, fl+1);
+
+    return p;
+#endif
+}
diff --git a/vere/ext/nasm/nasmlib/perfhash.c b/vere/ext/nasm/nasmlib/perfhash.c
new file mode 100644
index 0000000..acd3d28
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/perfhash.c
@@ -0,0 +1,55 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "perfhash.h"
+#include "hashtbl.h"            /* For crc64i() */
+
+int perfhash_find(const struct perfect_hash *hash, const char *str)
+{
+    uint32_t k1, k2;
+    uint64_t crc;
+    uint16_t ix;
+
+    crc = crc64i(hash->crcinit, str);
+    k1 = (uint32_t)crc & hash->hashmask;
+    k2 = ((uint32_t)(crc >> 32) & hash->hashmask) + 1;
+
+    ix = hash->hashvals[k1] + hash->hashvals[k2];
+
+    if (ix >= hash->tbllen ||
+        !hash->strings[ix] ||
+        nasm_stricmp(str, hash->strings[ix]))
+        return hash->errval;
+
+    return hash->tbloffs + ix;
+}
diff --git a/vere/ext/nasm/nasmlib/perfhash.pl b/vere/ext/nasm/nasmlib/perfhash.pl
new file mode 100755
index 0000000..0c885e8
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/perfhash.pl
@@ -0,0 +1,357 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# Generate a perfect hash for general case-insensitive string-to-enum
+# lookup.  This generates an enum and the corresponding hash, but
+# relies on a common function to parse the hash.
+#
+# Usage:
+#      perfhash.pl h foohash.dat foohash.h (to generate C header)
+#      perfhash.pl c foohash.dat foohash.c (to generate C source)
+#
+
+use strict;
+
+require 'phash.ph';
+
+sub basename($) {
+    my($s) = @_;
+    $s =~ s/^.*[^-[:alnum:]_\.]//;	# Remove path component as best we can
+    return $s;
+}
+
+sub intval($) {
+    my($s) = @_;
+
+    if ($s =~ /^0/) {
+	return oct($s);		# Handles octal or hexadecimal
+    } elsif ($s =~ /^\-(0.*)$/) {
+	return -oct($1);
+    } else {
+	return $s + 0;		# Forcibly convert to number
+    }
+}
+
+my($output, $infile, $outfile) = @ARGV;
+my $me = basename($0);
+
+# The following special things are allowed in the input file:
+# #<space> or ; begins a comment
+# #include filename
+# #name str
+#    The name of the hash
+# #prefix str
+#    Defines the prefix before enum
+# #guard str
+#    Defines the header guard string
+# #special str [= value]
+#    Generate an enum value without a corresponding string; not capitalized.
+# #header str
+#    Indicates the name of the .h file to include from the .c file
+# #errval str
+#    Define the value to be returned if a string is not found
+#    (defaults to -1).  This can be any constant C expression,
+#    including one of the enum values.
+#
+# Regular lines are just str [= value]
+#
+# Enumeration is generated in the order listed in the file, just as in C
+# specifying a value causes the values to increase by 1 from that point on
+# unless specified.
+
+my $name;
+my $prefix;
+my $guard;
+my $hfile;
+
+my %strings = ();
+my %specials = ();
+my $next_value = 0;
+my $errval = '-1';
+
+my @incstack =  ();
+my @filenames = ($infile);
+my @linenums =  (0);
+my $dd = undef;
+my $err = 0;
+
+while (scalar(@filenames)) {
+    if (!defined($dd)) {
+	open($dd, '<', $filenames[-1])
+	    or die "$0: cannot open: $filenames[-1]: $!\n";
+    }
+
+    my $line = <$dd>;
+    if (!defined($line)) {
+	close($dd);
+	$dd = pop @incstack;
+	pop @filenames;
+	pop @linenums;
+	next;
+    }
+
+    $linenums[-1]++;
+
+    chomp $line;
+    $line =~ s/\s*(|\;.*|\#\s.*|\#)$//; # Remove comments and trailing space
+    $line =~ s/^\s+//;			# Remove leading space
+    if ($line eq '') {
+	# Do nothing
+    } elsif ($line =~ /^\#name\s+([[:alnum:]_]+)$/) {
+	$name = $1;
+    } elsif ($line =~ /^\#prefix\s+([[:alnum:]_]+)$/) {
+	$prefix = $1;
+    } elsif ($line =~ /^\#guard\s+([[:alnum:]_]+)$/) {
+	$guard = $1;
+    } elsif ($line =~ /^\#errval\s+(\S.*)$/) {
+	$errval = $1;
+    } elsif ($line =~ /^\#header\s+(\"(.+)\"|\S+)$/) {
+	$hfile = ($2 ne '') ? $2 : $1;
+    } elsif ($line =~ /^\#include\s+(\"(.+)\"|\S+)$/) {
+	push @incstack, $dd;
+	push @filenames, (($2 ne '') ? $2 : $1);
+	push @linenums, 0;
+	undef $dd;		# Open a new file
+    } elsif ($line =~ /^(|\#special\s+)(\S+)\s*(|=\s*(\-?(0[Xx][[:xdigit:]]+|0[0-7]*|[0-9]+)))$/) {
+	$next_value = intval($4) if ($4 ne '');
+	if ($1 eq '') {
+	    $strings{$2} = $next_value++;
+	} else {
+	    $specials{$2} = $next_value++;
+	}
+    } else {
+	printf STDERR "%s:%d:%s syntax error: \"%s\"\n",
+	    $filenames[-1], $linenums[-1],
+	    (scalar(@incstack) == 1) ? '' : "(from $infile)", $line;
+	$err++;
+    }
+}
+
+exit 1 if ($err);
+
+# Default name, prefix, and header guard name
+if (!defined($name)) {
+    $name = basename($infile);
+    $name =~ s/(\..*)$//;		# Strip extension, if any
+}
+if (!defined($prefix)) {
+    $prefix = "\U${name}\E_";
+}
+if (!defined($hfile)) {
+    $hfile = $outfile;
+    $hfile =~ s/\.c$/\.h/;
+}
+if (!defined($guard)) {
+    $guard = basename($hfile);
+    $guard =~ s/[^[:alnum:]_]/_/g;
+    $guard =~ s/__+/_/g;
+    $guard =  "\U$guard";
+}
+
+# Verify input.  We can't have more than one constant with the same
+# enumeration value, nor the same enumeration string.
+if (scalar(keys(%strings)) == 0) {
+    die "$0: $infile: no strings to hash!\n";
+}
+
+my %enums;
+my %enumvals;
+my %stringbyval;
+my $max_enum;
+my $tbllen = 0;
+my $tbloffs;
+foreach my $s (keys(%strings)) {
+    my $es = "${prefix}\U${s}";
+    $es =~ s/[^[:alnum:]_]/_/g;
+    $es =~ s/__+/_/g;
+    my $v = $strings{$s};
+    $stringbyval{$v} = $s;
+    if (defined($enums{$es})) {
+	printf STDERR "%s: string \"%s\" duplicates existing enum %s\n",
+	    $infile, $s, $es;
+	$err++;
+    } else {
+	$enums{$es} = $v;
+    }
+    if (defined($enumvals{$v})) {
+	printf STDERR "%s: string \"%s\" duplicates existing enum constant %d\n", $v;
+	$err++;
+    } else {
+	$enumvals{$v} = $es;
+    }
+    $max_enum = $v if (!defined($max_enum) || $v > $max_enum);
+    $tbloffs = $v if (!defined($tbloffs) || $v < $tbloffs);
+    $tbllen = $v+1 if (!defined($tbllen) || $v >= $tbllen);
+}
+foreach my $s (keys(%specials)) {
+    my $es = $prefix . $s;	# No string mangling here
+    my $v = $specials{$s};
+    if (defined($enums{$es})) {
+	printf STDERR "%s: special \"%s\" duplicates existing enum %s\n",
+	    $infile, $s, $es;
+	$err++;
+    } else {
+	$enums{$es} = $v;
+    }
+    if (defined ($enumvals{$v})) {
+	printf STDERR "%s: special \"%s\" duplicates existing enum constant %d\n", $v;
+	$err++;
+    } else {
+	$enumvals{$v} = $es;
+    }
+    $max_enum = $v if ($v > $max_enum || !defined($max_enum));
+}
+
+$tbllen -= $tbloffs;
+if ($tbllen > 65536) {
+    printf STDERR "%s: span of enumeration values too large\n";
+    $err++;
+}
+
+exit 1 if ($err);
+
+open(F, '>', $outfile)
+    or die "$0: cannot create: ${outfile}: $!\n";
+
+if ($output eq 'h') {
+    print F "/*\n";
+    print F " * This file is generated from $infile\n";
+    print F " * by $me; do not edit.\n";
+    print F " */\n";
+    print F "\n";
+
+    print F "#ifndef $guard\n";
+    print F "#define $guard 1\n\n";
+    print F "#include \"perfhash.h\"\n\n";
+
+    my $c = '{';
+    $next_value = 0;
+    print F "enum ${name} ";
+    foreach my $v (sort { $a <=> $b } keys(%enumvals)) {
+	my $s = $enumvals{$v};
+	print F "$c\n    $s";
+	print F " = $v" if ($v != $next_value);
+	$next_value = $v + 1;
+	$c = ',';
+    }
+    print F "\n};\n\n";
+    print F "extern const struct perfect_hash ${name}_hash;\n";
+    printf F "extern const char * const %s_tbl[%d];\n", $name, $tbllen;
+
+    print F "\nstatic inline enum ${name} ${name}_find(const char *str)\n";
+    print F "{\n";
+    print F "    return perfhash_find(&${name}_hash, str);\n";
+    print F "}\n";
+
+    print F "\nstatic inline const char * ${name}_name(enum ${name} x)\n";
+    print F "{\n";
+    printf F  "    size_t ix = (size_t)x - (%d);\n", $tbloffs;
+    printf F "    if (ix >= %d)\n", $tbllen;
+    print F  "        return NULL;\n";
+    print F  "    return ${name}_tbl[ix];\n";
+    print F  "}\n";
+
+    print F "\nstatic inline const char * ${name}_dname(enum ${name} x)\n";
+    print F "{\n";
+    print F "    const char *y = ${name}_name(x);\n";
+    print F "    return y ? y : invalid_enum_str(x);\n";
+    print F "}\n";
+
+    print F "\n#endif /* $guard */\n";
+} elsif ($output eq 'c') {
+    # The strings we hash must all be lower case, even if the string
+    # table doesn't contain them that way.
+
+    my %lcstrings;
+    foreach my $s (keys(%strings)) {
+	my $ls = "\L$s";
+	if (defined($lcstrings{$ls})) {
+	    printf STDERR "%s: strings \"%s\" and \"%s\" differ only in case\n",
+		$infile, $s, $strings{$lcstrings{$s}};
+	} else {
+	    $lcstrings{$ls} = $strings{$s} - $tbloffs;
+	}
+    }
+
+    my @hashinfo = gen_perfect_hash(\%lcstrings);
+    if (!@hashinfo) {
+	die "$0: no hash found\n";
+    }
+
+    # Paranoia...
+    verify_hash_table(\%lcstrings, \@hashinfo);
+
+    my ($n, $sv, $g) = @hashinfo;
+
+    die if ($n & ($n-1));
+
+    print F "/*\n";
+    print F " * This file is generated from $infile\n";
+    print F " * by $me; do not edit.\n";
+    print F " */\n";
+    print F "\n";
+
+    print F "#include \"$hfile\"\n\n";
+
+    printf F "const char * const %s_tbl[%d] = ", $name, $tbllen;
+    my $c = '{';
+    for (my $i = $tbloffs; $i < $tbloffs+$tbllen; $i++) {
+	printf F "%s\n    %s", $c,
+	    defined($stringbyval{$i}) ? '"'.$stringbyval{$i}.'"' : 'NULL';
+	$c = ',';
+    }
+    print F "\n};\n\n";
+
+    print F "#define INVALID_HASH_ENTRY (65536/3)\n\n";
+
+    printf F "static const int16_t %s_hashvals[%d] = ", $name, $n*2;
+    $c = '{';
+    for (my $i = 0; $i < $n*2; $i++) {
+	my $h = ${$g}[$i];
+	print F "$c\n    ", defined($h) ? $h : 'INVALID_HASH_ENTRY';
+	$c = ',';
+    }
+    print F "\n};\n\n";
+
+    print F "const struct perfect_hash ${name}_hash = {\n";
+    printf F "    UINT64_C(0x%08x%08x),\n", $$sv[0], $$sv[1]; # crcinit
+    printf F "    UINT32_C(0x%x),\n", ($n-1) << 1;	      # hashmask
+    printf F "    UINT32_C(%u),\n", $tbllen;		      # tbllen
+    printf F "    %d,\n", $tbloffs;			      # tbloffs
+    printf F "    (%s),\n", $errval;			      # errval
+    printf F "    ${name}_hashvals,\n";			      # hashvals
+    printf F "    ${name}_tbl\n";			      # strings
+    print F "};\n";
+}
diff --git a/vere/ext/nasm/nasmlib/raa.c b/vere/ext/nasm/nasmlib/raa.c
new file mode 100644
index 0000000..038f97a
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/raa.c
@@ -0,0 +1,198 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "nasmlib.h"
+#include "raa.h"
+#include "ilog2.h"
+
+/*
+ * Routines to manage a dynamic random access array of int64_ts which
+ * may grow in size to be more than the largest single malloc'able
+ * chunk.
+ */
+
+#define RAA_LAYERSHIFT	11      /* 2^this many items per layer */
+#define RAA_LAYERSIZE	((size_t)1 << RAA_LAYERSHIFT)
+#define RAA_LAYERMASK	(RAA_LAYERSIZE-1)
+
+typedef struct RAA RAA;
+typedef union RAA_UNION RAA_UNION;
+typedef struct RAA_LEAF RAA_LEAF;
+typedef struct RAA_BRANCH RAA_BRANCH;
+
+struct RAA {
+    /* Last position in this RAA */
+    raaindex endposn;
+
+    /*
+     * Number of layers below this one to get to the real data. 0
+     * means this structure is a leaf, holding RAA_LAYERSIZE real
+     * data items; 1 and above mean it's a branch, holding
+     * RAA_LAYERSIZE pointers to the next level branch or leaf
+     * structures.
+     */
+    unsigned int layers;
+
+    /*
+     * Number of real data items spanned by one position in the
+     * `data' array at this level. This number is 0 trivially, for
+     * a leaf (level 0): for a level n branch it should be
+     * n*RAA_LAYERSHIFT.
+     */
+    unsigned int shift;
+
+    /*
+     * The actual data
+     */
+    union RAA_UNION {
+        struct RAA_LEAF {
+            union intorptr data[RAA_LAYERSIZE];
+        } l;
+        struct RAA_BRANCH {
+            struct RAA *data[RAA_LAYERSIZE];
+        } b;
+    } u;
+};
+
+#define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
+#define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
+
+static struct RAA *raa_init_layer(raaindex posn, unsigned int layers)
+{
+    struct RAA *r;
+    raaindex posmask;
+
+    r = nasm_zalloc((layers == 0) ? LEAFSIZ : BRANCHSIZ);
+    r->shift = layers * RAA_LAYERSHIFT;
+    r->layers    = layers;
+    posmask = ((raaindex)RAA_LAYERSIZE << r->shift) - 1;
+    r->endposn   = posn | posmask;
+    return r;
+}
+
+void raa_free(struct RAA *r)
+{
+    if (!r)
+        return;
+
+    if (r->layers) {
+        struct RAA **p = r->u.b.data;
+        size_t i;
+        for (i = 0; i < RAA_LAYERSIZE; i++)
+            raa_free(*p++);
+    }
+    nasm_free(r);
+}
+
+static const union intorptr *real_raa_read(struct RAA *r, raaindex posn)
+{
+    nasm_assert(posn <= (~(raaindex)0 >> 1));
+
+    if (unlikely(!r || posn > r->endposn))
+        return NULL;            /* Beyond the end */
+
+    while (r->layers) {
+        size_t l = (posn >> r->shift) & RAA_LAYERMASK;
+        r = r->u.b.data[l];
+        if (!r)
+            return NULL;        /* Not present */
+    }
+    return &r->u.l.data[posn & RAA_LAYERMASK];
+}
+
+int64_t raa_read(struct RAA *r, raaindex pos)
+{
+    const union intorptr *ip;
+
+    ip = real_raa_read(r, pos);
+    return ip ? ip->i : 0;
+}
+
+void *raa_read_ptr(struct RAA *r, raaindex pos)
+{
+    const union intorptr *ip;
+
+    ip = real_raa_read(r, pos);
+    return ip ? ip->p : NULL;
+}
+
+
+static struct RAA *
+real_raa_write(struct RAA *r, raaindex posn, union intorptr value)
+{
+    struct RAA *result;
+
+    nasm_assert(posn <= (~(raaindex)0 >> 1));
+
+    if (unlikely(!r)) {
+        /* Create a new top-level RAA */
+        r = raa_init_layer(posn, ilog2_64(posn)/RAA_LAYERSHIFT);
+    } else {
+        while (unlikely(r->endposn < posn)) {
+            /* We need to add layers to an existing RAA */
+            struct RAA *s = raa_init_layer(r->endposn, r->layers + 1);
+            s->u.b.data[0] = r;
+            r = s;
+        }
+    }
+
+    result = r;
+
+    while (r->layers) {
+        struct RAA **s;
+        size_t l = (posn >> r->shift) & RAA_LAYERMASK;
+        s = &r->u.b.data[l];
+        if (unlikely(!*s))
+            *s = raa_init_layer(posn, r->layers - 1);
+        r = *s;
+    }
+    r->u.l.data[posn & RAA_LAYERMASK] = value;
+
+    return result;
+}
+
+struct RAA *raa_write(struct RAA *r, raaindex posn, int64_t value)
+{
+    union intorptr ip;
+
+    ip.i = value;
+    return real_raa_write(r, posn, ip);
+}
+
+struct RAA *raa_write_ptr(struct RAA *r, raaindex posn, void *value)
+{
+    union intorptr ip;
+
+    ip.p = value;
+    return real_raa_write(r, posn, ip);
+}
diff --git a/vere/ext/nasm/nasmlib/rbtree.c b/vere/ext/nasm/nasmlib/rbtree.c
new file mode 100644
index 0000000..773338b
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/rbtree.c
@@ -0,0 +1,259 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rbtree.c
+ *
+ * Simple implementation of a "left-leaning threaded red-black tree"
+ * with 64-bit integer keys.  The search operation will return the
+ * highest node <= the key; only search and insert are supported, but
+ * additional standard llrbtree operations can be coded up at will.
+ *
+ * See http://www.cs.princeton.edu/~rs/talks/LLRB/RedBlack.pdf for
+ * information about left-leaning red-black trees.
+ *
+ * The "threaded" part means that left and right pointers that would
+ * otherwise be NULL are pointers to the in-order predecessor or
+ * successor node. The only pointers that are NULL are the very left-
+ * and rightmost, for which no corresponding side node exists.
+ *
+ * This, among other things, allows for efficient predecessor and
+ * successor operations without requiring dedicated space for a parent
+ * pointer.
+ *
+ * This implementation is robust for identical key values; such keys
+ * will not have their insertion order preserved, and after insertion
+ * of unrelated keys a lookup may return a different node for the
+ * duplicated key, but the prev/next operations will always enumerate
+ * all entries.
+ *
+ * The NULL pointers at the end are considered predecessor/successor
+ * pointers, so if the corresponding flags are clear it is always safe
+ * to access the pointed-to object without an explicit NULL pointer
+ * check.
+ */
+
+#include "rbtree.h"
+#include "nasmlib.h"
+
+struct rbtree *rb_search(const struct rbtree *tree, uint64_t key)
+{
+    const struct rbtree *best = NULL;
+
+    if (tree) {
+        while (true) {
+            if (tree->key > key) {
+                if (tree->m.flags & RBTREE_NODE_PRED)
+                    break;
+                tree = tree->m.left;
+            } else {
+                best = tree;
+                if (tree->key == key || (tree->m.flags & RBTREE_NODE_SUCC))
+                    break;
+                tree = tree->m.right;
+            }
+	}
+    }
+    return (struct rbtree *)best;
+}
+
+struct rbtree *rb_search_exact(const struct rbtree *tree, uint64_t key)
+{
+    struct rbtree *rv;
+
+    rv = rb_search(tree, key);
+    return (rv && rv->key == key) ? rv : NULL;
+}
+
+/* Reds two left in a row? */
+static inline bool is_red_left_left(struct rbtree *h)
+{
+    return !(h->m.flags & RBTREE_NODE_PRED) &&
+        !(h->m.left->m.flags & (RBTREE_NODE_BLACK|RBTREE_NODE_PRED)) &&
+        !(h->m.left->m.left->m.flags & RBTREE_NODE_BLACK);
+}
+
+/* Node to the right is red? */
+static inline bool is_red_right(struct rbtree *h)
+{
+    return !(h->m.flags & RBTREE_NODE_SUCC) &&
+           !(h->m.right->m.flags & RBTREE_NODE_BLACK);
+}
+
+/* Both the left and right hand nodes are red? */
+static inline bool is_red_both(struct rbtree *h)
+{
+    return !(h->m.flags & (RBTREE_NODE_PRED|RBTREE_NODE_SUCC))
+        && !(h->m.left->m.flags & h->m.right->m.flags & RBTREE_NODE_BLACK);
+}
+
+static inline struct rbtree *rotate_left(struct rbtree *h)
+{
+    struct rbtree *x = h->m.right;
+    enum rbtree_node_flags hf = h->m.flags;
+    enum rbtree_node_flags xf = x->m.flags;
+
+    if (xf & RBTREE_NODE_PRED) {
+        h->m.right = x;
+        h->m.flags = (hf & RBTREE_NODE_PRED)  | RBTREE_NODE_SUCC;
+    } else {
+        h->m.right = x->m.left;
+        h->m.flags = hf & RBTREE_NODE_PRED;
+    }
+    x->m.flags = (hf & RBTREE_NODE_BLACK) | (xf & RBTREE_NODE_SUCC);
+    x->m.left = h;
+
+    return x;
+}
+
+static inline struct rbtree *rotate_right(struct rbtree *h)
+{
+    struct rbtree *x = h->m.left;
+    enum rbtree_node_flags hf = h->m.flags;
+    enum rbtree_node_flags xf = x->m.flags;
+
+    if (xf & RBTREE_NODE_SUCC) {
+        h->m.left = x;
+        h->m.flags = (hf & RBTREE_NODE_SUCC)  | RBTREE_NODE_PRED;
+    } else {
+        h->m.left = x->m.right;
+        h->m.flags = hf & RBTREE_NODE_SUCC;
+    }
+    x->m.flags = (hf & RBTREE_NODE_BLACK) | (xf & RBTREE_NODE_PRED);
+    x->m.right = h;
+
+    return x;
+}
+
+static inline void color_flip(struct rbtree *h)
+{
+    h->m.flags          ^= RBTREE_NODE_BLACK;
+    h->m.left->m.flags  ^= RBTREE_NODE_BLACK;
+    h->m.right->m.flags ^= RBTREE_NODE_BLACK;
+}
+
+static struct rbtree *
+_rb_insert(struct rbtree *tree, struct rbtree *node);
+
+struct rbtree *rb_insert(struct rbtree *tree, struct rbtree *node)
+{
+    /* Initialize node as if it was the sole member of the tree */
+
+    nasm_zero(node->m);
+    node->m.flags = RBTREE_NODE_PRED|RBTREE_NODE_SUCC;
+
+    if (unlikely(!tree))
+        return node;
+
+    return _rb_insert(tree, node);
+}
+
+static struct rbtree *
+_rb_insert(struct rbtree *tree, struct rbtree *node)
+{
+    /* Recursive part of the algorithm */
+
+    /* Red on both sides? */
+    if (is_red_both(tree))
+	color_flip(tree);
+
+    if (node->key < tree->key) {
+        node->m.right  = tree;  /* Potential successor */
+        if (tree->m.flags & RBTREE_NODE_PRED) {
+            node->m.left   = tree->m.left;
+            tree->m.flags &= ~RBTREE_NODE_PRED;
+            tree->m.left   = node;
+        } else {
+            tree->m.left   = _rb_insert(tree->m.left, node);
+        }
+    } else {
+        node->m.left   = tree;  /* Potential predecessor */
+        if (tree->m.flags & RBTREE_NODE_SUCC) {
+            node->m.right  = tree->m.right;
+            tree->m.flags &= ~RBTREE_NODE_SUCC;
+            tree->m.right  = node;
+        } else {
+            tree->m.right  = _rb_insert(tree->m.right, node);
+        }
+    }
+
+    if (is_red_right(tree))
+	tree = rotate_left(tree);
+
+    if (is_red_left_left(tree))
+	tree = rotate_right(tree);
+
+    return tree;
+}
+
+struct rbtree *rb_first(const struct rbtree *tree)
+{
+    if (unlikely(!tree))
+        return NULL;
+
+    while (!(tree->m.flags & RBTREE_NODE_PRED))
+        tree = tree->m.left;
+
+    return (struct rbtree *)tree;
+}
+
+struct rbtree *rb_last(const struct rbtree *tree)
+{
+    if (unlikely(!tree))
+        return NULL;
+
+    while (!(tree->m.flags & RBTREE_NODE_SUCC))
+        tree = tree->m.right;
+
+    return (struct rbtree *)tree;
+}
+
+struct rbtree *rb_prev(const struct rbtree *node)
+{
+    struct rbtree *np = node->m.left;
+
+    if (node->m.flags & RBTREE_NODE_PRED)
+        return np;
+    else
+        return rb_last(np);
+}
+
+struct rbtree *rb_next(const struct rbtree *node)
+{
+    struct rbtree *np = node->m.right;
+
+    if (node->m.flags & RBTREE_NODE_SUCC)
+        return np;
+    else
+        return rb_first(np);
+}
diff --git a/vere/ext/nasm/nasmlib/readnum.c b/vere/ext/nasm/nasmlib/readnum.c
new file mode 100644
index 0000000..947bda5
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/readnum.c
@@ -0,0 +1,179 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasmlib.h"
+#include "error.h"
+#include "nasm.h"               /* For globalbits */
+
+#define lib_isnumchar(c)    (nasm_isalnum(c) || (c) == '$' || (c) == '_')
+
+static int radix_letter(char c)
+{
+    switch (c) {
+    case 'b': case 'B':
+    case 'y': case 'Y':
+	return 2;		/* Binary */
+    case 'o': case 'O':
+    case 'q': case 'Q':
+	return 8;		/* Octal */
+    case 'h': case 'H':
+    case 'x': case 'X':
+	return 16;		/* Hexadecimal */
+    case 'd': case 'D':
+    case 't': case 'T':
+	return 10;		/* Decimal */
+    default:
+	return 0;		/* Not a known radix letter */
+    }
+}
+
+int64_t readnum(const char *str, bool *error)
+{
+    const char *r = str, *q;
+    int32_t pradix, sradix, radix;
+    int plen, slen, len;
+    uint64_t result, checklimit;
+    int digit, last;
+    bool warn = false;
+    int sign = 1;
+
+    if (error)
+        *error = true;
+
+    while (nasm_isspace(*r))
+        r++;                    /* find start of number */
+
+    /*
+     * If the number came from make_tok_num (as a result of an %assign), it
+     * might have a '-' built into it (rather than in a preceding token).
+     */
+    if (*r == '-') {
+        r++;
+        sign = -1;
+    }
+
+    q = r;
+
+    while (lib_isnumchar(*q))
+        q++;                    /* find end of number */
+
+    len = q-r;
+    if (!len) {
+	/* Not numeric */
+        return 0;
+    }
+
+    /*
+     * Handle radix formats:
+     *
+     * 0<radix-letter><string>
+     * $<string>		(hexadecimal)
+     * <string><radix-letter>
+     */
+    pradix = sradix = 0;
+    plen = slen = 0;
+
+    if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
+	plen = 2;
+    else if (len > 1 && *r == '$')
+	pradix = 16, plen = 1;
+
+    if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
+	slen = 1;
+
+    if (pradix > sradix) {
+	radix = pradix;
+	r += plen;
+    } else if (sradix > pradix) {
+	radix = sradix;
+	q -= slen;
+    } else {
+	/* Either decimal, or invalid -- if invalid, we'll trip up
+	   further down. */
+	radix = 10;
+    }
+
+    /*
+     * `checklimit' must be 2**64 / radix. We can't do that in
+     * 64-bit arithmetic, which we're (probably) using, so we
+     * cheat: since we know that all radices we use are even, we
+     * can divide 2**63 by radix/2 instead.
+     */
+    checklimit = UINT64_C(0x8000000000000000) / (radix >> 1);
+
+    /*
+     * Calculate the highest allowable value for the last digit of a
+     * 64-bit constant... in radix 10, it is 6, otherwise it is 0
+     */
+    last = (radix == 10 ? 6 : 0);
+
+    result = 0;
+    while (*r && r < q) {
+	if (*r != '_') {
+	    if (*r < '0' || (*r > '9' && *r < 'A')
+		|| (digit = numvalue(*r)) >= radix) {
+                return 0;
+	    }
+	    if (result > checklimit ||
+		(result == checklimit && digit >= last)) {
+		warn = true;
+	    }
+
+	    result = radix * result + digit;
+	}
+        r++;
+    }
+
+    if (warn) {
+        /*!
+         *!number-overflow [on] numeric constant does not fit
+         *!    covers warnings about numeric constants which
+         *!    don't fit in 64 bits.
+         */
+        nasm_warn(WARN_NUMBER_OVERFLOW,
+		   "numeric constant %s does not fit in 64 bits",
+		   str);
+    }
+
+    if (error)
+        *error = false;
+    return result * sign;
+}
diff --git a/vere/ext/nasm/nasmlib/realpath.c b/vere/ext/nasm/nasmlib/realpath.c
new file mode 100644
index 0000000..eaa148a
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/realpath.c
@@ -0,0 +1,133 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * realpath.c	As system-independent as possible implementation of realpath()
+ */
+
+#include "compiler.h"
+
+#include <errno.h>
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#endif
+
+#include "nasmlib.h"
+
+#ifdef HAVE_CANONICALIZE_FILE_NAME
+
+/*
+ * GNU-specific, but avoids the realpath(..., NULL)
+ * portability problem if it exists.
+ */
+char *nasm_realpath(const char *rel_path)
+{
+    char *rp = canonicalize_file_name(rel_path);
+    return rp ? rp : nasm_strdup(rel_path);
+}
+
+#elif defined(HAVE_REALPATH)
+
+/*
+ * POSIX.1-2008 defines realpath(..., NULL); POSIX.1-2001 doesn't guarantee
+ * that a NULL second argument is supported.
+ */
+
+char *nasm_realpath(const char *rel_path)
+{
+    char *rp;
+
+    rp = realpath(rel_path, NULL);
+
+    /* Not all implementations of realpath() support a NULL second argument */
+    if (!rp && errno == EINVAL) {
+        long path_max = -1;
+        char *rp;
+
+#if defined(HAVE_PATHCONF) && defined(_PC_PATH_MAX)
+        path_max = pathconf(rel_path, _PC_PATH_MAX); /* POSIX */
+#endif
+
+        if (path_max < 0) {
+#ifdef PATH_MAX
+            path_max = PATH_MAX;    /* SUSv2 */
+#elif defined(MAXPATHLEN)
+            path_max = MAXPATHLEN;  /* Solaris */
+#else
+            path_max = 65536;    /* Crazily high, we hope */
+#endif
+        }
+
+        rp = nasm_malloc(path_max);
+
+        if (!realpath(rel_path, rp)) {
+            nasm_free(rp);
+            rp = NULL;
+        } else {
+            /* On some systems, pathconf() can return a very large value */
+
+            rp[path_max - 1] = '\0'; /* Just in case overrun is possible */
+            rp = nasm_realloc(rp, strlen(rp) + 1);
+        }
+    }
+
+    return rp ? rp : nasm_strdup(rel_path);
+}
+
+#elif defined(HAVE__FULLPATH)
+
+/*
+ * win32/win64 API
+ */
+
+char *nasm_realpath(const char *rel_path)
+{
+    char *rp = _fullpath(NULL, rel_path, 0);
+    return rp ? rp : nasm_strdup(rel_path);
+}
+
+#else
+
+/*
+ * There is nothing we know how to do here, so hope it just works anyway.
+ */
+
+char *nasm_realpath(const char *rel_path)
+{
+    return nasm_strdup(rel_path);
+}
+
+#endif
diff --git a/vere/ext/nasm/nasmlib/rlimit.c b/vere/ext/nasm/nasmlib/rlimit.c
new file mode 100644
index 0000000..096879f
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/rlimit.c
@@ -0,0 +1,78 @@
+ /* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+#include "nasmlib.h"
+
+#ifdef HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#endif
+
+#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_STACK)
+
+size_t nasm_get_stack_size_limit(void)
+{
+    struct rlimit rl;
+
+    if (getrlimit(RLIMIT_STACK, &rl))
+        return SIZE_MAX;
+
+# ifdef RLIM_SAVED_MAX
+    if (rl.rlim_cur == RLIM_SAVED_MAX)
+        rl.rlim_cur = rl.rlim_max;
+# endif
+
+    if (
+# ifdef RLIM_INFINITY
+        rl.rlim_cur >= RLIM_INFINITY ||
+# endif
+# ifdef RLIM_SAVED_CUR
+        rl.rlim_cur == RLIM_SAVED_CUR ||
+# endif
+# ifdef RLIM_SAVED_MAX
+        rl.rlim_cur == RLIM_SAVED_MAX ||
+# endif
+        (size_t)rl.rlim_cur != rl.rlim_cur)
+        return SIZE_MAX;
+
+    return rl.rlim_cur;
+}
+
+#else
+
+size_t nasm_get_stack_size_limit(void)
+{
+    return SIZE_MAX;
+}
+
+#endif
diff --git a/vere/ext/nasm/nasmlib/saa.c b/vere/ext/nasm/nasmlib/saa.c
new file mode 100644
index 0000000..dcc2c01
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/saa.c
@@ -0,0 +1,383 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "saa.h"
+
+/* Aggregate SAA components smaller than this */
+#define SAA_BLKSHIFT	16
+#define SAA_BLKLEN	((size_t)1 << SAA_BLKSHIFT)
+
+struct SAA *saa_init(size_t elem_len)
+{
+    struct SAA *s;
+    char *data;
+
+    s = nasm_zalloc(sizeof(struct SAA));
+
+    if (elem_len >= SAA_BLKLEN)
+        s->blk_len = elem_len;
+    else
+        s->blk_len = SAA_BLKLEN - (SAA_BLKLEN % elem_len);
+
+    s->elem_len = elem_len;
+    s->length = s->blk_len;
+    data = nasm_malloc(s->blk_len);
+    s->nblkptrs = s->nblks = 1;
+    s->blk_ptrs = nasm_malloc(sizeof(char *));
+    s->blk_ptrs[0] = data;
+    s->wblk = s->rblk = &s->blk_ptrs[0];
+
+    return s;
+}
+
+void saa_free(struct SAA *s)
+{
+    char **p;
+    size_t n;
+
+    for (p = s->blk_ptrs, n = s->nblks; n; p++, n--)
+        nasm_free(*p);
+
+    nasm_free(s->blk_ptrs);
+    nasm_free(s);
+}
+
+/* Add one allocation block to an SAA */
+static void saa_extend(struct SAA *s)
+{
+    size_t blkn = s->nblks++;
+
+    if (blkn >= s->nblkptrs) {
+        size_t rindex = s->rblk - s->blk_ptrs;
+        size_t windex = s->wblk - s->blk_ptrs;
+
+        s->nblkptrs <<= 1;
+        s->blk_ptrs =
+            nasm_realloc(s->blk_ptrs, s->nblkptrs * sizeof(char *));
+
+        s->rblk = s->blk_ptrs + rindex;
+        s->wblk = s->blk_ptrs + windex;
+    }
+
+    s->blk_ptrs[blkn] = nasm_malloc(s->blk_len);
+    s->length += s->blk_len;
+}
+
+void *saa_wstruct(struct SAA *s)
+{
+    void *p;
+
+    nasm_assert((s->wpos % s->elem_len) == 0);
+
+    if (s->wpos + s->elem_len > s->blk_len) {
+        nasm_assert(s->wpos == s->blk_len);
+        if (s->wptr + s->elem_len > s->length)
+            saa_extend(s);
+        s->wblk++;
+        s->wpos = 0;
+    }
+
+    p = *s->wblk + s->wpos;
+    s->wpos += s->elem_len;
+    s->wptr += s->elem_len;
+
+    if (s->wptr > s->datalen)
+        s->datalen = s->wptr;
+
+    return p;
+}
+
+void saa_wbytes(struct SAA *s, const void *data, size_t len)
+{
+    const char *d = data;
+
+    while (len) {
+        size_t l = s->blk_len - s->wpos;
+        if (l > len)
+            l = len;
+        if (l) {
+            if (d) {
+                memcpy(*s->wblk + s->wpos, d, l);
+                d += l;
+            } else
+                memset(*s->wblk + s->wpos, 0, l);
+            s->wpos += l;
+            s->wptr += l;
+            len -= l;
+
+            if (s->datalen < s->wptr)
+                s->datalen = s->wptr;
+        }
+        if (len) {
+            if (s->wptr >= s->length)
+                saa_extend(s);
+            s->wblk++;
+            s->wpos = 0;
+        }
+    }
+}
+
+/*
+ * Writes a string, *including* the final null, to the specified SAA,
+ * and return the number of bytes written.
+ */
+size_t saa_wcstring(struct SAA *s, const char *str)
+{
+    size_t bytes = strlen(str) + 1;
+
+    saa_wbytes(s, str, bytes);
+
+    return bytes;
+}
+
+void saa_rewind(struct SAA *s)
+{
+    s->rblk = s->blk_ptrs;
+    s->rpos = s->rptr = 0;
+}
+
+void *saa_rstruct(struct SAA *s)
+{
+    void *p;
+
+    if (s->rptr + s->elem_len > s->datalen)
+        return NULL;
+
+    nasm_assert((s->rpos % s->elem_len) == 0);
+
+    if (s->rpos + s->elem_len > s->blk_len) {
+        s->rblk++;
+        s->rpos = 0;
+    }
+
+    p = *s->rblk + s->rpos;
+    s->rpos += s->elem_len;
+    s->rptr += s->elem_len;
+
+    return p;
+}
+
+const void *saa_rbytes(struct SAA *s, size_t * lenp)
+{
+    const void *p;
+    size_t len;
+
+    if (s->rptr >= s->datalen) {
+        *lenp = 0;
+        return NULL;
+    }
+
+    if (s->rpos >= s->blk_len) {
+        s->rblk++;
+        s->rpos = 0;
+    }
+
+    len = *lenp;
+    if (len > s->datalen - s->rptr)
+        len = s->datalen - s->rptr;
+    if (len > s->blk_len - s->rpos)
+        len = s->blk_len - s->rpos;
+
+    *lenp = len;
+    p = *s->rblk + s->rpos;
+
+    s->rpos += len;
+    s->rptr += len;
+
+    return p;
+}
+
+void saa_rnbytes(struct SAA *s, void *data, size_t len)
+{
+    char *d = data;
+
+    nasm_assert(s->rptr + len <= s->datalen);
+
+    while (len) {
+        size_t l;
+        const void *p;
+
+        l = len;
+        p = saa_rbytes(s, &l);
+
+        memcpy(d, p, l);
+        d += l;
+        len -= l;
+    }
+}
+
+/* Same as saa_rnbytes, except position the counter first */
+void saa_fread(struct SAA *s, size_t posn, void *data, size_t len)
+{
+    size_t ix;
+
+    nasm_assert(posn + len <= s->datalen);
+
+    if (likely(s->blk_len == SAA_BLKLEN)) {
+        ix = posn >> SAA_BLKSHIFT;
+        s->rpos = posn & (SAA_BLKLEN - 1);
+    } else {
+        ix = posn / s->blk_len;
+        s->rpos = posn % s->blk_len;
+    }
+    s->rptr = posn;
+    s->rblk = &s->blk_ptrs[ix];
+
+    saa_rnbytes(s, data, len);
+}
+
+/* Same as saa_wbytes, except position the counter first */
+void saa_fwrite(struct SAA *s, size_t posn, const void *data, size_t len)
+{
+    size_t ix;
+    size_t padding = 0;
+
+    if (posn > s->datalen) {
+        padding = posn - s->datalen;
+        posn = s->datalen;
+    }
+
+    if (likely(s->blk_len == SAA_BLKLEN)) {
+        ix = posn >> SAA_BLKSHIFT;
+        s->wpos = posn & (SAA_BLKLEN - 1);
+    } else {
+        ix = posn / s->blk_len;
+        s->wpos = posn % s->blk_len;
+    }
+    s->wptr = posn;
+    s->wblk = &s->blk_ptrs[ix];
+
+    if (!s->wpos) {
+        s->wpos = s->blk_len;
+        s->wblk--;
+    }
+
+    if (padding)
+        saa_wbytes(s, NULL, padding);
+
+    saa_wbytes(s, data, len);
+}
+
+void saa_fpwrite(struct SAA *s, FILE * fp)
+{
+    const char *data;
+    size_t len;
+
+    saa_rewind(s);
+    while (len = s->datalen, (data = saa_rbytes(s, &len)) != NULL)
+        nasm_write(data, len, fp);
+}
+
+void saa_write8(struct SAA *s, uint8_t v)
+{
+    saa_wbytes(s, &v, 1);
+}
+
+void saa_write16(struct SAA *s, uint16_t v)
+{
+    v = cpu_to_le16(v);
+    saa_wbytes(s, &v, 2);
+}
+
+void saa_write32(struct SAA *s, uint32_t v)
+{
+    v = cpu_to_le32(v);
+    saa_wbytes(s, &v, 4);
+}
+
+void saa_write64(struct SAA *s, uint64_t v)
+{
+    v = cpu_to_le64(v);
+    saa_wbytes(s, &v, 8);
+}
+
+void saa_writeaddr(struct SAA *s, uint64_t v, size_t len)
+{
+    v = cpu_to_le64(v);
+    saa_wbytes(s, &v, len);
+}
+
+/* write unsigned LEB128 value to SAA */
+void saa_wleb128u(struct SAA *psaa, int value)
+{
+    char temp[64], *ptemp;
+    uint8_t byte;
+    int len;
+
+    ptemp = temp;
+    len = 0;
+    do {
+        byte = value & 127;
+        value >>= 7;
+        if (value != 0)         /* more bytes to come */
+            byte |= 0x80;
+        *ptemp = byte;
+        ptemp++;
+        len++;
+    } while (value != 0);
+    saa_wbytes(psaa, temp, len);
+}
+
+/* write signed LEB128 value to SAA */
+void saa_wleb128s(struct SAA *psaa, int value)
+{
+    char temp[64], *ptemp;
+    uint8_t byte;
+    bool more, negative;
+    int size, len;
+
+    ptemp = temp;
+    more = 1;
+    negative = (value < 0);
+    size = sizeof(int) * 8;
+    len = 0;
+    while (more) {
+        byte = value & 0x7f;
+        value >>= 7;
+        if (negative)
+            /* sign extend */
+            value |= -(1 << (size - 7));
+        /* sign bit of byte is second high order bit (0x40) */
+        if ((value == 0 && !(byte & 0x40)) ||
+            ((value == -1) && (byte & 0x40)))
+            more = 0;
+        else
+            byte |= 0x80;
+        *ptemp = byte;
+        ptemp++;
+        len++;
+    }
+    saa_wbytes(psaa, temp, len);
+}
diff --git a/vere/ext/nasm/nasmlib/string.c b/vere/ext/nasm/nasmlib/string.c
new file mode 100644
index 0000000..4ee3ecb
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/string.c
@@ -0,0 +1,224 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "nctype.h"
+
+#ifndef nasm_stricmp
+int nasm_stricmp(const char *s1, const char *s2)
+{
+    unsigned char c1, c2;
+    int d;
+
+    while (1) {
+	c1 = nasm_tolower(*s1++);
+	c2 = nasm_tolower(*s2++);
+	d = c1-c2;
+
+	if (d)
+	    return d;
+	if (!c1)
+	    break;
+    }
+    return 0;
+}
+#endif
+
+#ifndef nasm_strnicmp
+int nasm_strnicmp(const char *s1, const char *s2, size_t n)
+{
+    unsigned char c1, c2;
+    int d;
+
+    while (n--) {
+	c1 = nasm_tolower(*s1++);
+	c2 = nasm_tolower(*s2++);
+	d = c1-c2;
+
+	if (d)
+	    return d;
+	if (!c1)
+	    break;
+    }
+    return 0;
+}
+#endif
+
+int nasm_memicmp(const char *s1, const char *s2, size_t n)
+{
+    unsigned char c1, c2;
+    int d;
+
+    while (n--) {
+	c1 = nasm_tolower(*s1++);
+	c2 = nasm_tolower(*s2++);
+	d = c1-c2;
+	if (d)
+	    return d;
+    }
+    return 0;
+}
+
+#ifndef nasm_strsep
+char *nasm_strsep(char **stringp, const char *delim)
+{
+        char *s = *stringp;
+        char *e;
+
+        if (!s)
+                return NULL;
+
+        e = strpbrk(s, delim);
+        if (e)
+                *e++ = '\0';
+
+        *stringp = e;
+        return s;
+}
+#endif
+
+/* skip leading spaces */
+char *nasm_skip_spaces(const char *p)
+{
+    if (p)
+        while (*p && nasm_isspace(*p))
+            p++;
+    return (char *)p;
+}
+
+/* skip leading non-spaces */
+char *nasm_skip_word(const char *p)
+{
+    if (p)
+        while (*p && !nasm_isspace(*p))
+            p++;
+    return (char *)p;
+}
+
+/* zap leading spaces with zero */
+char *nasm_zap_spaces_fwd(char *p)
+{
+    if (p)
+        while (*p && nasm_isspace(*p))
+            *p++ = 0x0;
+    return p;
+}
+
+/* zap spaces with zero in reverse order */
+char *nasm_zap_spaces_rev(char *p)
+{
+    if (p)
+        while (*p && nasm_isspace(*p))
+            *p-- = 0x0;
+    return p;
+}
+
+/* zap leading and trailing spaces */
+char *nasm_trim_spaces(char *p)
+{
+    p = nasm_zap_spaces_fwd(p);
+    nasm_zap_spaces_fwd(nasm_skip_word(p));
+
+    return p;
+}
+
+/*
+ * return the word extracted from a stream
+ * or NULL if nothing left
+ */
+char *nasm_get_word(char *p, char **tail)
+{
+    char *word = nasm_skip_spaces(p);
+    char *next = nasm_skip_word(word);
+
+    if (word && *word) {
+        if (*next)
+            *next++ = '\0';
+    } else
+        word = next = NULL;
+
+    /* NOTE: the tail may start with spaces */
+    *tail = next;
+
+    return word;
+}
+
+/*
+ * Extract "opt=val" values from the stream and
+ * returns "opt"
+ *
+ * Exceptions:
+ * 1) If "=val" passed the NULL returned though
+ *    you may continue handling the tail via "next"
+ * 2) If "=" passed the NULL is returned and "val"
+ *    is set to NULL as well
+ */
+char *nasm_opt_val(char *p, char **val, char **next)
+{
+    char *q, *nxt;
+
+    *val = *next = NULL;
+
+    p = nasm_get_word(p, &nxt);
+    if (!p)
+        return NULL;
+
+    q = strchr(p, '=');
+    if (q) {
+        if (q == p)
+            p = NULL;
+        *q++='\0';
+        if (*q) {
+            *val = q;
+        } else {
+            q = nasm_get_word(q + 1, &nxt);
+            if (q)
+                *val = q;
+        }
+    } else {
+        q = nasm_skip_spaces(nxt);
+        if (q && *q == '=') {
+            q = nasm_get_word(q + 1, &nxt);
+            if (q)
+                *val = q;
+        }
+    }
+
+    *next = nxt;
+    return p;
+}
diff --git a/vere/ext/nasm/nasmlib/strlist.c b/vere/ext/nasm/nasmlib/strlist.c
new file mode 100644
index 0000000..449304b
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/strlist.c
@@ -0,0 +1,207 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * strlist.c - list of ordered strings, optionally made unique
+ */
+
+#include "strlist.h"
+
+/*
+ * Create a string list. The list can be uniqizing or not.
+ */
+struct strlist *strlist_alloc(bool uniq)
+{
+	struct strlist *list = nasm_zalloc(sizeof(*list));
+	list->tailp = &list->head;
+        list->uniq = uniq;
+	return list;
+}
+
+/*
+ * Append a string to a string list. Return the entry pointer, which
+ * may be a pre-existing entry for a uniqizing list.
+ */
+
+static const struct strlist_entry *
+strlist_add_common(struct strlist *list, struct strlist_entry *e,
+		   struct hash_insert *hi)
+{
+        e->offset = list->size;
+        e->next = NULL;
+
+	*list->tailp = e;
+	list->tailp = &e->next;
+	list->nstr++;
+	list->size += e->size;
+
+        if (list->uniq)
+		hash_add(hi, e->str, (void *)e);
+
+	return e;
+}
+
+const struct strlist_entry *
+strlist_add(struct strlist *list, const char *str)
+{
+	struct strlist_entry *e;
+	struct hash_insert hi;
+	size_t size;
+
+	if (!list)
+		return NULL;
+
+	size = strlen(str) + 1;
+	if (list->uniq) {
+		void **dp = hash_findb(&list->hash, str, size, &hi);
+		if (dp)
+			return *dp;
+	}
+
+	/* Structure already has char[1] as EOS */
+	e = nasm_malloc(sizeof(*e) - 1 + size);
+	e->size = size;
+	memcpy(e->str, str, size);
+
+	return strlist_add_common(list, e, &hi);
+}
+
+/*
+ * printf() to a string list
+ */
+const struct strlist_entry *
+strlist_vprintf(struct strlist *list, const char *fmt, va_list ap)
+{
+	/* clang miscompiles offsetin() unless e is initialized here */
+	struct strlist_entry *e = NULL;
+	struct hash_insert hi;
+
+	if (!list)
+		return NULL;
+
+	e = nasm_vaxprintf(offsetin(*e, str), fmt, ap);
+	e->size = nasm_last_string_size();
+
+	if (list->uniq) {
+		void **dp = hash_findb(&list->hash, e->str, e->size, &hi);
+		if (dp) {
+			nasm_free(e);
+			return *dp;
+		}
+	}
+
+	return strlist_add_common(list, e, &hi);
+}
+
+const struct strlist_entry *
+strlist_printf(struct strlist *list, const char *fmt, ...)
+{
+	va_list ap;
+	const struct strlist_entry *e;
+
+	va_start(ap, fmt);
+	e = strlist_vprintf(list, fmt, ap);
+	va_end(ap);
+
+	return e;
+}
+
+/*
+ * Free a string list. Sets the pointed to pointer to NULL.
+ */
+void strlist_free(struct strlist **listp)
+{
+	struct strlist *list = *listp;
+	struct strlist_entry *e, *tmp;
+
+	if (!list)
+		return;
+
+	if (list->uniq)
+		hash_free(&list->hash);
+
+	list_for_each_safe(e, tmp, list->head)
+		nasm_free(e);
+
+	nasm_free(list);
+	*listp = NULL;
+}
+
+/*
+ * Search the string list for an entry. If found, return the entry pointer.
+ * Only possible on a uniqizing list.
+ */
+const struct strlist_entry *
+strlist_find(const struct strlist *list, const char *str)
+{
+	void **hf;
+
+        nasm_assert(list->uniq);
+
+	hf = hash_find((struct hash_table *)&list->hash, str, NULL);
+	return hf ? *hf : NULL;
+}
+
+/*
+ * Produce a linearized buffer containing the whole list, in order;
+ * The character "sep" is the separator between strings; this is
+ * typically either 0 or '\n'. strlist_size() will give the size of
+ * the returned buffer.
+ */
+void *strlist_linearize(const struct strlist *list, char sep)
+{
+	const struct strlist_entry *sl;
+	char *buf = nasm_malloc(list->size);
+	char *p = buf;
+
+	strlist_for_each(sl, list) {
+		p = mempcpy(p, sl->str, sl->size);
+		p[-1] = sep;
+	}
+
+	return buf;
+}
+
+/*
+ * Output a string list to a file. The separator can be any string.
+ */
+void strlist_write(const struct strlist *list, const char *sep, FILE *f)
+{
+	const struct strlist_entry *sl;
+	size_t seplen = strlen(sep);
+
+	strlist_for_each(sl, list) {
+		fwrite(sl->str, 1, sl->size - 1, f);
+		fwrite(sep, 1, seplen, f);
+	}
+}
diff --git a/vere/ext/nasm/nasmlib/ver.c b/vere/ext/nasm/nasmlib/ver.c
new file mode 100644
index 0000000..667dc88
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/ver.c
@@ -0,0 +1,80 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "ver.h"
+#include "version.h"
+
+/* This is printed when entering nasm -v */
+const char nasm_version[] = NASM_VER;
+const char nasm_date[] = "";
+const char nasm_compile_options[] = ""
+#ifdef DEBUG
+    " with -DDEBUG"
+#endif
+    ;
+
+bool reproducible;              /* Reproducible output */
+
+/* These are used by some backends. For a reproducible build,
+ * these cannot contain version numbers.
+ */
+static const char * const _nasm_comment[2] =
+{
+    "The Netwide Assembler " NASM_VER,
+    "The Netwide Assembler"
+};
+
+static const char * const _nasm_signature[2] = {
+    "NASM " NASM_VER,
+    "NASM"
+};
+
+const char *nasm_comment(void)
+{
+    return _nasm_comment[reproducible];
+}
+
+size_t nasm_comment_len(void)
+{
+    return strlen(nasm_comment());
+}
+
+const char *nasm_signature(void)
+{
+    return _nasm_signature[reproducible];
+}
+
+size_t nasm_signature_len(void)
+{
+    return strlen(nasm_signature());
+}
diff --git a/vere/ext/nasm/nasmlib/zerobuf.c b/vere/ext/nasm/nasmlib/zerobuf.c
new file mode 100644
index 0000000..651c0fd
--- /dev/null
+++ b/vere/ext/nasm/nasmlib/zerobuf.c
@@ -0,0 +1,42 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+
+/* Uninitialized -> all zero by C spec */
+const uint8_t zero_buffer[ZERO_BUF_SIZE];
diff --git a/vere/ext/nasm/output/codeview.c b/vere/ext/nasm/output/codeview.c
new file mode 100644
index 0000000..d1011fc
--- /dev/null
+++ b/vere/ext/nasm/output/codeview.c
@@ -0,0 +1,820 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * codeview.c Codeview Debug Format support for COFF
+ */
+
+#include "version.h"
+#include "compiler.h"
+
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "preproc.h"
+#include "saa.h"
+#include "hashtbl.h"
+#include "outlib.h"
+#include "pecoff.h"
+#include "md5.h"
+
+static void cv8_init(void);
+static void cv8_linenum(const char *filename, int32_t linenumber,
+        int32_t segto);
+static void cv8_deflabel(char *name, int32_t segment, int64_t offset,
+        int is_global, char *special);
+static void cv8_typevalue(int32_t type);
+static void cv8_output(int type, void *param);
+static void cv8_cleanup(void);
+
+const struct dfmt df_cv8 = {
+    "Codeview 8+",              /* .fullname */
+    "cv8",                      /* .shortname */
+    cv8_init,                   /* .init */
+    cv8_linenum,                /* .linenum */
+    cv8_deflabel,               /* .debug_deflabel */
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,       /* .debug_directive */
+    cv8_typevalue,              /* .debug_typevalue */
+    cv8_output,                 /* .debug_output */
+    cv8_cleanup,                /* .cleanup */
+    NULL                        /* pragma list */
+};
+
+/*******************************************************************************
+ * dfmt callbacks
+ ******************************************************************************/
+struct source_file;
+
+struct source_file {
+    const char *filename;
+    char *fullname;
+    uint32_t fullnamelen;
+
+    struct source_file *next;
+
+    uint32_t filetbl_off;
+    uint32_t sourcetbl_off;
+
+    struct SAA *lines;
+    uint32_t num_lines;
+
+    unsigned char md5sum[MD5_HASHBYTES];
+};
+
+struct linepair {
+    uint32_t file_offset;
+    uint32_t linenumber;
+};
+
+enum symbol_type {
+    SYMTYPE_CODE,
+    SYMTYPE_PROC,
+    SYMTYPE_LDATA,
+    SYMTYPE_GDATA,
+
+    SYMTYPE_MAX
+};
+
+struct cv8_symbol {
+    enum symbol_type type;
+    char *name;
+
+    uint32_t secrel;
+    uint16_t section;
+    uint32_t size;
+    uint32_t typeindex;
+
+    enum symtype {
+        TYPE_UNREGISTERED = 0x0000, /* T_NOTYPE */
+        TYPE_BYTE = 0x0020,
+        TYPE_WORD = 0x0021,
+        TYPE_DWORD= 0x0022,
+        TYPE_QUAD = 0x0023,
+
+        TYPE_REAL32 = 0x0040,
+        TYPE_REAL64 = 0x0041,
+        TYPE_REAL80 = 0x0042,
+        TYPE_REAL128= 0x0043,
+        TYPE_REAL256= 0x0044,
+        TYPE_REAL512= 0x0045
+    } symtype;
+};
+
+struct cv8_state {
+    int symbol_sect;
+    int type_sect;
+
+    uint32_t text_offset;
+
+    struct source_file *source_files, **source_files_tail;
+    const char *last_filename;
+    struct source_file *last_source_file;
+    struct hash_table file_hash;
+    unsigned num_files;
+    uint32_t total_filename_len;
+
+
+    unsigned total_lines;
+
+    struct SAA *symbols;
+    struct cv8_symbol *last_sym;
+    unsigned num_syms[SYMTYPE_MAX];
+    unsigned symbol_lengths;
+    unsigned total_syms;
+
+    struct {
+        char *name;
+        size_t namebytes;
+    } outfile;
+};
+struct cv8_state cv8_state;
+
+static void cv8_init(void)
+{
+    const uint32_t sect_flags =     IMAGE_SCN_MEM_READ |
+                    IMAGE_SCN_MEM_DISCARDABLE |
+                    IMAGE_SCN_CNT_INITIALIZED_DATA |
+                    IMAGE_SCN_ALIGN_1BYTES;
+
+    cv8_state.symbol_sect = coff_make_section(".debug$S", sect_flags);
+    cv8_state.type_sect = coff_make_section(".debug$T", sect_flags);
+
+    cv8_state.text_offset = 0;
+
+    cv8_state.source_files = NULL;
+    cv8_state.source_files_tail = &cv8_state.source_files;
+
+    cv8_state.num_files = 0;
+    cv8_state.total_filename_len = 0;
+
+    cv8_state.total_lines = 0;
+
+    cv8_state.symbols = saa_init(sizeof(struct cv8_symbol));
+    cv8_state.last_sym = NULL;
+}
+
+static struct source_file *register_file(const char *filename);
+static struct coff_Section *find_section(int32_t segto);
+
+static void cv8_linenum(const char *filename, int32_t linenumber,
+        int32_t segto)
+{
+    struct coff_Section *s;
+    struct linepair *li;
+    struct source_file *file;
+
+    file = register_file(filename);
+
+    s = find_section(segto);
+    if (s == NULL)
+        return;
+
+    if ((s->flags & IMAGE_SCN_MEM_EXECUTE) == 0)
+        return;
+
+    li = saa_wstruct(file->lines);
+    li->file_offset = cv8_state.text_offset;
+    li->linenumber = linenumber;
+
+    file->num_lines++;
+    cv8_state.total_lines++;
+}
+
+static void cv8_deflabel(char *name, int32_t segment, int64_t offset,
+        int is_global, char *special)
+{
+    struct cv8_symbol *sym;
+    struct coff_Section *s;
+
+    (void)special;
+
+    s = find_section(segment);
+    if (s == NULL)
+        return;
+
+    sym = saa_wstruct(cv8_state.symbols);
+
+    if (s->flags & IMAGE_SCN_MEM_EXECUTE)
+        sym->type = is_global ? SYMTYPE_PROC : SYMTYPE_CODE;
+    else
+        sym->type = is_global ?  SYMTYPE_GDATA : SYMTYPE_LDATA;
+    cv8_state.num_syms[sym->type]++;
+    cv8_state.total_syms++;
+
+    sym->section = segment;
+    sym->secrel = offset;
+    sym->symtype = TYPE_UNREGISTERED;
+    sym->size = 0;
+    sym->typeindex = 0;
+
+    sym->name = nasm_strdup(name);
+    cv8_state.symbol_lengths += strlen(sym->name) + 1;
+
+    if (cv8_state.last_sym && cv8_state.last_sym->section == segment)
+        cv8_state.last_sym->size = offset - cv8_state.last_sym->secrel;
+    cv8_state.last_sym = sym;
+}
+
+static void cv8_typevalue(int32_t type)
+{
+    if (!cv8_state.last_sym)
+        return;
+    if (cv8_state.last_sym->symtype != TYPE_UNREGISTERED)
+        return;
+
+    switch (TYM_TYPE(type)) {
+    case TY_BYTE:
+        cv8_state.last_sym->symtype = TYPE_BYTE;
+        break;
+    case TY_WORD:
+        cv8_state.last_sym->symtype = TYPE_WORD;
+        break;
+    case TY_DWORD:
+        cv8_state.last_sym->symtype = TYPE_DWORD;
+        break;
+    case TY_QWORD:
+        cv8_state.last_sym->symtype = TYPE_QUAD;
+        break;
+    case TY_FLOAT:
+        cv8_state.last_sym->symtype = TYPE_REAL32;
+        break;
+    case TY_TBYTE:
+        cv8_state.last_sym->symtype = TYPE_REAL80;
+        break;
+    case TY_OWORD:
+        cv8_state.last_sym->symtype = TYPE_REAL128;
+        break;
+    case TY_YWORD:
+        cv8_state.last_sym->symtype = TYPE_REAL256;
+        break;
+    case TY_ZWORD:
+        cv8_state.last_sym->symtype = TYPE_REAL512;
+        break;
+    case TY_UNKNOWN:
+        break;
+    case TY_LABEL:
+        break;
+    }
+}
+
+static void cv8_output(int type, void *param)
+{
+    struct coff_DebugInfo *dinfo = param;
+
+    (void)type;
+
+    if (dinfo->section && dinfo->section->name &&
+    !strncmp(dinfo->section->name, ".text", 5))
+        cv8_state.text_offset += dinfo->size;
+}
+
+static void build_symbol_table(struct coff_Section *const sect);
+static void build_type_table(struct coff_Section *const sect);
+
+static void cv8_cleanup(void)
+{
+    struct cv8_symbol *sym;
+    struct source_file *file, *ftmp;
+
+    struct coff_Section *symbol_sect = coff_sects[cv8_state.symbol_sect];
+    struct coff_Section *type_sect = coff_sects[cv8_state.type_sect];
+
+    cv8_state.outfile.name = nasm_realpath(outname);
+    cv8_state.outfile.namebytes = strlen(cv8_state.outfile.name) + 1;
+
+    build_symbol_table(symbol_sect);
+    build_type_table(type_sect);
+
+    list_for_each_safe(file, ftmp, cv8_state.source_files) {
+        nasm_free(file->fullname);
+        saa_free(file->lines);
+        nasm_free(file);
+    }
+    hash_free(&cv8_state.file_hash);
+
+    saa_rewind(cv8_state.symbols);
+    while ((sym = saa_rstruct(cv8_state.symbols)))
+        nasm_free(sym->name);
+    saa_free(cv8_state.symbols);
+
+    nasm_free(cv8_state.outfile.name);
+}
+
+/*******************************************************************************
+ * implementation
+ ******************************************************************************/
+static void calc_md5(const char *const filename,
+        unsigned char sum[MD5_HASHBYTES])
+{
+    int success = 0;
+    unsigned char *file_buf;
+    FILE *f;
+    MD5_CTX ctx;
+
+    f = pp_input_fopen(filename, NF_BINARY);
+    if (!f)
+        goto done;
+
+    file_buf = nasm_zalloc(BUFSIZ);
+
+    MD5Init(&ctx);
+    while (!feof(f)) {
+        size_t i = fread(file_buf, 1, BUFSIZ, f);
+        if (ferror(f))
+            goto done_0;
+        else if (i == 0)
+            break;
+        MD5Update(&ctx, file_buf, i);
+    }
+    MD5Final(sum, &ctx);
+
+    success = 1;
+done_0:
+    nasm_free(file_buf);
+    fclose(f);
+done:
+    if (!success) {
+        nasm_nonfatal("unable to hash file %s. "
+                      "Debug information may be unavailable.",
+                      filename);
+    }
+    return;
+}
+
+static struct source_file *register_file(const char *filename)
+{
+    struct source_file *file;
+    void **filep;
+    char *fullpath;
+    struct hash_insert hi;
+
+    /*
+     * The common case is that we are invoked with the same filename
+     * as we were last time.  Make this a pointer comparison: this is
+     * safe because the NASM core code allocates each filename once
+     * and never frees it.
+     */
+    if (likely(cv8_state.last_filename == filename))
+        return cv8_state.last_source_file;
+
+    cv8_state.last_filename = filename;
+
+    filep = hash_find(&cv8_state.file_hash, filename, &hi);
+    if (likely(filep)) {
+        file = *filep;
+    } else {
+        /* New filename encounter */
+
+        fullpath = nasm_realpath(filename);
+
+        nasm_new(file);
+        file->filename = filename;
+        file->fullname = fullpath;
+        file->fullnamelen = strlen(fullpath);
+        file->lines = saa_init(sizeof(struct linepair));
+        *cv8_state.source_files_tail = file;
+        cv8_state.source_files_tail = &file->next;
+        calc_md5(fullpath, file->md5sum);
+
+        hash_add(&hi, filename, file);
+
+        cv8_state.num_files++;
+        cv8_state.total_filename_len += file->fullnamelen + 1;
+    }
+
+    cv8_state.last_source_file = file;
+    return file;
+}
+
+static struct coff_Section *find_section(int32_t segto)
+{
+    int i;
+
+    for (i = 0; i < coff_nsects; i++) {
+        struct coff_Section *sec;
+
+        sec = coff_sects[i];
+        if (segto == sec->index)
+            return sec;
+    }
+    return NULL;
+}
+
+static void register_reloc(struct coff_Section *const sect,
+        char *sym, uint32_t addr, uint16_t type)
+{
+    struct coff_Reloc *r;
+    struct coff_Section *sec;
+    uint32_t i;
+
+    r = *sect->tail = nasm_malloc(sizeof(struct coff_Reloc));
+    sect->tail = &r->next;
+    r->next = NULL;
+    sect->nrelocs++;
+
+    r->address = addr;
+    r->symbase = SECT_SYMBOLS;
+    r->type = type;
+
+    r->symbol = 0;
+    for (i = 0; i < (uint32_t)coff_nsects; i++) {
+        sec = coff_sects[i];
+        if (!strcmp(sym, sec->name)) {
+            return;
+        }
+        r->symbol += 2;
+    }
+
+    saa_rewind(coff_syms);
+    for (i = 0; i < coff_nsyms; i++) {
+        struct coff_Symbol *s = saa_rstruct(coff_syms);
+        r->symbol++;
+        if (s->strpos == -1 && !strcmp(sym, s->name)) {
+            return;
+        } else if (s->strpos != -1) {
+            int res;
+            char *symname;
+
+            symname = nasm_malloc(s->namlen + 1);
+            saa_fread(coff_strs, s->strpos-4, symname, s->namlen);
+            symname[s->namlen] = '\0';
+            res = strcmp(sym, symname);
+            nasm_free(symname);
+            if (!res)
+                return;
+        }
+    }
+    nasm_panic("codeview: relocation for unregistered symbol: %s", sym);
+}
+
+static inline void section_write32(struct coff_Section *sect, uint32_t val)
+{
+    saa_write32(sect->data, val);
+    sect->len += 4;
+}
+
+static inline void section_write16(struct coff_Section *sect, uint16_t val)
+{
+    saa_write16(sect->data, val);
+    sect->len += 2;
+}
+
+static inline void section_write8(struct coff_Section *sect, uint8_t val)
+{
+    saa_write8(sect->data, val);
+    sect->len++;
+}
+
+static inline void section_wbytes(struct coff_Section *sect, const void *buf,
+        size_t len)
+{
+    saa_wbytes(sect->data, buf, len);
+    sect->len += len;
+}
+
+static void write_filename_table(struct coff_Section *const sect)
+{
+    uint32_t field_length;
+    uint32_t tbl_off = 1;    /* offset starts at 1 to skip NULL entry */
+    struct source_file *file;
+
+    nasm_assert(cv8_state.source_files != NULL);
+    nasm_assert(cv8_state.num_files > 0);
+    nasm_assert(cv8_state.total_filename_len > 0);
+
+    field_length = 1 + cv8_state.total_filename_len;
+
+    section_write32(sect, 0x000000F3);
+    section_write32(sect, field_length);
+
+    section_write8(sect, 0);
+
+    list_for_each(file, cv8_state.source_files) {
+        section_wbytes(sect, file->fullname, file->fullnamelen + 1);
+        file->filetbl_off = tbl_off;
+        tbl_off += file->fullnamelen + 1;
+    }
+}
+
+static void write_sourcefile_table(struct coff_Section *const sect)
+{
+    const uint32_t entry_size = 4 + 2 + MD5_HASHBYTES + 2;
+
+    uint32_t field_length = 0;
+    uint32_t tbl_off = 0;
+    struct source_file *file;
+
+    field_length = entry_size * cv8_state.num_files;
+
+    section_write32(sect, 0x000000F4);
+    section_write32(sect, field_length);
+
+    list_for_each(file, cv8_state.source_files) {
+        nasm_assert(file->filetbl_off > 0);
+        section_write32(sect, file->filetbl_off);
+        section_write16(sect, 0x0110);
+        section_wbytes(sect, file->md5sum, MD5_HASHBYTES);
+        section_write16(sect, 0);
+
+        file->sourcetbl_off = tbl_off;
+        tbl_off += entry_size;
+    }
+}
+
+static void write_linenumber_table(struct coff_Section *const sect)
+{
+    const uint32_t file_field_len = 12;
+    const uint32_t line_field_len = 8;
+
+    int i;
+    uint32_t field_length = 0;
+    size_t field_base;
+    struct source_file *file;
+    struct coff_Section *s;
+
+    for (i = 0; i < coff_nsects; i++) {
+        if (!strncmp(coff_sects[i]->name, ".text", 5))
+            break;
+    }
+
+    if (i == coff_nsects)
+        return;
+    s = coff_sects[i];
+
+    field_length = 12;
+    field_length += (cv8_state.num_files * file_field_len);
+    field_length += (cv8_state.total_lines * line_field_len);
+
+    section_write32(sect, 0x000000F2);
+    section_write32(sect, field_length);
+
+    field_base = sect->len;
+    section_write32(sect, 0); /* SECREL, updated by relocation */
+    section_write16(sect, 0); /* SECTION, updated by relocation*/
+    section_write16(sect, 0); /* pad */
+    section_write32(sect, s->len);
+
+    register_reloc(sect, ".text", field_base,
+        win64 ? IMAGE_REL_AMD64_SECREL : IMAGE_REL_I386_SECREL);
+
+    register_reloc(sect, ".text", field_base + 4,
+        win64 ? IMAGE_REL_AMD64_SECTION : IMAGE_REL_I386_SECTION);
+
+    list_for_each(file, cv8_state.source_files) {
+        struct linepair *li;
+
+        /* source mapping */
+        section_write32(sect, file->sourcetbl_off);
+        section_write32(sect, file->num_lines);
+        section_write32(sect, file_field_len + (file->num_lines * line_field_len));
+
+        /* the pairs */
+        saa_rewind(file->lines);
+        while ((li = saa_rstruct(file->lines))) {
+            section_write32(sect, li->file_offset);
+            section_write32(sect, li->linenumber |= 0x80000000);
+        }
+    }
+}
+
+static uint32_t write_symbolinfo_obj(struct coff_Section *sect)
+{
+    uint32_t obj_len;
+
+    obj_len = 2 + 4 + cv8_state.outfile.namebytes;
+
+    section_write16(sect, obj_len);
+    section_write16(sect, 0x1101);
+    section_write32(sect, 0); /* ASM language */
+    section_wbytes(sect, cv8_state.outfile.name, cv8_state.outfile.namebytes);
+
+    return obj_len;
+}
+
+static uint32_t write_symbolinfo_properties(struct coff_Section *sect,
+        const char *const creator_str)
+{
+    /* https://github.com/Microsoft/microsoft-pdb/blob/1d60e041/include/cvinfo.h#L3313 */
+    uint32_t creator_len;
+
+    creator_len = 2 + 4 + 2 + 3*2 + 3*2 + strlen(creator_str)+1 + 2;
+
+    /*
+     * We used to use a language ID of 3 for "MASM", since it's closest of the
+     * options available; however, BinScope from WACK (the Windows Application
+     * Certification Kit) tests for specific minimum MASM versions and trying to
+     * match an increasing sequence of random MASM version/build numbers seems
+     * like a fool's errand.
+     *
+     * Instead, use a different language ID (NASM is, after all, not MASM
+     * syntax) and just write the actual NASM version number. BinScope appears
+     * to be happy with that.
+     */
+
+    section_write16(sect, creator_len);
+    section_write16(sect, 0x1116);
+    section_write32(sect, 'N'); /* language: 'N' (0x4e) for "NASM"; flags are 0 */
+    if (win64)
+        section_write16(sect, 0x00D0); /* machine */
+    else if (win32)
+        section_write16(sect, 0x0006); /* machine */
+    else
+        nasm_panic("neither win32 nor win64 are set!");
+    section_write16(sect, 0); /* verFEMajor */
+    section_write16(sect, 0); /* verFEMinor */
+    section_write16(sect, 0); /* verFEBuild */
+
+    /* BinScope/WACK insist on version >= 8.0.50727 */
+    section_write16(sect, NASM_MAJOR_VER); /* verMajor */
+    section_write16(sect, NASM_MINOR_VER); /* verMinor */
+    section_write16(sect, NASM_SUBMINOR_VER*100 + NASM_PATCHLEVEL_VER); /* verBuild */
+
+    section_wbytes(sect, creator_str, strlen(creator_str)+1); /* verSt */
+    /*
+     * normally there would be key/value pairs here, but they aren't
+     * necessary. They are terminated by 2B
+     */
+    section_write16(sect, 0);
+
+    return creator_len;
+}
+
+static uint32_t write_symbolinfo_symbols(struct coff_Section *sect)
+{
+    uint32_t len = 0, field_len;
+    uint32_t field_base;
+    struct cv8_symbol *sym;
+
+    saa_rewind(cv8_state.symbols);
+    while ((sym = saa_rstruct(cv8_state.symbols))) {
+        switch (sym->type) {
+        case SYMTYPE_LDATA:
+        case SYMTYPE_GDATA:
+            field_len = 12 + strlen(sym->name) + 1;
+            len += field_len - 2;
+            section_write16(sect, field_len);
+            if (sym->type == SYMTYPE_LDATA)
+                section_write16(sect, 0x110C);
+            else
+                section_write16(sect, 0x110D);
+            section_write32(sect, sym->symtype);
+
+            field_base = sect->len;
+            section_write32(sect, 0); /* SECREL */
+            section_write16(sect, 0); /* SECTION */
+            break;
+        case SYMTYPE_PROC:
+        case SYMTYPE_CODE:
+            field_len = 9 + strlen(sym->name) + 1;
+            len += field_len - 2;
+            section_write16(sect, field_len);
+            section_write16(sect, 0x1105);
+
+            field_base = sect->len;
+            section_write32(sect, 0); /* SECREL */
+            section_write16(sect, 0); /* SECTION */
+            section_write8(sect, 0); /* FLAG */
+            break;
+        default:
+            nasm_panic("unknown symbol type");
+        }
+
+        section_wbytes(sect, sym->name, strlen(sym->name) + 1);
+
+        register_reloc(sect, sym->name, field_base,
+            win64 ? IMAGE_REL_AMD64_SECREL :
+                IMAGE_REL_I386_SECREL);
+        register_reloc(sect, sym->name, field_base + 4,
+            win64 ? IMAGE_REL_AMD64_SECTION :
+                IMAGE_REL_I386_SECTION);
+    }
+
+    return len;
+}
+
+static void write_symbolinfo_table(struct coff_Section *const sect)
+{
+    static const char creator_str[] = "The Netwide Assembler " NASM_VER;
+    uint32_t obj_length, creator_length, sym_length;
+    uint32_t field_length = 0, out_len;
+
+    nasm_assert(cv8_state.outfile.namebytes);
+
+    /* signature, language, outfile NULL */
+    obj_length = 2 + 4 + cv8_state.outfile.namebytes;
+    creator_length = 2 + 4 + 2 + 3*2 + 3*2 + strlen(creator_str)+1 + 2;
+
+    sym_length =    ( cv8_state.num_syms[SYMTYPE_CODE] *  7) +
+            ( cv8_state.num_syms[SYMTYPE_PROC] *  7) +
+            ( cv8_state.num_syms[SYMTYPE_LDATA] * 10) +
+            ( cv8_state.num_syms[SYMTYPE_GDATA] * 10) +
+            cv8_state.symbol_lengths;
+
+    field_length = 2 + obj_length +
+               2 + creator_length +
+               (4 * cv8_state.total_syms) + sym_length;
+
+    section_write32(sect, 0x000000F1);
+    section_write32(sect, field_length);
+
+    /* for sub fields, length proceeds type */
+
+    out_len = write_symbolinfo_obj(sect);
+    nasm_assert(out_len == obj_length);
+
+    out_len = write_symbolinfo_properties(sect, creator_str);
+    nasm_assert(out_len == creator_length);
+
+    out_len = write_symbolinfo_symbols(sect);
+    nasm_assert(out_len == sym_length);
+}
+
+static inline void align4_table(struct coff_Section *const sect)
+{
+    unsigned diff;
+    uint32_t zero = 0;
+    struct SAA *data = sect->data;
+
+    if (data->wptr % 4 == 0)
+        return;
+
+    diff = 4 - (data->wptr % 4);
+    if (diff)
+        section_wbytes(sect, &zero, diff);
+}
+
+static void build_symbol_table(struct coff_Section *const sect)
+{
+    section_write32(sect, 0x00000004);
+
+    write_filename_table(sect);
+    align4_table(sect);
+    write_sourcefile_table(sect);
+    align4_table(sect);
+    write_linenumber_table(sect);
+    align4_table(sect);
+    write_symbolinfo_table(sect);
+    align4_table(sect);
+}
+
+static void build_type_table(struct coff_Section *const sect)
+{
+    uint32_t field_len;
+    uint32_t typeindex = 0x1000;
+    uint32_t idx_arglist;
+
+    section_write32(sect, 0x00000004);
+
+    /* empty argument list type */
+    field_len = 2 + 4;
+    section_write16(sect, field_len);
+    section_write16(sect, 0x1201); /* ARGLIST */
+    section_write32(sect, 0); /* num params */
+    idx_arglist = typeindex++;
+
+    /* procedure type: void proc(void) */
+    field_len = 2 + 4 + 1 + 1 + 2 + 4;
+    section_write16(sect, field_len);
+    section_write16(sect, 0x1008); /* PROC type */
+
+    section_write32(sect, 0x00000003); /* return type VOID */
+    section_write8(sect, 0);  /* calling convention (default) */
+    section_write8(sect, 0);  /* function attributes */
+    section_write16(sect, 0); /* # params */
+    section_write32(sect, idx_arglist); /* argument list type */
+    /* idx_voidfunc = typeindex++; */
+}
diff --git a/vere/ext/nasm/output/dwarf.h b/vere/ext/nasm/output/dwarf.h
new file mode 100644
index 0000000..87bc0c8
--- /dev/null
+++ b/vere/ext/nasm/output/dwarf.h
@@ -0,0 +1,621 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef OUTPUT_DWARF_H
+#define OUTPUT_DWARF_H
+
+/*
+ * based on DWARF 3 standard
+ */
+
+enum dwarf_tag {
+	DW_TAG_padding			= 0x00,
+	DW_TAG_array_type		= 0x01,
+	DW_TAG_class_type		= 0x02,
+	DW_TAG_entry_point		= 0x03,
+	DW_TAG_enumeration_type		= 0x04,
+	DW_TAG_formal_parameter		= 0x05,
+	DW_TAG_global_subroutine	= 0x06,
+	DW_TAG_global_variable		= 0x07,
+	DW_TAG_label			= 0x0a,
+	DW_TAG_lexical_block		= 0x0b,
+	DW_TAG_local_variable		= 0x0c,
+	DW_TAG_member			= 0x0d,
+	DW_TAG_pointer_type		= 0x0f,
+	DW_TAG_reference_type		= 0x10,
+	DW_TAG_compile_unit		= 0x11,
+	DW_TAG_string_type		= 0x12,
+	DW_TAG_structure_type		= 0x13,
+	DW_TAG_subroutine		= 0x14,
+	DW_TAG_subroutine_type		= 0x15,
+	DW_TAG_typedef			= 0x16,
+	DW_TAG_union_type		= 0x17,
+	DW_TAG_unspecified_parameters	= 0x18,
+	DW_TAG_variant			= 0x19,
+	DW_TAG_common_block		= 0x1a,
+	DW_TAG_common_inclusion		= 0x1b,
+	DW_TAG_inheritance		= 0x1c,
+	DW_TAG_inlined_subroutine	= 0x1d,
+	DW_TAG_module			= 0x1e,
+	DW_TAG_ptr_to_member_type	= 0x1f,
+	DW_TAG_set_type			= 0x20,
+	DW_TAG_subrange_type		= 0x21,
+	DW_TAG_with_stmt		= 0x22,
+	DW_TAG_access_declaration	= 0x23,
+	DW_TAG_base_type		= 0x24,
+	DW_TAG_catch_block		= 0x25,
+	DW_TAG_const_type		= 0x26,
+	DW_TAG_constant			= 0x27,
+	DW_TAG_enumerator		= 0x28,
+	DW_TAG_file_type		= 0x29,
+	DW_TAG_friend			= 0x2a,
+	DW_TAG_namelist			= 0x2b,
+	DW_TAG_namelist_item		= 0x2c,
+	DW_TAG_packed_type		= 0x2d,
+	DW_TAG_subprogram		= 0x2e,
+	DW_TAG_template_type_parameter	= 0x2f,
+	DW_TAG_template_value_parameter	= 0x30,
+	DW_TAG_thrown_type		= 0x31,
+	DW_TAG_try_block		= 0x32,
+	DW_TAG_variant_part		= 0x33,
+	DW_TAG_variable			= 0x34,
+	DW_TAG_volatile_type		= 0x35,
+	/* DWARF 3 */
+	DW_TAG_dwarf_procedure		= 0x36,
+	DW_TAG_restrict_type		= 0x37,
+	DW_TAG_interface_type		= 0x38,
+	DW_TAG_namespace		= 0x39,
+	DW_TAG_imported_module		= 0x3a,
+	DW_TAG_unspecified_type		= 0x3b,
+	DW_TAG_partial_unit		= 0x3c,
+	DW_TAG_imported_unit		= 0x3d,
+	DW_TAG_condition		= 0x3f,
+	DW_TAG_shared_type		= 0x40,
+	/* DWARF 4 */
+	DW_TAG_type_unit		= 0x41,
+	DW_TAG_rvalue_reference_type	= 0x42,
+	DW_TAG_template_alias		= 0x43,
+	/* DWARF 5 */
+	DW_TAG_atomic_type		= 0x47,
+
+	DW_TAG_lo_user			= 0x4080,
+	DW_TAG_hi_user			= 0xffff
+};
+
+enum dwarf_child {
+	DW_CHILDREN_no		= 0x00,
+	DW_CHILDREN_yes		= 0x01
+};
+
+enum dwarf_form {
+	DW_FORM_addr		= 0x01,
+	DW_FORM_block2		= 0x03,
+	DW_FORM_block4		= 0x04,
+	DW_FORM_data2		= 0x05,
+	DW_FORM_data4		= 0x06,
+	DW_FORM_data8		= 0x07,
+	DW_FORM_string		= 0x08,
+	DW_FORM_block		= 0x09,
+	DW_FORM_block1		= 0x0a,
+	DW_FORM_data1		= 0x0b,
+	DW_FORM_flag		= 0x0c,
+	DW_FORM_sdata		= 0x0d,
+	DW_FORM_strp		= 0x0e,
+	DW_FORM_udata		= 0x0f,
+	DW_FORM_ref_addr	= 0x10,
+	DW_FORM_ref1		= 0x11,
+	DW_FORM_ref2		= 0x12,
+	DW_FORM_ref4		= 0x13,
+	DW_FORM_ref8		= 0x14,
+	DW_FORM_ref_udata	= 0x15,
+	DW_FORM_indirect	= 0x16,
+	/* DWARF 4 */
+	DW_FORM_sec_offset	= 0x17,
+	DW_FORM_exprloc		= 0x18,
+	DW_FORM_flag_present	= 0x19,
+	DW_FORM_ref_sig8	= 0x20
+};
+
+enum dwarf_attribute {
+	DW_AT_sibling		= 0x01,
+	DW_AT_location		= 0x02,
+	DW_AT_name		= 0x03,
+	DW_AT_ordering		= 0x09,
+	DW_AT_byte_size		= 0x0b,
+	DW_AT_bit_offset	= 0x0c,
+	DW_AT_bit_size		= 0x0d,
+	DW_AT_stmt_list		= 0x10,
+	DW_AT_low_pc		= 0x11,
+	DW_AT_high_pc		= 0x12,
+	DW_AT_language		= 0x13,
+	DW_AT_discr		= 0x15,
+	DW_AT_discr_value	= 0x16,
+	DW_AT_visibility	= 0x17,
+	DW_AT_import		= 0x18,
+	DW_AT_string_length	= 0x19,
+	DW_AT_common_reference	= 0x1a,
+	DW_AT_comp_dir		= 0x1b,
+	DW_AT_const_value	= 0x1c,
+	DW_AT_containing_type	= 0x1d,
+	DW_AT_default_value	= 0x1e,
+	DW_AT_inline		= 0x20,
+	DW_AT_is_optional	= 0x21,
+	DW_AT_lower_bound	= 0x22,
+	DW_AT_producer		= 0x25,
+	DW_AT_prototyped	= 0x27,
+	DW_AT_return_addr	= 0x2a,
+	DW_AT_start_scope	= 0x2c,
+	DW_AT_bit_stride	= 0x2e,
+	DW_AT_upper_bound	= 0x2f,
+	DW_AT_abstract_origin	= 0x31,
+	DW_AT_accessibility	= 0x32,
+	DW_AT_address_class	= 0x33,
+	DW_AT_artificial	= 0x34,
+	DW_AT_base_types	= 0x35,
+	DW_AT_calling_convention= 0x36,
+	DW_AT_count		= 0x37,
+	DW_AT_data_member_location = 0x38,
+	DW_AT_decl_column	= 0x39,
+	DW_AT_decl_file		= 0x3a,
+	DW_AT_decl_line		= 0x3b,
+	DW_AT_declaration	= 0x3c,
+	DW_AT_discr_list	= 0x3d,
+	DW_AT_encoding		= 0x3e,
+	DW_AT_external		= 0x3f,
+	DW_AT_frame_base	= 0x40,
+	DW_AT_friend		= 0x41,
+	DW_AT_identifier_case	= 0x42,
+	DW_AT_macro_info	= 0x43,
+	DW_AT_namelist_item	= 0x44,
+	DW_AT_priority		= 0x45,
+	DW_AT_segment		= 0x46,
+	DW_AT_specification	= 0x47,
+	DW_AT_static_link	= 0x48,
+	DW_AT_type		= 0x49,
+	DW_AT_use_location	= 0x4a,
+	DW_AT_variable_parameter = 0x4b,
+	DW_AT_virtuality	= 0x4c,
+	DW_AT_vtable_elem_location = 0x4d,
+	/* DWARF 3 */
+	DW_AT_allocated		= 0x4e,
+	DW_AT_associated	= 0x4f,
+	DW_AT_data_location	= 0x50,
+	DW_AT_byte_stride	= 0x51,
+	DW_AT_entry_pc		= 0x52,
+	DW_AT_use_UTF8		= 0x53,
+	DW_AT_extension		= 0x54,
+	DW_AT_ranges		= 0x55,
+	DW_AT_trampoline	= 0x56,
+	DW_AT_call_column	= 0x57,
+	DW_AT_call_file		= 0x58,
+	DW_AT_call_line		= 0x59,
+	DW_AT_description	= 0x5a,
+	DW_AT_binary_scale	= 0x5b,
+	DW_AT_decimal_scale	= 0x5c,
+	DW_AT_small		= 0x5d,
+	DW_AT_decimal_sign	= 0x5e,
+	DW_AT_digit_count	= 0x5f,
+	DW_AT_picture_string	= 0x60,
+	DW_AT_mutable		= 0x61,
+	DW_AT_threads_scaled	= 0x62,
+	DW_AT_explicit		= 0x63,
+	DW_AT_object_pointer	= 0x64,
+	DW_AT_endianity		= 0x65,
+	DW_AT_elemental		= 0x66,
+	DW_AT_pure		= 0x67,
+	DW_AT_recursive		= 0x68,
+	/* DWARF 4 */
+	DW_AT_signature		= 0x69,
+	DW_AT_main_subprogram	= 0x6a,
+	DW_AT_data_bit_offset	= 0x6b,
+	DW_AT_const_expr	= 0x6c,
+	DW_AT_enum_class	= 0x6d,
+	DW_AT_linkage_name	= 0x6e,
+	/* DWARF 5 */
+	DW_AT_noreturn		= 0x87,
+
+	DW_AT_lo_user		= 0x2000,
+	DW_AT_hi_user		= 0x3fff
+};
+
+enum dwarf_op {
+	DW_OP_addr		= 0x03,
+	DW_OP_deref		= 0x06,
+	DW_OP_const1u		= 0x08,
+	DW_OP_const1s		= 0x09,
+	DW_OP_const2u		= 0x0a,
+	DW_OP_const2s		= 0x0b,
+	DW_OP_const4u		= 0x0c,
+	DW_OP_const4s		= 0x0d,
+	DW_OP_const8u		= 0x0e,
+	DW_OP_const8s		= 0x0f,
+	DW_OP_constu		= 0x10,
+	DW_OP_consts		= 0x11,
+	DW_OP_dup		= 0x12,
+	DW_OP_drop		= 0x13,
+	DW_OP_over		= 0x14,
+	DW_OP_pick		= 0x15,
+	DW_OP_swap		= 0x16,
+	DW_OP_rot		= 0x17,
+	DW_OP_xderef		= 0x18,
+	DW_OP_abs		= 0x19,
+	DW_OP_and		= 0x1a,
+	DW_OP_div		= 0x1b,
+	DW_OP_minus		= 0x1c,
+	DW_OP_mod		= 0x1d,
+	DW_OP_mul		= 0x1e,
+	DW_OP_neg		= 0x1f,
+	DW_OP_not		= 0x20,
+	DW_OP_or		= 0x21,
+	DW_OP_plus		= 0x22,
+	DW_OP_plus_uconst	= 0x23,
+	DW_OP_shl		= 0x24,
+	DW_OP_shr		= 0x25,
+	DW_OP_shra		= 0x26,
+	DW_OP_xor		= 0x27,
+	DW_OP_skip		= 0x2f,
+	DW_OP_bra		= 0x28,
+	DW_OP_eq		= 0x29,
+	DW_OP_ge		= 0x2a,
+	DW_OP_gt		= 0x2b,
+	DW_OP_le		= 0x2c,
+	DW_OP_lt		= 0x2d,
+	DW_OP_ne		= 0x2e,
+	DW_OP_lit0		= 0x30,
+	DW_OP_lit1		= 0x31,
+	DW_OP_lit2		= 0x32,
+	DW_OP_lit3		= 0x33,
+	DW_OP_lit4		= 0x34,
+	DW_OP_lit5		= 0x35,
+	DW_OP_lit6		= 0x36,
+	DW_OP_lit7		= 0x37,
+	DW_OP_lit8		= 0x38,
+	DW_OP_lit9		= 0x39,
+	DW_OP_lit10		= 0x3a,
+	DW_OP_lit11		= 0x3b,
+	DW_OP_lit12		= 0x3c,
+	DW_OP_lit13		= 0x3d,
+	DW_OP_lit14		= 0x3e,
+	DW_OP_lit15		= 0x3f,
+	DW_OP_lit16		= 0x40,
+	DW_OP_lit17		= 0x41,
+	DW_OP_lit18		= 0x42,
+	DW_OP_lit19		= 0x43,
+	DW_OP_lit20		= 0x44,
+	DW_OP_lit21		= 0x45,
+	DW_OP_lit22		= 0x46,
+	DW_OP_lit23		= 0x47,
+	DW_OP_lit24		= 0x48,
+	DW_OP_lit25		= 0x49,
+	DW_OP_lit26		= 0x4a,
+	DW_OP_lit27		= 0x4b,
+	DW_OP_lit28		= 0x4c,
+	DW_OP_lit29		= 0x4d,
+	DW_OP_lit30		= 0x4e,
+	DW_OP_lit31		= 0x4f,
+	DW_OP_reg0		= 0x50,
+	DW_OP_reg1		= 0x51,
+	DW_OP_reg2		= 0x52,
+	DW_OP_reg3		= 0x53,
+	DW_OP_reg4		= 0x54,
+	DW_OP_reg5		= 0x55,
+	DW_OP_reg6		= 0x56,
+	DW_OP_reg7		= 0x57,
+	DW_OP_reg8		= 0x58,
+	DW_OP_reg9		= 0x59,
+	DW_OP_reg10		= 0x5a,
+	DW_OP_reg11		= 0x5b,
+	DW_OP_reg12		= 0x5c,
+	DW_OP_reg13		= 0x5d,
+	DW_OP_reg14		= 0x5e,
+	DW_OP_reg15		= 0x5f,
+	DW_OP_reg16		= 0x60,
+	DW_OP_reg17		= 0x61,
+	DW_OP_reg18		= 0x62,
+	DW_OP_reg19		= 0x63,
+	DW_OP_reg20		= 0x64,
+	DW_OP_reg21		= 0x65,
+	DW_OP_reg22		= 0x66,
+	DW_OP_reg23		= 0x67,
+	DW_OP_reg24		= 0x68,
+	DW_OP_reg25		= 0x69,
+	DW_OP_reg26		= 0x6a,
+	DW_OP_reg27		= 0x6b,
+	DW_OP_reg28		= 0x6c,
+	DW_OP_reg29		= 0x6d,
+	DW_OP_reg30		= 0x6e,
+	DW_OP_reg31		= 0x6f,
+	DW_OP_breg0		= 0x70,
+	DW_OP_breg1		= 0x71,
+	DW_OP_breg2		= 0x72,
+	DW_OP_breg3		= 0x73,
+	DW_OP_breg4		= 0x74,
+	DW_OP_breg5		= 0x75,
+	DW_OP_breg6		= 0x76,
+	DW_OP_breg7		= 0x77,
+	DW_OP_breg8		= 0x78,
+	DW_OP_breg9		= 0x79,
+	DW_OP_breg10		= 0x7a,
+	DW_OP_breg11		= 0x7b,
+	DW_OP_breg12		= 0x7c,
+	DW_OP_breg13		= 0x7d,
+	DW_OP_breg14		= 0x7e,
+	DW_OP_breg15		= 0x7f,
+	DW_OP_breg16		= 0x80,
+	DW_OP_breg17		= 0x81,
+	DW_OP_breg18		= 0x82,
+	DW_OP_breg19		= 0x83,
+	DW_OP_breg20		= 0x84,
+	DW_OP_breg21		= 0x85,
+	DW_OP_breg22		= 0x86,
+	DW_OP_breg23		= 0x87,
+	DW_OP_breg24		= 0x88,
+	DW_OP_breg25		= 0x89,
+	DW_OP_breg26		= 0x8a,
+	DW_OP_breg27		= 0x8b,
+	DW_OP_breg28		= 0x8c,
+	DW_OP_breg29		= 0x8d,
+	DW_OP_breg30		= 0x8e,
+	DW_OP_breg31		= 0x8f,
+	DW_OP_regx		= 0x90,
+	DW_OP_fbreg		= 0x91,
+	DW_OP_bregx		= 0x92,
+	DW_OP_piece		= 0x93,
+	DW_OP_deref_size	= 0x94,
+	DW_OP_xderef_size	= 0x95,
+	DW_OP_nop		= 0x96,
+	/* DWARF 3 */
+	DW_OP_push_object_address = 0x97,
+	DW_OP_call2		= 0x98,
+	DW_OP_call4		= 0x99,
+	DW_OP_call_ref		= 0x9a ,
+	DW_OP_form_tls_address	= 0x9b,
+	DW_OP_call_frame_cfa	= 0x9c,
+	DW_OP_bit_piece		= 0x9d,
+	/* DWARF 4 */
+	DW_OP_implicit_value	= 0x9e,
+	DW_OP_stack_value	= 0x9f,
+
+	DW_OP_lo_user		= 0xe0,
+	DW_OP_hi_user		= 0xff
+};
+
+enum dwarf_base_type {
+	DW_ATE_address		= 0x01,
+	DW_ATE_boolean		= 0x02,
+	DW_ATE_complex_float	= 0x03,
+	DW_ATE_float		= 0x04,
+	DW_ATE_signed		= 0x05,
+	DW_ATE_signed_char	= 0x06,
+	DW_ATE_unsigned		= 0x07,
+	DW_ATE_unsigned_char	= 0x08,
+	/* DWARF 3 */
+	DW_ATE_imaginary_float	= 0x09,
+	DW_ATE_packed_decimal	= 0x0a,
+	DW_ATE_numeric_string	= 0x0b,
+	DW_ATE_edited		= 0x0c,
+	DW_ATE_signed_fixed	= 0x0d,
+	DW_ATE_unsigned_fixed	= 0x0e,
+	DW_ATE_decimal_float	= 0x0f,
+	/* DWARF 4 */
+	DW_ATE_UTF		= 0x10,
+
+	DW_ATE_lo_user		= 0x80,
+	DW_ATE_hi_user		= 0xff
+};
+
+enum dwarf_decimal_sign {
+	DW_DS_unsigned			= 0x01,
+	DW_DS_leading_overpunch		= 0x02,
+	DW_DS_trailing_overpunch	= 0x03,
+	DW_DS_leading_separate		= 0x04,
+	DW_DS_trailing_separate		= 0x05
+};
+
+enum dwarf_endianity {
+	DW_END_default	= 0x00,
+	DW_END_big	= 0x01,
+	DW_END_little	= 0x02,
+
+	DW_END_lo_user	= 0x40,
+	DW_END_hi_user	= 0xff
+};
+
+enum dwarf_accessibility {
+	DW_ACCESS_public	= 0x01,
+	DW_ACCESS_protected	= 0x02,
+	DW_ACCESS_private	= 0x03
+};
+
+enum dwarf_visibility {
+	DW_VIS_local		= 0x01,
+	DW_VIS_exported		= 0x02,
+	DW_VIS_qualified	= 0x03
+};
+
+enum dwarf_virtuality {
+	DW_VIRTUALITY_none		= 0x00,
+	DW_VIRTUALITY_virtual		= 0x01,
+	DW_VIRTUALITY_pure_virtual	= 0x02
+};
+
+enum dwarf_language {
+	DW_LANG_C89		= 0x0001,
+	DW_LANG_C		= 0x0002,
+	DW_LANG_Ada83		= 0x0003,
+	DW_LANG_C_plus_plus	= 0x0004,
+	DW_LANG_Cobol74		= 0x0005,
+	DW_LANG_Cobol85		= 0x0006,
+	DW_LANG_Fortran77	= 0x0007,
+	DW_LANG_Fortran90	= 0x0008,
+	DW_LANG_Pascal83	= 0x0009,
+	DW_LANG_Modula2		= 0x000a,
+	DW_LANG_Java		= 0x000b,
+	DW_LANG_C99		= 0x000c,
+	DW_LANG_Ada95		= 0x000d,
+	DW_LANG_Fortran95	= 0x000e,
+	DW_LANG_PLI		= 0x000f,
+	DW_LANG_ObjC		= 0x0010,
+	DW_LANG_ObjC_plus_plus	= 0x0011,
+	DW_LANG_UPC		= 0x0012,
+	DW_LANG_D		= 0x0013,
+	DW_LANG_Python		= 0x0014,
+	DW_LANG_OpenCL		= 0x0015,
+	DW_LANG_Go		= 0x0016,
+	DW_LANG_Modula3		= 0x0017,
+	DW_LANG_Haskell		= 0x0018,
+	DW_LANG_C_plus_plus_03	= 0x0019,
+	DW_LANG_C_plus_plus_11	= 0x001a,
+	DW_LANG_OCaml		= 0x001b,
+	DW_LANG_Rust		= 0x001c,
+	DW_LANG_C11		= 0x001d,
+	DW_LANG_Swift		= 0x001e,
+	DW_LANG_Julia		= 0x001f,
+	DW_LANG_Dylan		= 0x0020,
+	DW_LANG_C_plus_plus_14	= 0x0021,
+	DW_LANG_Fortran03	= 0x0022,
+	DW_LANG_Fortran08	= 0x0023,
+	DW_LANG_RenderScript	= 0x0024,
+
+	DW_LANG_Mips_Assembler	= 0x8001,
+
+	DW_LANG_lo_user		= 0x8000,
+	DW_LANG_hi_user		= 0xffff,
+
+	DW_LANG_Rust_old	= 0x9000
+};
+
+enum dwarf_identifier_case {
+	DW_ID_case_sensitive	= 0x00,
+	DW_ID_up_case		= 0x01,
+	DW_ID_down_case		= 0x02,
+	DW_ID_case_insensitive	= 0x03
+};
+
+enum dwarf_calling_conversion {
+	DW_CC_normal			= 0x01,
+	DW_CC_program			= 0x02,
+	DW_CC_nocall			= 0x03,
+	DW_CC_pass_by_reference		= 0x4,
+	DW_CC_pass_by_value		= 0x5,
+
+	DW_CC_lo_user			= 0x40,
+	DW_CC_hi_user			= 0xff,
+
+	DW_CC_GNU_renesas_sh		= 0x40,
+	DW_CC_GNU_borland_fastcall_i386	= 0x41
+};
+
+enum dwarf_inline {
+	DW_INL_not_inlined		= 0x00,
+	DW_INL_inlined			= 0x01,
+	DW_INL_declared_not_inlined	= 0x02,
+	DW_INL_declared_inlined		= 0x03
+};
+
+enum dwarf_ordering {
+	DW_ORD_row_major = 0x00,
+	DW_ORD_col_major = 0x01
+};
+
+enum dwarf_discriminant {
+	DW_DSC_label = 0x00,
+	DW_DSC_range = 0x01
+};
+
+enum dwarf_line_number {
+	DW_LNS_extended_op	= 0x00,
+	DW_LNS_copy		= 0x01,
+	DW_LNS_advance_pc	= 0x02,
+	DW_LNS_advance_line	= 0x03,
+	DW_LNS_set_file		= 0x04,
+	DW_LNS_set_column	= 0x05,
+	DW_LNS_negate_stmt	= 0x06,
+	DW_LNS_set_basic_block	= 0x07,
+	DW_LNS_const_add_pc	= 0x08,
+	DW_LNS_fixed_advance_pc	= 0x09,
+	DW_LNS_set_prologue_end	= 0x0a,
+	DW_LNS_set_epilogue_begin = 0x0b,
+	DW_LNS_set_isa		= 0x0c
+};
+
+enum dwarf_line_number_extended {
+	DW_LNE_end_sequence	= 0x01,
+	DW_LNE_set_address	= 0x02,
+	DW_LNE_define_file	= 0x03,
+	DW_LNE_set_discriminator= 0x04,
+	DW_LNE_lo_user		= 0x80,
+	DW_LNE_hi_user		= 0xff
+};
+
+enum dwarf_macinfo_type {
+	DW_MACINFO_define	= 0x01,
+	DW_MACINFO_undef	= 0x02,
+	DW_MACINFO_start_file	= 0x03,
+	DW_MACINFO_end_file	= 0x04,
+	DW_MACINFO_vendor_ext	= 0xff
+};
+
+enum dwarf_call_frame {
+	DW_CFA_advance_loc		= 0x01,
+	DW_CFA_offset			= 0x02,
+	DW_CFA_restore			= 0x03,
+	DW_CFA_nop			= 0x00,
+	DW_CFA_set_loc			= 0x01,
+	DW_CFA_advance_loc1		= 0x02,
+	DW_CFA_advance_loc2		= 0x03,
+	DW_CFA_advance_loc4		= 0x04,
+	DW_CFA_offset_extended		= 0x05,
+	DW_CFA_restore_extended		= 0x06,
+	DW_CFA_undefined		= 0x07,
+	DW_CFA_same_value		= 0x08,
+	DW_CFA_register			= 0x09,
+	DW_CFA_remember_state		= 0x0a,
+	DW_CFA_restore_state		= 0x0b,
+	DW_CFA_def_cfa			= 0x0c,
+	DW_CFA_def_cfa_register		= 0x0d,
+	DW_CFA_def_cfa_offset		= 0x0e,
+	/* DWARF 3 */
+	DW_CFA_def_cfa_expression	= 0x0f,
+	DW_CFA_expression		= 0x10,
+	DW_CFA_offset_extended_sf	= 0x11,
+	DW_CFA_def_cfa_sf		= 0x12,
+	DW_CFA_def_cfa_offset_sf	= 0x13,
+	DW_CFA_val_offset		= 0x14,
+	DW_CFA_val_offset_sf		= 0x15,
+	DW_CFA_val_expression		= 0x16,
+	DW_CFA_lo_user			= 0x1c,
+	DW_CFA_hi_user			= 0x3f
+};
+
+#endif /* OUTPUT_DWARF_H */
diff --git a/vere/ext/nasm/output/elf.h b/vere/ext/nasm/output/elf.h
new file mode 100644
index 0000000..a15688e
--- /dev/null
+++ b/vere/ext/nasm/output/elf.h
@@ -0,0 +1,557 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef OUTPUT_ELF_H
+#define OUTPUT_ELF_H
+
+/*
+ * Since NASM support both Elf32/64 file formats
+ * we need to cover all types, structures, typedefs and etc
+ */
+
+#include "compiler.h"
+
+/* Segment types */
+#define PT_NULL		0
+#define PT_LOAD		1
+#define PT_DYNAMIC	2
+#define PT_INTERP	3
+#define PT_NOTE		4
+#define PT_SHLIB	5
+#define PT_PHDR		6
+#define PT_LOOS		0x60000000
+#define PT_HIOS		0x6fffffff
+#define PT_LOPROC	0x70000000
+#define PT_HIPROC	0x7fffffff
+#define PT_GNU_EH_FRAME	0x6474e550	/* Extension, eh? */
+
+/* ELF file types */
+#define ET_NONE		0
+#define ET_REL		1
+#define ET_EXEC		2
+#define ET_DYN		3
+#define ET_CORE		4
+#define ET_LOPROC	0xff00
+#define ET_HIPROC	0xffff
+
+/* ELF machine types */
+#define EM_NONE		0
+#define EM_M32		1
+#define EM_SPARC	2
+#define EM_386		3
+#define EM_68K		4
+#define EM_88K		5
+#define EM_486		6	/* Not used in Linux at least */
+#define EM_860		7
+#define EM_MIPS		8	/* R3k, bigendian(?) */
+#define EM_MIPS_RS4_BE	10	/* R4k BE */
+#define EM_PARISC	15
+#define EM_SPARC32PLUS	18
+#define EM_PPC		20
+#define EM_PPC64	21
+#define EM_S390		22
+#define EM_SH		42
+#define EM_SPARCV9	43	/* v9 = SPARC64 */
+#define EM_H8_300H	47
+#define EM_H8S		48
+#define EM_IA_64	50
+#define EM_X86_64	62
+#define EM_CRIS		76
+#define EM_V850		87
+#define EM_ALPHA	0x9026	/* Interim Alpha that stuck around */
+#define EM_CYGNUS_V850	0x9080	/* Old v850 ID used by Cygnus */
+#define EM_S390_OLD	0xA390	/* Obsolete interim value for S/390 */
+
+/* Dynamic type values */
+#define DT_NULL		0
+#define DT_NEEDED	1
+#define DT_PLTRELSZ	2
+#define DT_PLTGOT	3
+#define DT_HASH		4
+#define DT_STRTAB	5
+#define DT_SYMTAB	6
+#define DT_RELA		7
+#define DT_RELASZ	8
+#define DT_RELAENT	9
+#define DT_STRSZ	10
+#define DT_SYMENT	11
+#define DT_INIT		12
+#define DT_FINI		13
+#define DT_SONAME	14
+#define DT_RPATH	15
+#define DT_SYMBOLIC	16
+#define DT_REL		17
+#define DT_RELSZ	18
+#define DT_RELENT	19
+#define DT_PLTREL	20
+#define DT_DEBUG	21
+#define DT_TEXTREL	22
+#define DT_JMPREL	23
+#define DT_LOPROC	0x70000000
+#define DT_HIPROC	0x7fffffff
+
+/* Auxiliary table entries */
+#define AT_NULL		0	/* end of vector */
+#define AT_IGNORE	1	/* entry should be ignored */
+#define AT_EXECFD	2	/* file descriptor of program */
+#define AT_PHDR		3	/* program headers for program */
+#define AT_PHENT	4	/* size of program header entry */
+#define AT_PHNUM	5	/* number of program headers */
+#define AT_PAGESZ	6	/* system page size */
+#define AT_BASE		7	/* base address of interpreter */
+#define AT_FLAGS	8	/* flags */
+#define AT_ENTRY	9	/* entry point of program */
+#define AT_NOTELF	10	/* program is not ELF */
+#define AT_UID		11	/* real uid */
+#define AT_EUID		12	/* effective uid */
+#define AT_GID		13	/* real gid */
+#define AT_EGID		14	/* effective gid */
+#define AT_PLATFORM	15	/* string identifying CPU for optimizations */
+#define AT_HWCAP	16	/* arch dependent hints at CPU capabilities */
+#define AT_CLKTCK	17	/* frequency at which times() increments */
+/* 18..22 = ? */
+#define AT_SECURE	23	/* secure mode boolean */
+
+/* Program header permission flags */
+#define PF_X		0x1
+#define PF_W		0x2
+#define PF_R		0x4
+
+/* Section header types */
+#define SHT_NULL        0
+#define SHT_PROGBITS    1
+#define SHT_SYMTAB      2
+#define SHT_STRTAB      3
+#define SHT_RELA        4
+#define SHT_HASH        5
+#define SHT_DYNAMIC     6
+#define SHT_NOTE        7
+#define SHT_NOBITS      8
+#define SHT_REL         9
+#define SHT_SHLIB       10
+#define SHT_DYNSYM      11
+#define SHT_INIT_ARRAY	14
+#define SHT_FINI_ARRAY	15
+#define SHT_PREINIT_ARRAY 16
+#define SHT_GROUP	17
+#define SHT_SYMTAB_SHNDX 18
+#define SHT_LOPROC      0x70000000
+#define SHT_HIPROC      0x7fffffff
+#define SHT_LOUSER      0x80000000
+#define SHT_HIUSER      0xffffffff
+
+/* Section header flags */
+#define SHF_WRITE		(1 << 0)	/* Writable */
+#define SHF_ALLOC		(1 << 1)	/* Occupies memory during execution */
+#define SHF_EXECINSTR		(1 << 2)	/* Executable */
+#define SHF_MERGE		(1 << 4)	/* Might be merged */
+#define SHF_STRINGS		(1 << 5)	/* Contains nul-terminated strings */
+#define SHF_INFO_LINK		(1 << 6)	/* `sh_info' contains SHT index */
+#define SHF_LINK_ORDER		(1 << 7)	/* Preserve order after combining */
+#define SHF_OS_NONCONFORMING	(1 << 8)	/* Non-standard OS specific handling required */
+#define SHF_GROUP		(1 << 9)	/* Section is member of a group */
+#define SHF_TLS			(1 << 10)	/* Section hold thread-local data */
+
+/* Special section numbers */
+#define SHN_UNDEF       0x0000
+#define SHN_LORESERVE   0xff00
+#define SHN_LOPROC      0xff00
+#define SHN_HIPROC      0xff1f
+#define SHN_ABS         0xfff1
+#define SHN_COMMON      0xfff2
+#define SHN_XINDEX	0xffff
+#define SHN_HIRESERVE   0xffff
+
+/* Same, but signed/sign-extended */
+#define XSHN_UNDEF      ((int16_t)SHN_UNDEF)
+#define XSHN_LORESERVE  ((int16_t)SHN_LORESERVE)
+#define XSHN_LOPROC     ((int16_t)SHN_LOPROC)
+#define XSHN_HIPROC     ((int16_t)SHN_HIPROC)
+#define XSHN_ABS        ((int16_t)SHN_ABS)
+#define XSHN_COMMON     ((int16_t)SHN_COMMON)
+#define XSHN_XINDEX     ((int16_t)SHN_XINDEX)
+#define XSHN_HIRESERVE  ((int16_t)SHN_HIRESERVE)
+
+/* Section align flag */
+#define SHA_ANY		1	/* No alignment constraint */
+
+/* Length of magic at the start of a file */
+#define EI_NIDENT	16
+
+/* Magic number constants... */
+#define EI_MAG0		0	/* e_ident[] indexes */
+#define EI_MAG1		1
+#define EI_MAG2		2
+#define EI_MAG3		3
+#define EI_CLASS	4
+#define EI_DATA		5
+#define EI_VERSION	6
+#define EI_OSABI	7
+#define EI_ABIVERSION	8
+#define EI_NINDENT	16
+
+#define ELFMAG0		0x7f	/* EI_MAG */
+#define ELFMAG1		'E'
+#define ELFMAG2		'L'
+#define ELFMAG3		'F'
+#define ELFMAG		"\177ELF"
+#define SELFMAG		4
+
+#define ELFCLASSNONE	0	/* EI_CLASS */
+#define ELFCLASS32	1
+#define ELFCLASS64	2
+#define ELFCLASSNUM	3
+
+#define ELFDATANONE	0	/* e_ident[EI_DATA] */
+#define ELFDATA2LSB	1
+#define ELFDATA2MSB	2
+
+#define EV_NONE		0	/* e_version, EI_VERSION */
+#define EV_CURRENT	1
+#define EV_NUM		2
+
+#define ELFOSABI_NONE	0
+#define ELFOSABI_LINUX	3
+
+/* Legal values for ST_BIND subfield of st_info (symbol binding) */
+#define STB_LOCAL	0	/* Local symbol */
+#define STB_GLOBAL	1	/* Global symbol */
+#define STB_WEAK	2	/* Weak symbol */
+#define STB_NUM		3	/* Number of defined types */
+#define STB_LOOS	10	/* Start of OS-specific */
+#define STB_HIOS	12	/* End of OS-specific */
+#define STB_LOPROC	13	/* Start of processor-specific */
+#define STB_HIPROC	15	/* End of processor-specific */
+
+/* Symbol types */
+#define STT_NOTYPE	0	/* Symbol type is unspecified */
+#define STT_OBJECT	1	/* Symbol is a data object */
+#define STT_FUNC	2	/* Symbol is a code object */
+#define STT_SECTION	3	/* Symbol associated with a section */
+#define STT_FILE	4	/* Symbol's name is file name */
+#define STT_COMMON	5	/* Symbol is a common data object */
+#define STT_TLS		6	/* Symbol is thread-local data object */
+#define STT_NUM		7	/* Number of defined types */
+
+/* Symbol visibilities */
+#define STV_DEFAULT	0	/* Default symbol visibility rules */
+#define STV_INTERNAL	1	/* Processor specific hidden class */
+#define STV_HIDDEN	2	/* Sym unavailable in other modules */
+#define STV_PROTECTED	3	/* Not preemptible, not exported */
+
+/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field  */
+#define ELF32_ST_BIND(i)	((i) >> 4)
+#define ELF32_ST_MKBIND(i)	((i) << 4)	/* just a helper */
+#define ELF32_ST_TYPE(i)	((i) & 0xf)
+#define ELF32_ST_INFO(b, i)	(ELF32_ST_MKBIND(b) + ELF32_ST_TYPE(i))
+
+#define ELF64_ST_BIND(i)	ELF32_ST_BIND(i)
+#define ELF64_ST_MKBIND(i)	ELF32_ST_MKBIND(i)
+#define ELF64_ST_TYPE(i)	ELF32_ST_TYPE(i)
+#define ELF64_ST_INFO(b, i)	ELF32_ST_INFO(b, i)
+
+/*
+ * ELF standard typedefs (yet more proof that <stdint.h> was way overdue)
+ */
+
+typedef uint16_t Elf32_Half;
+typedef int16_t Elf32_SHalf;
+typedef uint32_t Elf32_Word;
+typedef int32_t Elf32_Sword;
+typedef uint64_t Elf32_Xword;
+typedef int64_t Elf32_Sxword;
+
+typedef uint32_t Elf32_Off;
+typedef uint32_t Elf32_Addr;
+typedef uint16_t Elf32_Section;
+
+typedef uint16_t Elf64_Half;
+typedef int16_t Elf64_SHalf;
+typedef uint32_t Elf64_Word;
+typedef int32_t Elf64_Sword;
+typedef uint64_t Elf64_Xword;
+typedef int64_t Elf64_Sxword;
+
+typedef uint64_t Elf64_Off;
+typedef uint64_t Elf64_Addr;
+typedef uint16_t Elf64_Section;
+
+/*
+ * Dynamic header
+ */
+
+typedef struct elf32_dyn {
+	Elf32_Sword		d_tag;
+	union {
+		Elf32_Sword	d_val;
+		Elf32_Addr	d_ptr;
+	} d_un;
+} Elf32_Dyn;
+
+typedef struct elf64_dyn {
+	Elf64_Sxword		d_tag;
+	union {
+		Elf64_Xword	d_val;
+		Elf64_Addr	d_ptr;
+	} d_un;
+} Elf64_Dyn;
+
+/*
+ * Relocations
+ */
+
+#define ELF32_R_SYM(x)		((x) >> 8)
+#define ELF32_R_TYPE(x)		((x) & 0xff)
+#define ELF32_R_INFO(s,t)	(((Elf32_Word)(s) << 8) + ELF32_R_TYPE(t))
+
+typedef struct elf32_rel {
+	Elf32_Addr		r_offset;
+	Elf32_Word		r_info;
+} Elf32_Rel;
+
+typedef struct elf32_rela {
+	Elf32_Addr		r_offset;
+	Elf32_Word		r_info;
+	Elf32_Sword		r_addend;
+} Elf32_Rela;
+
+enum reloc32_type {
+	R_386_32		=  1,	/* ordinary absolute relocation */
+	R_386_PC32		=  2,	/* PC-relative relocation */
+	R_386_GOT32		=  3,	/* an offset into GOT */
+	R_386_PLT32		=  4,	/* a PC-relative offset into PLT */
+	R_386_COPY		=  5,	/* ??? */
+	R_386_GLOB_DAT		=  6,	/* ??? */
+	R_386_JUMP_SLOT		=  7,	/* ??? */
+	R_386_RELATIVE		=  8,	/* ??? */
+	R_386_GOTOFF		=  9,	/* an offset from GOT base */
+	R_386_GOTPC		= 10,	/* a PC-relative offset _to_ GOT */
+	R_386_TLS_TPOFF		= 14,	/* Offset in static TLS block */
+	R_386_TLS_IE		= 15,	/* Address of GOT entry for static TLS block offset */
+	/* These are GNU extensions, but useful */
+	R_386_16		= 20,	/* A 16-bit absolute relocation */
+	R_386_PC16		= 21,	/* A 16-bit PC-relative relocation */
+	R_386_8			= 22,	/* An 8-bit absolute relocation */
+	R_386_PC8		= 23,	/* An 8-bit PC-relative relocation */
+        R_386_SEG16		= 45,   /* A 16-bit real-mode segment */
+        R_386_SUB16		= 46,   /* Subtract 16-bit value */
+        R_386_SUB32		= 47    /* Subtract 32-bit value */
+};
+
+#define ELF64_R_SYM(x)		((x) >> 32)
+#define ELF64_R_TYPE(x)		((x) & 0xffffffff)
+#define ELF64_R_INFO(s,t)	(((Elf64_Xword)(s) << 32) + ELF64_R_TYPE(t))
+
+typedef struct elf64_rel {
+	Elf64_Addr	r_offset;
+	Elf64_Xword	r_info;
+} Elf64_Rel;
+
+typedef struct elf64_rela {
+	Elf64_Addr	r_offset;
+	Elf64_Xword	r_info;
+	Elf64_Sxword	r_addend;
+} Elf64_Rela;
+
+enum reloc64_type {
+	R_X86_64_NONE		=  0,	/* No reloc */
+	R_X86_64_64		=  1,	/* Direct 64 bit  */
+	R_X86_64_PC32		=  2,	/* PC relative 32 bit signed */
+	R_X86_64_GOT32		=  3,	/* 32 bit GOT entry */
+	R_X86_64_PLT32		=  4,	/* 32 bit PLT address */
+	R_X86_64_COPY		=  5,	/* Copy symbol at runtime */
+	R_X86_64_GLOB_DAT	=  6,	/* Create GOT entry */
+	R_X86_64_JUMP_SLOT	=  7,	/* Create PLT entry */
+	R_X86_64_RELATIVE	=  8,	/* Adjust by program base */
+	R_X86_64_GOTPCREL	=  9,	/* 32 bit signed PC relative offset to GOT */
+	R_X86_64_32		= 10,	/* Direct 32 bit zero extended */
+	R_X86_64_32S		= 11,	/* Direct 32 bit sign extended */
+	R_X86_64_16		= 12,	/* Direct 16 bit zero extended */
+	R_X86_64_PC16		= 13,	/* 16 bit sign extended pc relative */
+	R_X86_64_8		= 14,	/* Direct 8 bit sign extended  */
+	R_X86_64_PC8		= 15,	/* 8 bit sign extended pc relative */
+	R_X86_64_DTPMOD64	= 16,	/* ID of module containing symbol */
+	R_X86_64_DTPOFF64	= 17,	/* Offset in module's TLS block */
+	R_X86_64_TPOFF64	= 18,	/* Offset in initial TLS block */
+	R_X86_64_TLSGD		= 19,	/* 32 bit signed PC relative offset to two GOT entries for GD symbol */
+	R_X86_64_TLSLD		= 20,	/* 32 bit signed PC relative offset to two GOT entries for LD symbol */
+	R_X86_64_DTPOFF32	= 21,	/* Offset in TLS block */
+	R_X86_64_GOTTPOFF	= 22,	/* 32 bit signed PC relative offset to GOT entry for IE symbol */
+	R_X86_64_TPOFF32	= 23,	/* Offset in initial TLS block */
+	R_X86_64_PC64		= 24,	/* word64 S + A - P */
+	R_X86_64_GOTOFF64	= 25,	/* word64 S + A - GOT */
+	R_X86_64_GOTPC32	= 26,	/* word32 GOT + A - P */
+	R_X86_64_GOT64		= 27,	/* word64 G + A */
+	R_X86_64_GOTPCREL64	= 28,	/* word64 G + GOT - P + A */
+	R_X86_64_GOTPC64	= 29,	/* word64 GOT - P + A */
+	R_X86_64_GOTPLT64	= 30,	/* word64 G + A */
+	R_X86_64_PLTOFF64	= 31,	/* word64 L - GOT + A */
+	R_X86_64_SIZE32		= 32,	/* word32 Z + A */
+	R_X86_64_SIZE64		= 33,	/* word64 Z + A */
+	R_X86_64_GOTPC32_TLSDESC= 34,	/* word32 */
+	R_X86_64_TLSDESC_CALL	= 35,	/* none */
+	R_X86_64_TLSDESC	= 36	/* word64?2 */
+};
+
+/*
+ * Symbol
+ */
+
+typedef struct elf32_sym {
+	Elf32_Word	st_name;
+	Elf32_Addr	st_value;
+	Elf32_Word	st_size;
+	unsigned char	st_info;
+	unsigned char	st_other;
+	Elf32_Half	st_shndx;
+} Elf32_Sym;
+
+typedef struct elf64_sym {
+	Elf64_Word	st_name;
+	unsigned char	st_info;
+	unsigned char	st_other;
+	Elf64_Half	st_shndx;
+	Elf64_Addr	st_value;
+	Elf64_Xword	st_size;
+} Elf64_Sym;
+
+/*
+ * Main file header
+ */
+
+typedef struct elf32_hdr {
+	unsigned char	e_ident[EI_NIDENT];
+	Elf32_Half	e_type;
+	Elf32_Half	e_machine;
+	Elf32_Word	e_version;
+	Elf32_Addr	e_entry;
+	Elf32_Off	e_phoff;
+	Elf32_Off	e_shoff;
+	Elf32_Word	e_flags;
+	Elf32_Half	e_ehsize;
+	Elf32_Half	e_phentsize;
+	Elf32_Half	e_phnum;
+	Elf32_Half	e_shentsize;
+	Elf32_Half	e_shnum;
+	Elf32_Half	e_shstrndx;
+} Elf32_Ehdr;
+
+typedef struct elf64_hdr {
+	unsigned char	e_ident[EI_NIDENT];
+	Elf64_Half	e_type;
+	Elf64_Half	e_machine;
+	Elf64_Word	e_version;
+	Elf64_Addr	e_entry;
+	Elf64_Off	e_phoff;
+	Elf64_Off	e_shoff;
+	Elf64_Word	e_flags;
+	Elf64_Half	e_ehsize;
+	Elf64_Half	e_phentsize;
+	Elf64_Half	e_phnum;
+	Elf64_Half	e_shentsize;
+	Elf64_Half	e_shnum;
+	Elf64_Half	e_shstrndx;
+} Elf64_Ehdr;
+
+/*
+ * Program header
+ */
+
+typedef struct elf32_phdr {
+	Elf32_Word	p_type;
+	Elf32_Off	p_offset;
+	Elf32_Addr	p_vaddr;
+	Elf32_Addr	p_paddr;
+	Elf32_Word	p_filesz;
+	Elf32_Word	p_memsz;
+	Elf32_Word	p_flags;
+	Elf32_Word	p_align;
+} Elf32_Phdr;
+
+typedef struct elf64_phdr {
+	Elf64_Word	p_type;
+	Elf64_Word	p_flags;
+	Elf64_Off	p_offset;
+	Elf64_Addr	p_vaddr;
+	Elf64_Addr	p_paddr;
+	Elf64_Xword	p_filesz;
+	Elf64_Xword	p_memsz;
+	Elf64_Xword	p_align;
+} Elf64_Phdr;
+
+/*
+ * Section header
+ */
+
+typedef struct elf32_shdr {
+	Elf32_Word	sh_name;
+	Elf32_Word	sh_type;
+	Elf32_Word	sh_flags;
+	Elf32_Addr	sh_addr;
+	Elf32_Off	sh_offset;
+	Elf32_Word	sh_size;
+	Elf32_Word	sh_link;
+	Elf32_Word	sh_info;
+	Elf32_Word	sh_addralign;
+	Elf32_Word	sh_entsize;
+} Elf32_Shdr;
+
+typedef struct elf64_shdr {
+	Elf64_Word	sh_name;
+	Elf64_Word	sh_type;
+	Elf64_Xword	sh_flags;
+	Elf64_Addr	sh_addr;
+	Elf64_Off	sh_offset;
+	Elf64_Xword	sh_size;
+	Elf64_Word	sh_link;
+	Elf64_Word	sh_info;
+	Elf64_Xword	sh_addralign;
+	Elf64_Xword	sh_entsize;
+} Elf64_Shdr;
+
+/*
+ * Note header
+ */
+typedef struct elf32_note {
+	Elf32_Word	n_namesz;	/* Name size */
+	Elf32_Word	n_descsz;	/* Content size */
+	Elf32_Word	n_type;		/* Content type */
+} Elf32_Nhdr;
+
+typedef struct elf64_note {
+	Elf64_Word	n_namesz;	/* Name size */
+	Elf64_Word	n_descsz;	/* Content size */
+	Elf64_Word	n_type;		/* Content type */
+} Elf64_Nhdr;
+
+#endif /* OUTPUT_ELF_H */
diff --git a/vere/ext/nasm/output/legacy.c b/vere/ext/nasm/output/legacy.c
new file mode 100644
index 0000000..15d22e9
--- /dev/null
+++ b/vere/ext/nasm/output/legacy.c
@@ -0,0 +1,122 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2016-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * output/legacy.c
+ *
+ * Mangle a struct out_data to match the rather bizarre legacy
+ * backend interface.
+ *
+ * The "data" parameter for the output function points to a "int64_t",
+ * containing the address of the target in question, unless the type is
+ * OUT_RAWDATA, in which case it points to an "uint8_t"
+ * array.
+ *
+ * Exceptions are OUT_RELxADR, which denote an x-byte relocation
+ * which will be a relative jump. For this we need to know the
+ * distance in bytes from the start of the relocated record until
+ * the end of the containing instruction. _This_ is what is stored
+ * in the size part of the parameter, in this case.
+ *
+ * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
+ * and the contents of the "data" parameter is irrelevant.
+ */
+
+#include "nasm.h"
+#include "outlib.h"
+
+void nasm_do_legacy_output(const struct out_data *data)
+{
+    const void *dptr = data->data;
+    enum out_type type = data->type;
+    int32_t tsegment = data->tsegment;
+    int32_t twrt = data->twrt;
+    uint64_t size = data->size;
+
+    switch (data->type) {
+    case OUT_RELADDR:
+        switch (data->size) {
+        case 1:
+            type = OUT_REL1ADR;
+            break;
+        case 2:
+            type = OUT_REL2ADR;
+            break;
+        case 4:
+            type = OUT_REL4ADR;
+            break;
+        case 8:
+            type = OUT_REL8ADR;
+            break;
+        default:
+            panic();
+            break;
+        }
+
+        dptr = &data->toffset;
+        size = data->relbase - data->offset;
+        break;
+
+    case OUT_SEGMENT:
+        type = OUT_ADDRESS;
+        tsegment |= 1;
+        /* fall through */
+
+    case OUT_ADDRESS:
+        dptr = &data->toffset;
+        size = (data->flags & OUT_SIGNED) ? -data->size : data->size;
+        break;
+
+    case OUT_RAWDATA:
+    case OUT_RESERVE:
+        tsegment = twrt = NO_SEG;
+        break;
+
+    case OUT_ZERODATA:
+        tsegment = twrt = NO_SEG;
+        type = OUT_RAWDATA;
+        dptr = zero_buffer;
+        while (size > ZERO_BUF_SIZE) {
+            ofmt->legacy_output(data->segment, dptr, type,
+                                ZERO_BUF_SIZE, tsegment, twrt);
+            size -= ZERO_BUF_SIZE;
+        }
+        break;
+
+    default:
+        panic();
+        break;
+    }
+
+    ofmt->legacy_output(data->segment, dptr, type, size, tsegment, twrt);
+}
diff --git a/vere/ext/nasm/output/macho.h b/vere/ext/nasm/output/macho.h
new file mode 100644
index 0000000..538c531
--- /dev/null
+++ b/vere/ext/nasm/output/macho.h
@@ -0,0 +1,282 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef OUTPUT_MACHO_H
+#define OUTPUT_MACHO_H
+
+#include "compiler.h"
+
+/* Magics */
+#define MH_MAGIC			0xfeedface
+#define MH_MAGIC_64			0xfeedfacf
+
+/* File types */
+#define MH_OBJECT			0x1
+
+/* CPUs */
+#define CPU_ARCH_MASK			0xff000000
+#define CPU_ARCH_ABI64			0x01000000
+#define CPU_TYPE_X86			7
+#define CPU_TYPE_I386			CPU_TYPE_X86
+#define CPU_TYPE_X86_64			(CPU_TYPE_X86 | CPU_ARCH_ABI64)
+
+#define CPU_SUBTYPE_MASK		0xff000000
+#define CPU_SUBTYPE_I386_ALL		3
+
+/* Header flags */
+#define MH_SUBSECTIONS_VIA_SYMBOLS	0x00002000
+
+/* Load commands */
+#define LC_SEGMENT			0x1
+#define LC_SEGMENT_64			0x19
+#define LC_SYMTAB			0x2
+
+/* Symbol type bits */
+#define N_STAB				0xe0
+#define	N_PEXT				0x10
+#define N_TYPE				0x0e
+#define N_EXT				0x01
+
+/* To mask with N_TYPE */
+#define N_UNDF				0x00
+#define N_ABS				0x02
+#define N_INDR				0x0a
+#define N_PBUD				0x0c
+#define N_SECT				0x0e
+
+/* Section ordinals */
+#define NO_SECT				0x00
+#define MAX_SECT			0xff
+
+/* Section bits */
+#define SECTION_TYPE			0x000000ff
+#define SECTION_ATTRIBUTES		0xffffff00
+#define SECTION_ATTRIBUTES_USR		0xff000000
+#define SECTION_ATTRIBUTES_SYS		0x00ffff00
+
+#define S_REGULAR				0x00
+#define S_ZEROFILL				0x01
+#define S_CSTRING_LITERALS			0x02
+#define S_4BYTE_LITERALS			0x03
+#define S_8BYTE_LITERALS			0x04
+#define S_LITERAL_POINTERS			0x05
+#define S_NON_LAZY_SYMBOL_POINTERS		0x06
+#define S_LAZY_SYMBOL_POINTERS			0x07
+#define S_SYMBOL_STUBS				0x08
+#define S_MOD_INIT_FUNC_POINTERS		0x09
+#define S_MOD_TERM_FUNC_POINTERS		0x0a
+#define S_COALESCED				0x0b
+#define S_GB_ZEROFILL				0x0c
+#define S_INTERPOSING				0x0d
+#define S_16BYTE_LITERALS			0x0e
+#define S_DTRACE_DOF				0x0f
+#define S_LAZY_DYLIB_SYMBOL_POINTERS		0x10
+#define S_THREAD_LOCAL_REGULAR			0x11
+#define S_THREAD_LOCAL_ZEROFILL			0x12
+#define S_THREAD_LOCAL_VARIABLES		0x13
+#define S_THREAD_LOCAL_VARIABLE_POINTERS	0x14
+#define S_THREAD_LOCAL_INIT_FUNCTION_POINTERS	0x15
+
+#define S_ATTR_PURE_INSTRUCTIONS		0x80000000
+#define S_ATTR_NO_TOC				0x40000000
+#define S_ATTR_STRIP_STATIC_SYMS		0x20000000
+#define S_ATTR_NO_DEAD_STRIP			0x10000000
+#define S_ATTR_LIVE_SUPPORT			0x08000000
+#define S_ATTR_SELF_MODIFYING_CODE		0x04000000
+#define S_ATTR_DEBUG				0x02000000
+
+#define S_ATTR_SOME_INSTRUCTIONS		0x00000400
+#define S_ATTR_EXT_RELOC			0x00000200
+#define S_ATTR_LOC_RELOC			0x00000100
+#define INDIRECT_SYMBOL_LOCAL			0x80000000
+#define INDIRECT_SYMBOL_ABS			0x40000000
+
+/* Relocation info type */
+#define GENERIC_RELOC_VANILLA		0
+#define GENERIC_RELOC_PAIR		1
+#define GENERIC_RELOC_SECTDIFF		2
+#define GENERIC_RELOC_PB_LA_PTR		3
+#define GENERIC_RELOC_LOCAL_SECTDIFF	4
+#define GENERIC_RELOC_TLV		5
+
+#define X86_64_RELOC_UNSIGNED		0
+#define X86_64_RELOC_SIGNED		1
+#define X86_64_RELOC_BRANCH		2
+#define X86_64_RELOC_GOT_LOAD		3
+#define X86_64_RELOC_GOT		4
+#define X86_64_RELOC_SUBTRACTOR		5
+#define X86_64_RELOC_SIGNED_1		6
+#define X86_64_RELOC_SIGNED_2		7
+#define X86_64_RELOC_SIGNED_4		8
+#define X86_64_RELOC_TLV		9
+
+/* Relocation info */
+#define R_ABS		0
+#define R_SCATTERED	0x80000000
+
+/* VM permission constants */
+#define	VM_PROT_NONE			0x00
+#define VM_PROT_READ			0x01
+#define VM_PROT_WRITE			0x02
+#define VM_PROT_EXECUTE			0x04
+
+typedef struct {
+	uint32_t	magic;
+	uint32_t	cputype;
+	uint32_t	cpusubtype;
+	uint32_t	filetype;
+	uint32_t	ncmds;
+	uint32_t	sizeofcmds;
+	uint32_t	flags;
+} macho_header_t;
+
+typedef struct {
+	uint32_t	magic;
+	uint32_t	cputype;
+	uint32_t	cpusubtype;
+	uint32_t	filetype;
+	uint32_t	ncmds;
+	uint32_t	sizeofcmds;
+	uint32_t	flags;
+	uint32_t	reserved;
+} macho_header_64_t;
+
+typedef struct {
+	uint32_t	cmd;
+	uint32_t	cmdsize;
+} macho_load_command_t;
+
+typedef struct {
+	uint32_t	cmd;
+	uint32_t	cmdsize;
+	char		segname[16];
+	uint32_t	vmaddr;
+	uint32_t	vmsize;
+	uint32_t	fileoff;
+	uint32_t	filesize;
+	uint32_t	maxprot;
+	uint32_t	initprot;
+	uint32_t	nsects;
+	uint32_t	flags;
+} macho_segment_command_t;
+
+typedef struct {
+	uint32_t	cmd;
+	uint32_t	cmdsize;
+	char		segname[16];
+	uint64_t	vmaddr;
+	uint64_t	vmsize;
+	uint64_t	fileoff;
+	uint64_t	filesize;
+	uint32_t	maxprot;
+	uint32_t	initprot;
+	uint32_t	nsects;
+	uint32_t	flags;
+} macho_segment_command_64_t;
+
+typedef struct {
+	char		sectname[16];
+	char		segname[16];
+	uint32_t	addr;
+	uint32_t	size;
+	uint32_t	offset;
+	uint32_t	align;
+	uint32_t	reloff;
+	uint32_t	nreloc;
+	uint32_t	flags;
+	uint32_t	reserved1;
+	uint32_t	reserved2;
+} macho_section_t;
+
+typedef struct {
+	char		sectname[16];
+	char		segname[16];
+	uint64_t	addr;
+	uint64_t	size;
+	uint32_t	offset;
+	uint32_t	align;
+	uint32_t	reloff;
+	uint32_t	nreloc;
+	uint32_t	flags;
+	uint32_t	reserved1;
+	uint32_t	reserved2;
+	uint32_t	reserved3;
+} macho_section_64_t;
+
+typedef struct {
+	uint32_t	cmd;
+	uint32_t	cmdsize;
+	uint32_t	symoff;
+	uint32_t	nsyms;
+	uint32_t	stroff;
+	uint32_t	strsize;
+} macho_symtab_command_t;
+
+typedef struct {
+	int32_t		r_address;
+	union {
+		struct {
+			uint32_t	r_symbolnum:	24,
+					r_pcrel:	1,
+					r_length:	2,
+					r_extern:	1,
+					r_type:		4;
+		} s;
+		uint32_t	r_raw;
+	} u;
+} macho_relocation_info_t;
+
+typedef struct nlist_base {
+	uint32_t	n_strx;
+	uint8_t		n_type;
+	uint8_t		n_sect;
+	uint16_t	n_desc;
+} macho_nlist_base_t;
+
+typedef struct nlist {
+	uint32_t	n_strx;
+	uint8_t		n_type;
+	uint8_t		n_sect;
+	int16_t		n_desc;
+	uint32_t	n_value;
+} macho_nlist_t;
+
+typedef struct {
+	uint32_t	n_strx;
+	uint8_t		n_type;
+	uint8_t		n_sect;
+	uint16_t	n_desc;
+	uint64_t	n_value;
+} macho_nlist_64_t;
+
+#endif /* OUTPUT_MACHO_H */
diff --git a/vere/ext/nasm/output/nulldbg.c b/vere/ext/nasm/output/nulldbg.c
new file mode 100644
index 0000000..93ec3a7
--- /dev/null
+++ b/vere/ext/nasm/output/nulldbg.c
@@ -0,0 +1,96 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2014 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "outlib.h"
+
+void null_debug_init(void)
+{
+}
+
+void null_debug_linenum(const char *filename, int32_t linenumber, int32_t segto)
+{
+	(void)filename;
+	(void)linenumber;
+	(void)segto;
+}
+
+void null_debug_deflabel(char *name, int32_t segment, int64_t offset,
+                         int is_global, char *special)
+{
+	(void)name;
+	(void)segment;
+	(void)offset;
+	(void)is_global;
+	(void)special;
+}
+
+void null_debug_directive(const char *directive, const char *params)
+{
+	(void)directive;
+	(void)params;
+}
+
+void null_debug_typevalue(int32_t type)
+{
+	(void)type;
+}
+
+void null_debug_output(int type, void *param)
+{
+	(void)type;
+	(void)param;
+}
+
+void null_debug_cleanup(void)
+{
+}
+
+const struct dfmt null_debug_form = {
+    "Null",
+    "null",
+    null_debug_init,
+    null_debug_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    null_debug_typevalue,
+    null_debug_output,
+    null_debug_cleanup,
+    NULL                        /* pragma list */
+};
+
+const struct dfmt * const null_debug_arr[2] = { &null_debug_form, NULL };
diff --git a/vere/ext/nasm/output/nullout.c b/vere/ext/nasm/output/nullout.c
new file mode 100644
index 0000000..121fe70
--- /dev/null
+++ b/vere/ext/nasm/output/nullout.c
@@ -0,0 +1,60 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "outlib.h"
+
+enum directive_result
+null_directive(enum directive directive, char *value)
+{
+    (void)directive;
+    (void)value;
+    return DIRR_UNKNOWN;
+}
+
+void null_sectalign(int32_t seg, unsigned int value)
+{
+    (void)seg;
+    (void)value;
+}
+
+void null_reset(void)
+{
+    /* Nothing to do */
+}
+
+int32_t null_segbase(int32_t segment)
+{
+    return segment;
+}
diff --git a/vere/ext/nasm/output/outaout.c b/vere/ext/nasm/output/outaout.c
new file mode 100644
index 0000000..c59c789
--- /dev/null
+++ b/vere/ext/nasm/output/outaout.c
@@ -0,0 +1,923 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2013 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * outaout.c	output routines for the Netwide Assembler to produce
+ *		Linux a.out object files
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "saa.h"
+#include "raa.h"
+#include "stdscan.h"
+#include "eval.h"
+#include "outform.h"
+#include "outlib.h"
+
+#if defined OF_AOUT || defined OF_AOUTB
+
+#define RELTYPE_ABSOLUTE 0x00
+#define RELTYPE_RELATIVE 0x01
+#define RELTYPE_GOTPC    0x01   /* no explicit GOTPC in a.out */
+#define RELTYPE_GOTOFF   0x10
+#define RELTYPE_GOT      0x10   /* distinct from GOTOFF bcos sym not sect */
+#define RELTYPE_PLT      0x21
+#define RELTYPE_SYMFLAG  0x08
+
+struct Reloc {
+    struct Reloc *next;
+    int32_t address;               /* relative to _start_ of section */
+    int32_t symbol;                /* symbol number or -ve section id */
+    int bytes;                  /* 2 or 4 */
+    int reltype;                /* see above */
+};
+
+struct Symbol {
+    int32_t strpos;                /* string table position of name */
+    int type;                   /* symbol type - see flags below */
+    int32_t value;                 /* address, or COMMON variable size */
+    int32_t size;                  /* size for data or function exports */
+    int32_t segment;               /* back-reference used by gsym_reloc */
+    struct Symbol *next;        /* list of globals in each section */
+    struct Symbol *nextfwd;     /* list of unresolved-size symbols */
+    char *name;                 /* for unresolved-size symbols */
+    int32_t symnum;                /* index into symbol table */
+};
+
+/*
+ * Section IDs - used in Reloc.symbol when negative, and in
+ * Symbol.type when positive.
+ */
+#define SECT_ABS 2              /* absolute value */
+#define SECT_TEXT 4             /* text section */
+#define SECT_DATA 6             /* data section */
+#define SECT_BSS 8              /* bss section */
+#define SECT_MASK 0xE           /* mask out any of the above */
+
+/*
+ * More flags used in Symbol.type.
+ */
+#define SYM_GLOBAL 1            /* it's a global symbol */
+#define SYM_DATA 0x100          /* used for shared libs */
+#define SYM_FUNCTION 0x200      /* used for shared libs */
+#define SYM_WITH_SIZE 0x4000    /* not output; internal only */
+
+/*
+ * Bit more explanation of symbol types: SECT_xxx denotes a local
+ * symbol. SECT_xxx|SYM_GLOBAL denotes a global symbol, defined in
+ * this module. Just SYM_GLOBAL, with zero value, denotes an
+ * external symbol referenced in this module. And just SYM_GLOBAL,
+ * but with a non-zero value, declares a C `common' variable, of
+ * size `value'.
+ */
+
+struct Section {
+    struct SAA *data;
+    uint32_t len, size, nrelocs;
+    int32_t index;
+    struct Reloc *head, **tail;
+    struct Symbol *gsyms, *asym;
+};
+
+static struct Section stext, sdata, sbss;
+
+static struct SAA *syms;
+static uint32_t nsyms;
+
+static struct RAA *bsym;
+
+static struct SAA *strs;
+static uint32_t strslen;
+
+static struct Symbol *fwds;
+
+static int bsd;
+static int is_pic;
+
+static void aout_write(void);
+static void aout_write_relocs(struct Reloc *);
+static void aout_write_syms(void);
+static void aout_sect_write(struct Section *, const uint8_t *,
+                            uint32_t);
+static void aout_pad_sections(void);
+static void aout_fixup_relocs(struct Section *);
+
+/*
+ * Special section numbers which are used to define special
+ * symbols, which can be used with WRT to provide PIC relocation
+ * types.
+ */
+static int32_t aout_gotpc_sect, aout_gotoff_sect;
+static int32_t aout_got_sect, aout_plt_sect;
+static int32_t aout_sym_sect;
+
+static void aoutg_init(void)
+{
+    stext.data = saa_init(1L);
+    stext.head = NULL;
+    stext.tail = &stext.head;
+    sdata.data = saa_init(1L);
+    sdata.head = NULL;
+    sdata.tail = &sdata.head;
+    stext.len = stext.size = sdata.len = sdata.size = sbss.len = 0;
+    stext.nrelocs = sdata.nrelocs = 0;
+    stext.gsyms = sdata.gsyms = sbss.gsyms = NULL;
+    stext.index = seg_alloc();
+    sdata.index = seg_alloc();
+    sbss.index = seg_alloc();
+    stext.asym = sdata.asym = sbss.asym = NULL;
+    syms = saa_init((int32_t)sizeof(struct Symbol));
+    nsyms = 0;
+    bsym = raa_init();
+    strs = saa_init(1L);
+    strslen = 0;
+    fwds = NULL;
+}
+
+#ifdef OF_AOUT
+
+static void aout_init(void)
+{
+    bsd = false;
+    aoutg_init();
+
+    aout_gotpc_sect = aout_gotoff_sect = aout_got_sect =
+        aout_plt_sect = aout_sym_sect = NO_SEG;
+}
+
+#endif
+
+#ifdef OF_AOUTB
+
+extern const struct ofmt of_aoutb;
+
+static void aoutb_init(void)
+{
+    bsd = true;
+    aoutg_init();
+
+    is_pic = 0x00;              /* may become 0x40 */
+
+    aout_gotpc_sect = seg_alloc();
+    backend_label("..gotpc", aout_gotpc_sect + 1, 0L);
+    aout_gotoff_sect = seg_alloc();
+    backend_label("..gotoff", aout_gotoff_sect + 1, 0L);
+    aout_got_sect = seg_alloc();
+    backend_label("..got", aout_got_sect + 1, 0L);
+    aout_plt_sect = seg_alloc();
+    backend_label("..plt", aout_plt_sect + 1, 0L);
+    aout_sym_sect = seg_alloc();
+    backend_label("..sym", aout_sym_sect + 1, 0L);
+}
+
+#endif
+
+static void aout_cleanup(void)
+{
+    struct Reloc *r;
+
+    aout_pad_sections();
+    aout_fixup_relocs(&stext);
+    aout_fixup_relocs(&sdata);
+    aout_write();
+    saa_free(stext.data);
+    while (stext.head) {
+        r = stext.head;
+        stext.head = stext.head->next;
+        nasm_free(r);
+    }
+    saa_free(sdata.data);
+    while (sdata.head) {
+        r = sdata.head;
+        sdata.head = sdata.head->next;
+        nasm_free(r);
+    }
+    saa_free(syms);
+    raa_free(bsym);
+    saa_free(strs);
+}
+
+static int32_t aout_section_names(char *name, int *bits)
+{
+    /*
+     * Default to 32 bits.
+     */
+    if (!name) {
+        *bits = 32;
+        return stext.index;
+    }
+
+    if (!strcmp(name, ".text"))
+        return stext.index;
+    else if (!strcmp(name, ".data"))
+        return sdata.index;
+    else if (!strcmp(name, ".bss"))
+        return sbss.index;
+    else
+        return NO_SEG;
+}
+
+static void aout_deflabel(char *name, int32_t segment, int64_t offset,
+                          int is_global, char *special)
+{
+    int pos = strslen + 4;
+    struct Symbol *sym;
+    int special_used = false;
+
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+        /*
+         * This is a NASM special symbol. We never allow it into
+         * the a.out symbol table, even if it's a valid one. If it
+         * _isn't_ a valid one, we should barf immediately.
+         */
+        if (strcmp(name, "..gotpc") && strcmp(name, "..gotoff") &&
+            strcmp(name, "..got") && strcmp(name, "..plt") &&
+            strcmp(name, "..sym"))
+            nasm_nonfatal("unrecognised special symbol `%s'", name);
+        return;
+    }
+
+    if (is_global == 3) {
+        struct Symbol **s;
+        /*
+         * Fix up a forward-reference symbol size from the first
+         * pass.
+         */
+        for (s = &fwds; *s; s = &(*s)->nextfwd)
+            if (!strcmp((*s)->name, name)) {
+                struct tokenval tokval;
+                expr *e;
+                char *p = special;
+
+                p = nasm_skip_spaces(nasm_skip_word(p));
+                stdscan_reset();
+                stdscan_set(p);
+                tokval.t_type = TOKEN_INVALID;
+                e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
+                if (e) {
+                    if (!is_simple(e))
+                        nasm_nonfatal("cannot use relocatable"
+                                      " expression as symbol size");
+                    else
+                        (*s)->size = reloc_value(e);
+                }
+
+                /*
+                 * Remove it from the list of unresolved sizes.
+                 */
+                nasm_free((*s)->name);
+                *s = (*s)->nextfwd;
+                return;
+            }
+        return;                 /* it wasn't an important one */
+    }
+
+    saa_wbytes(strs, name, (int32_t)(1 + strlen(name)));
+    strslen += 1 + strlen(name);
+
+    sym = saa_wstruct(syms);
+
+    sym->strpos = pos;
+    sym->type = is_global ? SYM_GLOBAL : 0;
+    sym->segment = segment;
+    if (segment == NO_SEG)
+        sym->type |= SECT_ABS;
+    else if (segment == stext.index) {
+        sym->type |= SECT_TEXT;
+        if (is_global) {
+            sym->next = stext.gsyms;
+            stext.gsyms = sym;
+        } else if (!stext.asym)
+            stext.asym = sym;
+    } else if (segment == sdata.index) {
+        sym->type |= SECT_DATA;
+        if (is_global) {
+            sym->next = sdata.gsyms;
+            sdata.gsyms = sym;
+        } else if (!sdata.asym)
+            sdata.asym = sym;
+    } else if (segment == sbss.index) {
+        sym->type |= SECT_BSS;
+        if (is_global) {
+            sym->next = sbss.gsyms;
+            sbss.gsyms = sym;
+        } else if (!sbss.asym)
+            sbss.asym = sym;
+    } else
+        sym->type = SYM_GLOBAL;
+    if (is_global == 2)
+        sym->value = offset;
+    else
+        sym->value = (sym->type == SYM_GLOBAL ? 0 : offset);
+
+    if (is_global && sym->type != SYM_GLOBAL) {
+        /*
+         * Global symbol exported _from_ this module. We must check
+         * the special text for type information.
+         */
+
+        if (special) {
+            int n = strcspn(special, " ");
+
+            if (!nasm_strnicmp(special, "function", n))
+                sym->type |= SYM_FUNCTION;
+            else if (!nasm_strnicmp(special, "data", n) ||
+                     !nasm_strnicmp(special, "object", n))
+                sym->type |= SYM_DATA;
+            else
+                nasm_nonfatal("unrecognised symbol type `%.*s'",
+                              n, special);
+            if (special[n]) {
+                struct tokenval tokval;
+                expr *e;
+                int fwd = false;
+                char *saveme = stdscan_get();
+
+                if (!bsd) {
+                    nasm_nonfatal("Linux a.out does not support"
+                                  " symbol size information");
+                } else {
+                    while (special[n] && nasm_isspace(special[n]))
+                        n++;
+                    /*
+                     * We have a size expression; attempt to
+                     * evaluate it.
+                     */
+                    sym->type |= SYM_WITH_SIZE;
+                    stdscan_reset();
+                    stdscan_set(special + n);
+                    tokval.t_type = TOKEN_INVALID;
+                    e = evaluate(stdscan, NULL, &tokval, &fwd, 0, NULL);
+                    if (fwd) {
+                        sym->nextfwd = fwds;
+                        fwds = sym;
+                        sym->name = nasm_strdup(name);
+                    } else if (e) {
+                        if (!is_simple(e))
+                            nasm_nonfatal("cannot use relocatable"
+                                          " expression as symbol size");
+                        else
+                            sym->size = reloc_value(e);
+                    }
+                }
+                stdscan_set(saveme);
+            }
+            special_used = true;
+        }
+    }
+
+    /*
+     * define the references from external-symbol segment numbers
+     * to these symbol records.
+     */
+    if (segment != NO_SEG && segment != stext.index &&
+        segment != sdata.index && segment != sbss.index)
+        bsym = raa_write(bsym, segment, nsyms);
+    sym->symnum = nsyms;
+
+    nsyms++;
+    if (sym->type & SYM_WITH_SIZE)
+        nsyms++;                /* and another for the size */
+
+    if (special && !special_used)
+        nasm_nonfatal("no special symbol features supported here");
+}
+
+static void aout_add_reloc(struct Section *sect, int32_t segment,
+                           int reltype, int bytes)
+{
+    struct Reloc *r;
+
+    r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
+    sect->tail = &r->next;
+    r->next = NULL;
+
+    r->address = sect->len;
+    r->symbol = (segment == NO_SEG ? -SECT_ABS :
+                 segment == stext.index ? -SECT_TEXT :
+                 segment == sdata.index ? -SECT_DATA :
+                 segment == sbss.index ? -SECT_BSS :
+                 raa_read(bsym, segment));
+    r->reltype = reltype;
+    if (r->symbol >= 0)
+        r->reltype |= RELTYPE_SYMFLAG;
+    r->bytes = bytes;
+
+    sect->nrelocs++;
+}
+
+/*
+ * This routine deals with ..got and ..sym relocations: the more
+ * complicated kinds. In shared-library writing, some relocations
+ * with respect to global symbols must refer to the precise symbol
+ * rather than referring to an offset from the base of the section
+ * _containing_ the symbol. Such relocations call to this routine,
+ * which searches the symbol list for the symbol in question.
+ *
+ * RELTYPE_GOT references require the _exact_ symbol address to be
+ * used; RELTYPE_ABSOLUTE references can be at an offset from the
+ * symbol. The boolean argument `exact' tells us this.
+ *
+ * Return value is the adjusted value of `addr', having become an
+ * offset from the symbol rather than the section. Should always be
+ * zero when returning from an exact call.
+ *
+ * Limitation: if you define two symbols at the same place,
+ * confusion will occur.
+ *
+ * Inefficiency: we search, currently, using a linked list which
+ * isn't even necessarily sorted.
+ */
+static int32_t aout_add_gsym_reloc(struct Section *sect,
+                                int32_t segment, int32_t offset,
+                                int type, int bytes, int exact)
+{
+    struct Symbol *sym, *sm, *shead;
+    struct Reloc *r;
+
+    /*
+     * First look up the segment to find whether it's text, data,
+     * bss or an external symbol.
+     */
+    shead = NULL;
+    if (segment == stext.index)
+        shead = stext.gsyms;
+    else if (segment == sdata.index)
+        shead = sdata.gsyms;
+    else if (segment == sbss.index)
+        shead = sbss.gsyms;
+    if (!shead) {
+        if (exact && offset != 0)
+            nasm_nonfatal("unable to find a suitable global symbol"
+                          " for this reference");
+        else
+            aout_add_reloc(sect, segment, type, bytes);
+        return offset;
+    }
+
+    if (exact) {
+        /*
+         * Find a symbol pointing _exactly_ at this one.
+         */
+        list_for_each(sym, shead)
+            if (sym->value == offset)
+                break;
+    } else {
+        /*
+         * Find the nearest symbol below this one.
+         */
+        sym = NULL;
+        list_for_each(sm, shead)
+            if (sm->value <= offset && (!sym || sm->value > sym->value))
+                sym = sm;
+    }
+    if (!sym && exact) {
+        nasm_nonfatal("unable to find a suitable global symbol"
+                      " for this reference");
+        return 0;
+    }
+
+    r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
+    sect->tail = &r->next;
+    r->next = NULL;
+
+    r->address = sect->len;
+    r->symbol = sym->symnum;
+    r->reltype = type | RELTYPE_SYMFLAG;
+    r->bytes = bytes;
+
+    sect->nrelocs++;
+
+    return offset - sym->value;
+}
+
+/*
+ * This routine deals with ..gotoff relocations. These _must_ refer
+ * to a symbol, due to a perversity of *BSD's PIC implementation,
+ * and it must be a non-global one as well; so we store `asym', the
+ * first nonglobal symbol defined in each section, and always work
+ * from that. Relocation type is always RELTYPE_GOTOFF.
+ *
+ * Return value is the adjusted value of `addr', having become an
+ * offset from the `asym' symbol rather than the section.
+ */
+static int32_t aout_add_gotoff_reloc(struct Section *sect, int32_t segment,
+                                  int32_t offset, int bytes)
+{
+    struct Reloc *r;
+    struct Symbol *asym;
+
+    /*
+     * First look up the segment to find whether it's text, data,
+     * bss or an external symbol.
+     */
+    asym = NULL;
+    if (segment == stext.index)
+        asym = stext.asym;
+    else if (segment == sdata.index)
+        asym = sdata.asym;
+    else if (segment == sbss.index)
+        asym = sbss.asym;
+    if (!asym)
+        nasm_nonfatal("`..gotoff' relocations require a non-global"
+                      " symbol in the section");
+
+    r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
+    sect->tail = &r->next;
+    r->next = NULL;
+
+    r->address = sect->len;
+    r->symbol = asym->symnum;
+    r->reltype = RELTYPE_GOTOFF;
+    r->bytes = bytes;
+
+    sect->nrelocs++;
+
+    return offset - asym->value;
+}
+
+static void aout_out(int32_t segto, const void *data,
+		     enum out_type type, uint64_t size,
+                     int32_t segment, int32_t wrt)
+{
+    struct Section *s;
+    int32_t addr;
+    uint8_t mydata[4], *p;
+
+    if (segto == stext.index)
+        s = &stext;
+    else if (segto == sdata.index)
+        s = &sdata;
+    else if (segto == sbss.index)
+        s = NULL;
+    else {
+        nasm_warn(WARN_OTHER, "attempt to assemble code in"
+                  " segment %d: defaulting to `.text'", segto);
+        s = &stext;
+    }
+
+    if (!s && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in the"
+                  " BSS section: ignored");
+        sbss.len += realsize(type, size);
+        return;
+    }
+
+    memset(mydata, 0, sizeof(mydata));
+
+    if (type == OUT_RESERVE) {
+        if (s) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+                      " %s section: zeroing",
+                      (segto == stext.index ? "code" : "data"));
+            aout_sect_write(s, NULL, size);
+        } else
+            sbss.len += size;
+    } else if (type == OUT_RAWDATA) {
+        aout_sect_write(s, data, size);
+    } else if (type == OUT_ADDRESS) {
+        int asize = abs((int)size);
+        addr = *(int64_t *)data;
+        if (segment != NO_SEG) {
+            if (segment % 2) {
+                nasm_nonfatal("a.out format does not support"
+                              " segment base references");
+            } else {
+                if (wrt == NO_SEG) {
+                    aout_add_reloc(s, segment, RELTYPE_ABSOLUTE, asize);
+                } else if (!bsd) {
+                    nasm_nonfatal("Linux a.out format does not support"
+                                  " any use of WRT");
+                    wrt = NO_SEG;       /* we can at least _try_ to continue */
+                } else if (wrt == aout_gotpc_sect + 1) {
+                    is_pic = 0x40;
+                    aout_add_reloc(s, segment, RELTYPE_GOTPC, asize);
+                } else if (wrt == aout_gotoff_sect + 1) {
+                    is_pic = 0x40;
+                    addr = aout_add_gotoff_reloc(s, segment, addr, asize);
+                } else if (wrt == aout_got_sect + 1) {
+                    is_pic = 0x40;
+                    addr = aout_add_gsym_reloc(s, segment, addr, RELTYPE_GOT,
+                                               asize, true);
+                } else if (wrt == aout_sym_sect + 1) {
+                    addr = aout_add_gsym_reloc(s, segment, addr,
+                                               RELTYPE_ABSOLUTE, asize,
+                                               false);
+                } else if (wrt == aout_plt_sect + 1) {
+                    is_pic = 0x40;
+                    nasm_nonfatal("a.out format cannot produce non-PC-"
+                                  "relative PLT references");
+                } else {
+                    nasm_nonfatal("a.out format does not support this"
+                                  " use of WRT");
+                    wrt = NO_SEG;       /* we can at least _try_ to continue */
+                }
+            }
+        }
+        p = mydata;
+        if (asize == 2)
+            WRITESHORT(p, addr);
+        else
+            WRITELONG(p, addr);
+        aout_sect_write(s, mydata, asize);
+    } else if (type == OUT_REL2ADR) {
+        if (segment != NO_SEG && segment % 2) {
+            nasm_nonfatal("a.out format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                aout_add_reloc(s, segment, RELTYPE_RELATIVE, 2);
+            } else if (!bsd) {
+                nasm_nonfatal("Linux a.out format does not support"
+                              " any use of WRT");
+                wrt = NO_SEG;   /* we can at least _try_ to continue */
+            } else if (wrt == aout_plt_sect + 1) {
+                is_pic = 0x40;
+                aout_add_reloc(s, segment, RELTYPE_PLT, 2);
+            } else if (wrt == aout_gotpc_sect + 1 ||
+                       wrt == aout_gotoff_sect + 1 ||
+                       wrt == aout_got_sect + 1) {
+                nasm_nonfatal("a.out format cannot produce PC-"
+                              "relative GOT references");
+            } else {
+                nasm_nonfatal("a.out format does not support this"
+                              " use of WRT");
+                wrt = NO_SEG;   /* we can at least _try_ to continue */
+            }
+        }
+        p = mydata;
+        WRITESHORT(p, *(int64_t *)data - (size + s->len));
+        aout_sect_write(s, mydata, 2L);
+    } else if (type == OUT_REL4ADR) {
+        if (segment != NO_SEG && segment % 2) {
+            nasm_nonfatal("a.out format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                aout_add_reloc(s, segment, RELTYPE_RELATIVE, 4);
+            } else if (!bsd) {
+                nasm_nonfatal("Linux a.out format does not support"
+                              " any use of WRT");
+                wrt = NO_SEG;   /* we can at least _try_ to continue */
+            } else if (wrt == aout_plt_sect + 1) {
+                is_pic = 0x40;
+                aout_add_reloc(s, segment, RELTYPE_PLT, 4);
+            } else if (wrt == aout_gotpc_sect + 1 ||
+                       wrt == aout_gotoff_sect + 1 ||
+                       wrt == aout_got_sect + 1) {
+                nasm_nonfatal("a.out format cannot produce PC-"
+                              "relative GOT references");
+            } else {
+                nasm_nonfatal("a.out format does not support this"
+                              " use of WRT");
+                wrt = NO_SEG;   /* we can at least _try_ to continue */
+            }
+        }
+        p = mydata;
+        WRITELONG(p, *(int64_t *)data - (size + s->len));
+        aout_sect_write(s, mydata, 4L);
+    }
+}
+
+static void aout_pad_sections(void)
+{
+    static uint8_t pad[] = { 0x90, 0x90, 0x90, 0x90 };
+    /*
+     * Pad each of the text and data sections with NOPs until their
+     * length is a multiple of four. (NOP == 0x90.) Also increase
+     * the length of the BSS section similarly.
+     */
+    aout_sect_write(&stext, pad, (-(int32_t)stext.len) & 3);
+    aout_sect_write(&sdata, pad, (-(int32_t)sdata.len) & 3);
+    sbss.len = ALIGN(sbss.len, 4);
+}
+
+/*
+ * a.out files have the curious property that all references to
+ * things in the data or bss sections are done by addresses which
+ * are actually relative to the start of the _text_ section, in the
+ * _file_. (No relation to what happens after linking. No idea why
+ * this should be so. It's very strange.) So we have to go through
+ * the relocation table, _after_ the final size of each section is
+ * known, and fix up the relocations pointed to.
+ */
+static void aout_fixup_relocs(struct Section *sect)
+{
+    struct Reloc *r;
+
+    saa_rewind(sect->data);
+    list_for_each(r, sect->head) {
+        uint8_t *p, *q, blk[4];
+        int32_t l;
+
+        saa_fread(sect->data, r->address, blk, (int32_t)r->bytes);
+        p = q = blk;
+        l = *p++;
+        if (r->bytes > 1) {
+            l += ((int32_t)*p++) << 8;
+            if (r->bytes == 4) {
+                l += ((int32_t)*p++) << 16;
+                l += ((int32_t)*p++) << 24;
+            }
+        }
+        if (r->symbol == -SECT_DATA)
+            l += stext.len;
+        else if (r->symbol == -SECT_BSS)
+            l += stext.len + sdata.len;
+        if (r->bytes == 4)
+            WRITELONG(q, l);
+        else if (r->bytes == 2)
+            WRITESHORT(q, l);
+        else
+            *q++ = l & 0xFF;
+        saa_fwrite(sect->data, r->address, blk, (int32_t)r->bytes);
+    }
+}
+
+static void aout_write(void)
+{
+    /*
+     * Emit the a.out header.
+     */
+    /* OMAGIC, M_386 or MID_I386, no flags */
+    fwriteint32_t(bsd ? 0x07018600 | is_pic : 0x640107L, ofile);
+    fwriteint32_t(stext.len, ofile);
+    fwriteint32_t(sdata.len, ofile);
+    fwriteint32_t(sbss.len, ofile);
+    fwriteint32_t(nsyms * 12, ofile);     /* length of symbol table */
+    fwriteint32_t(0L, ofile);     /* object files have no entry point */
+    fwriteint32_t(stext.nrelocs * 8, ofile);      /* size of text relocs */
+    fwriteint32_t(sdata.nrelocs * 8, ofile);      /* size of data relocs */
+
+    /*
+     * Write out the code section and the data section.
+     */
+    saa_fpwrite(stext.data, ofile);
+    saa_fpwrite(sdata.data, ofile);
+
+    /*
+     * Write out the relocations.
+     */
+    aout_write_relocs(stext.head);
+    aout_write_relocs(sdata.head);
+
+    /*
+     * Write the symbol table.
+     */
+    aout_write_syms();
+
+    /*
+     * And the string table.
+     */
+    fwriteint32_t(strslen + 4, ofile);    /* length includes length count */
+    saa_fpwrite(strs, ofile);
+}
+
+static void aout_write_relocs(struct Reloc *r)
+{
+    list_for_each(r, r) {
+        uint32_t word2;
+
+        fwriteint32_t(r->address, ofile);
+
+        if (r->symbol >= 0)
+            word2 = r->symbol;
+        else
+            word2 = -r->symbol;
+        word2 |= r->reltype << 24;
+        word2 |= (r->bytes == 1 ? 0 :
+                  r->bytes == 2 ? 0x2000000L : 0x4000000L);
+        fwriteint32_t(word2, ofile);
+    }
+}
+
+static void aout_write_syms(void)
+{
+    uint32_t i;
+
+    saa_rewind(syms);
+    for (i = 0; i < nsyms; i++) {
+        struct Symbol *sym = saa_rstruct(syms);
+        fwriteint32_t(sym->strpos, ofile);
+        fwriteint32_t((int32_t)sym->type & ~SYM_WITH_SIZE, ofile);
+        /*
+         * Fix up the symbol value now we know the final section
+         * sizes.
+         */
+        if ((sym->type & SECT_MASK) == SECT_DATA)
+            sym->value += stext.len;
+        if ((sym->type & SECT_MASK) == SECT_BSS)
+            sym->value += stext.len + sdata.len;
+        fwriteint32_t(sym->value, ofile);
+        /*
+         * Output a size record if necessary.
+         */
+        if (sym->type & SYM_WITH_SIZE) {
+            fwriteint32_t(sym->strpos, ofile);
+            fwriteint32_t(0x0DL, ofile);  /* special value: means size */
+            fwriteint32_t(sym->size, ofile);
+            i++;                /* use up another of `nsyms' */
+        }
+    }
+}
+
+static void aout_sect_write(struct Section *sect,
+                            const uint8_t *data, uint32_t len)
+{
+    saa_wbytes(sect->data, data, len);
+    sect->len += len;
+}
+
+extern macros_t aout_stdmac[];
+
+#endif                          /* OF_AOUT || OF_AOUTB */
+
+#ifdef OF_AOUT
+
+const struct ofmt of_aout = {
+    "Linux a.out",
+    "aout",
+    ".o",
+    0,
+    32,
+    null_debug_arr,
+    &null_debug_form,
+    aout_stdmac,
+    aout_init,
+    null_reset,
+    nasm_do_legacy_output,
+    aout_out,
+    aout_deflabel,
+    aout_section_names,
+    NULL,
+    null_sectalign,
+    null_segbase,
+    null_directive,
+    aout_cleanup,
+    NULL                        /* pragma list */
+};
+
+#endif
+
+#ifdef OF_AOUTB
+
+const struct ofmt of_aoutb = {
+    "NetBSD/FreeBSD a.out",
+    "aoutb",
+    ".o",
+    0,
+    32,
+    null_debug_arr,
+    &null_debug_form,
+    aout_stdmac,
+    aoutb_init,
+    null_reset,
+    nasm_do_legacy_output,
+    aout_out,
+    aout_deflabel,
+    aout_section_names,
+    NULL,
+    null_sectalign,
+    null_segbase,
+    null_directive,
+    aout_cleanup,
+    NULL                        /* pragma list */
+};
+
+#endif
diff --git a/vere/ext/nasm/output/outaout.mac b/vere/ext/nasm/output/outaout.mac
new file mode 100644
index 0000000..5b7b366
--- /dev/null
+++ b/vere/ext/nasm/output/outaout.mac
@@ -0,0 +1,37 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: aout aoutb
+%define __?SECT?__ [section .text]
+%macro __?NASM_CDecl?__ 1
+%endmacro
diff --git a/vere/ext/nasm/output/outas86.c b/vere/ext/nasm/output/outas86.c
new file mode 100644
index 0000000..54b22f8
--- /dev/null
+++ b/vere/ext/nasm/output/outas86.c
@@ -0,0 +1,611 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/* 
+ * outas86.c	output routines for the Netwide Assembler to produce
+ *		Linux as86 (bin86-0.3) object files
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "saa.h"
+#include "raa.h"
+#include "outform.h"
+#include "outlib.h"
+
+#ifdef OF_AS86
+
+struct Piece {
+    struct Piece *next;
+    int type;                   /* 0 = absolute, 1 = seg, 2 = sym */
+    int32_t offset;		/* relative offset */
+    int number;			/* symbol/segment number (4=bss) */
+    int32_t bytes;	        /* size of reloc or of absolute data */
+    bool relative;		/* relative address? */
+};
+
+struct Symbol {
+    int32_t strpos;		/* string table position of name */
+    int flags;                  /* symbol flags */
+    int segment;                /* 4=bss at this point */
+    int32_t value;		/* address, or COMMON variable size */
+};
+
+/*
+ * Section IDs - used in Piece.number and Symbol.segment.
+ */
+#define SECT_TEXT 0             /* text section */
+#define SECT_DATA 3             /* data section */
+#define SECT_BSS 4              /* bss section */
+
+/*
+ * Flags used in Symbol.flags.
+ */
+#define SYM_ENTRY (1<<8)
+#define SYM_EXPORT (1<<7)
+#define SYM_IMPORT (1<<6)
+#define SYM_ABSOLUTE (1<<4)
+
+struct Section {
+    struct SAA *data;
+    uint32_t datalen, size, len;
+    int32_t index;
+    struct Piece *head, *last, **tail;
+};
+
+static struct Section stext, sdata;
+static uint32_t bsslen;
+static int32_t bssindex;
+
+static struct SAA *syms;
+static uint32_t nsyms;
+
+static struct RAA *bsym;
+
+static struct SAA *strs;
+static size_t strslen;
+
+static int as86_reloc_size;
+
+static void as86_write(void);
+static void as86_write_section(struct Section *, int);
+static size_t as86_add_string(const char *name);
+static void as86_sect_write(struct Section *, const uint8_t *,
+                            uint32_t);
+
+static void as86_init(void)
+{
+    stext.data = saa_init(1L);
+    stext.datalen = 0L;
+    stext.head = stext.last = NULL;
+    stext.tail = &stext.head;
+    sdata.data = saa_init(1L);
+    sdata.datalen = 0L;
+    sdata.head = sdata.last = NULL;
+    sdata.tail = &sdata.head;
+    bsslen =
+        stext.len = stext.datalen = stext.size =
+        sdata.len = sdata.datalen = sdata.size = 0;
+    stext.index = seg_alloc();
+    sdata.index = seg_alloc();
+    bssindex = seg_alloc();
+    syms = saa_init((int32_t)sizeof(struct Symbol));
+    nsyms = 0;
+    bsym = raa_init();
+    strs = saa_init(1L);
+    strslen = 0;
+
+    /* as86 module name = input file minus extension */
+    as86_add_string(filename_set_extension(inname, ""));
+}
+
+static void as86_cleanup(void)
+{
+    struct Piece *p;
+
+    as86_write();
+    saa_free(stext.data);
+    while (stext.head) {
+        p = stext.head;
+        stext.head = stext.head->next;
+        nasm_free(p);
+    }
+    saa_free(sdata.data);
+    while (sdata.head) {
+        p = sdata.head;
+        sdata.head = sdata.head->next;
+        nasm_free(p);
+    }
+    saa_free(syms);
+    raa_free(bsym);
+    saa_free(strs);
+}
+
+static int32_t as86_section_names(char *name, int *bits)
+{
+    /*
+     * Default is 16 bits.
+     */
+    if (!name) {
+        *bits = 16;
+        return stext.index;
+    }
+
+    if (!strcmp(name, ".text"))
+        return stext.index;
+    else if (!strcmp(name, ".data"))
+        return sdata.index;
+    else if (!strcmp(name, ".bss"))
+        return bssindex;
+    else
+        return NO_SEG;
+}
+
+static size_t as86_add_string(const char *name)
+{
+    size_t pos = strslen;
+    size_t length = strlen(name);
+
+    saa_wbytes(strs, name, length + 1);
+    strslen += 1 + length;
+
+    return pos;
+}
+
+static void as86_deflabel(char *name, int32_t segment, int64_t offset,
+                          int is_global, char *special)
+{
+    bool is_start = false;
+    struct Symbol *sym;
+
+    if (special)
+        nasm_nonfatal("as86 format does not support any"
+                      " special symbol types");
+
+
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+	if (strcmp(name, "..start")) {
+	    nasm_nonfatal("unrecognised special symbol `%s'", name);
+	    return;
+	} else {
+	    is_start = true;
+	}
+    }
+
+    sym = saa_wstruct(syms);
+
+    sym->strpos = as86_add_string(name);
+    sym->flags = 0;
+
+    if (is_start)
+      sym->flags = SYM_ENTRY;
+
+    if (segment == NO_SEG)
+        sym->flags |= SYM_ABSOLUTE, sym->segment = 0;
+    else if (segment == stext.index)
+        sym->segment = SECT_TEXT;
+    else if (segment == sdata.index)
+        sym->segment = SECT_DATA;
+    else if (segment == bssindex)
+        sym->segment = SECT_BSS;
+    else {
+        sym->flags |= SYM_IMPORT;
+        sym->segment = 15;
+    }
+
+    if (is_global == 2)
+        sym->segment = 3;       /* already have IMPORT */
+
+    if (is_global && !(sym->flags & SYM_IMPORT))
+        sym->flags |= SYM_EXPORT;
+
+    sym->value = offset;
+
+    /*
+     * define the references from external-symbol segment numbers
+     * to these symbol records.
+     */
+    if (segment != NO_SEG && segment != stext.index &&
+        segment != sdata.index && segment != bssindex)
+        bsym = raa_write(bsym, segment, nsyms);
+
+    nsyms++;
+}
+
+static void as86_add_piece(struct Section *sect, int type, int32_t offset,
+                           int32_t segment, int32_t bytes, int relative)
+{
+    struct Piece *p;
+
+    sect->len += bytes;
+
+    if (type == 0 && sect->last && sect->last->type == 0) {
+        sect->last->bytes += bytes;
+        return;
+    }
+
+    p = sect->last = *sect->tail = nasm_malloc(sizeof(struct Piece));
+    sect->tail = &p->next;
+    p->next = NULL;
+
+    p->type = type;
+    p->offset = offset;
+    p->bytes = bytes;
+    p->relative = relative;
+
+    if (type == 1 && segment == stext.index)
+        p->number = SECT_TEXT;
+    else if (type == 1 && segment == sdata.index)
+        p->number = SECT_DATA;
+    else if (type == 1 && segment == bssindex)
+        p->number = SECT_BSS;
+    else if (type == 1)
+        p->number = raa_read(bsym, segment), p->type = 2;
+}
+
+static void as86_out(int32_t segto, const void *data,
+		     enum out_type type, uint64_t size,
+                     int32_t segment, int32_t wrt)
+{
+    struct Section *s;
+    int32_t offset;
+    uint8_t mydata[4], *p;
+
+    if (wrt != NO_SEG) {
+        wrt = NO_SEG;           /* continue to do _something_ */
+        nasm_nonfatal("WRT not supported by as86 output format");
+    }
+
+    if (segto == stext.index)
+        s = &stext;
+    else if (segto == sdata.index)
+        s = &sdata;
+    else if (segto == bssindex)
+        s = NULL;
+    else {
+        nasm_warn(WARN_OTHER, "attempt to assemble code in"
+                  " segment %d: defaulting to `.text'", segto);
+        s = &stext;
+    }
+
+    if (!s && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in the"
+                  " BSS section: ignored");
+	bsslen += realsize(type, size);
+        return;
+    }
+
+    memset(mydata, 0, sizeof(mydata));
+
+    if (type == OUT_RESERVE) {
+        if (s) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+                      " %s section: zeroing",
+                      (segto == stext.index ? "code" : "data"));
+            as86_sect_write(s, NULL, size);
+            as86_add_piece(s, 0, 0L, 0L, size, 0);
+        } else
+            bsslen += size;
+    } else if (type == OUT_RAWDATA) {
+        as86_sect_write(s, data, size);
+        as86_add_piece(s, 0, 0L, 0L, size, 0);
+    } else if (type == OUT_ADDRESS) {
+        int asize = abs((int)size);
+        if (segment != NO_SEG) {
+            if (segment % 2) {
+                nasm_nonfatal("as86 format does not support"
+                              " segment base references");
+            } else {
+                offset = *(int64_t *)data;
+                as86_add_piece(s, 1, offset, segment, asize, 0);
+            }
+        } else {
+            p = mydata;
+            WRITELONG(p, *(int64_t *)data);
+            as86_sect_write(s, data, asize);
+            as86_add_piece(s, 0, 0L, 0L, asize, 0);
+        }
+    } else if (type == OUT_REL2ADR) {
+        if (segment != NO_SEG) {
+            if (segment % 2) {
+                nasm_nonfatal("as86 format does not support"
+                              " segment base references");
+            } else {
+                offset = *(int64_t *)data;
+                as86_add_piece(s, 1, offset - size + 2, segment, 2L,
+                               1);
+            }
+        }
+    } else if (type == OUT_REL4ADR) {
+        if (segment != NO_SEG) {
+            if (segment % 2) {
+                nasm_nonfatal("as86 format does not support"
+                              " segment base references");
+            } else {
+                offset = *(int64_t *)data;
+                as86_add_piece(s, 1, offset - size + 4, segment, 4L,
+                               1);
+            }
+        }
+    }
+}
+
+static void as86_write(void)
+{
+    uint32_t i;
+    int32_t symlen, seglen, segsize;
+
+    /*
+     * First, go through the symbol records working out how big
+     * each will be. Also fix up BSS references at this time, and
+     * set the flags words up completely.
+     */
+    symlen = 0;
+    saa_rewind(syms);
+    for (i = 0; i < nsyms; i++) {
+        struct Symbol *sym = saa_rstruct(syms);
+        if (sym->segment == SECT_BSS)
+            sym->segment = SECT_DATA, sym->value += sdata.len;
+        sym->flags |= sym->segment;
+        if (sym->value == 0)
+            sym->flags |= 0 << 14, symlen += 4;
+        else if (sym->value >= 0 && sym->value <= 255)
+            sym->flags |= 1 << 14, symlen += 5;
+        else if (sym->value >= 0 && sym->value <= 65535L)
+            sym->flags |= 2 << 14, symlen += 6;
+        else
+            sym->flags |= 3 << 14, symlen += 8;
+    }
+
+    /*
+     * Now do the same for the segments, and get the segment size
+     * descriptor word at the same time.
+     */
+    seglen = segsize = 0;
+    if ((uint32_t)stext.len > 65535L)
+        segsize |= 0x03000000L, seglen += 4;
+    else
+        segsize |= 0x02000000L, seglen += 2;
+    if ((uint32_t)sdata.len > 65535L)
+        segsize |= 0xC0000000L, seglen += 4;
+    else
+        segsize |= 0x80000000L, seglen += 2;
+
+    /*
+     * Emit the as86 header.
+     */
+    fwriteint32_t(0x000186A3L, ofile);
+    fputc(0x2A, ofile);
+    fwriteint32_t(27 + symlen + seglen + strslen, ofile); /* header length */
+    fwriteint32_t(stext.len + sdata.len + bsslen, ofile);
+    fwriteint16_t(strslen, ofile);
+    fwriteint16_t(0, ofile);     /* class = revision = 0 */
+    fwriteint32_t(0x55555555L, ofile);    /* segment max sizes: always this */
+    fwriteint32_t(segsize, ofile);        /* segment size descriptors */
+    if (segsize & 0x01000000L)
+        fwriteint32_t(stext.len, ofile);
+    else
+        fwriteint16_t(stext.len, ofile);
+    if (segsize & 0x40000000L)
+        fwriteint32_t(sdata.len + bsslen, ofile);
+    else
+        fwriteint16_t(sdata.len + bsslen, ofile);
+    fwriteint16_t(nsyms, ofile);
+
+    /*
+     * Write the symbol table.
+     */
+    saa_rewind(syms);
+    for (i = 0; i < nsyms; i++) {
+        struct Symbol *sym = saa_rstruct(syms);
+        fwriteint16_t(sym->strpos, ofile);
+        fwriteint16_t(sym->flags, ofile);
+        switch (sym->flags & (3 << 14)) {
+        case 0 << 14:
+            break;
+        case 1 << 14:
+            fputc(sym->value, ofile);
+            break;
+        case 2 << 14:
+            fwriteint16_t(sym->value, ofile);
+            break;
+        case 3 << 14:
+            fwriteint32_t(sym->value, ofile);
+            break;
+        }
+    }
+
+    /*
+     * Write out the string table.
+     */
+    saa_fpwrite(strs, ofile);
+
+    /*
+     * Write the program text.
+     */
+    as86_reloc_size = -1;
+    as86_write_section(&stext, SECT_TEXT);
+    as86_write_section(&sdata, SECT_DATA);
+    /*
+     * Append the BSS section to the .data section
+     */
+    if (bsslen > 65535L) {
+        fputc(0x13, ofile);
+        fwriteint32_t(bsslen, ofile);
+    } else if (bsslen > 255) {
+        fputc(0x12, ofile);
+        fwriteint16_t(bsslen, ofile);
+    } else if (bsslen) {
+        fputc(0x11, ofile);
+        fputc(bsslen, ofile);
+    }
+
+    fputc(0, ofile);           /* termination */
+}
+
+static void as86_set_rsize(int size)
+{
+    if (as86_reloc_size != size) {
+        switch (as86_reloc_size = size) {
+        case 1:
+            fputc(0x01, ofile);
+            break;
+        case 2:
+            fputc(0x02, ofile);
+            break;
+        case 4:
+            fputc(0x03, ofile);
+            break;
+        default:
+            nasm_panic("bizarre relocation size %d", size);
+	    break;
+        }
+    }
+}
+
+static void as86_write_section(struct Section *sect, int index)
+{
+    struct Piece *p;
+    uint32_t s;
+    int32_t length;
+
+    fputc(0x20 + index, ofile);        /* select the right section */
+
+    saa_rewind(sect->data);
+
+    for (p = sect->head; p; p = p->next)
+        switch (p->type) {
+        case 0:
+            /*
+             * Absolute data. Emit it in chunks of at most 64
+             * bytes.
+             */
+            length = p->bytes;
+            do {
+                char buf[64];
+                int32_t tmplen = (length > 64 ? 64 : length);
+                fputc(0x40 | (tmplen & 0x3F), ofile);
+                saa_rnbytes(sect->data, buf, tmplen);
+                nasm_write(buf, tmplen, ofile);
+                length -= tmplen;
+            } while (length > 0);
+            break;
+        case 1:
+            /*
+             * A segment-type relocation. First fix up the BSS.
+             */
+            if (p->number == SECT_BSS)
+                p->number = SECT_DATA, p->offset += sdata.len;
+            as86_set_rsize(p->bytes);
+            fputc(0x80 | (p->relative ? 0x20 : 0) | p->number, ofile);
+            if (as86_reloc_size == 2)
+                fwriteint16_t(p->offset, ofile);
+            else
+                fwriteint32_t(p->offset, ofile);
+            break;
+        case 2:
+            /*
+             * A symbol-type relocation.
+             */
+            as86_set_rsize(p->bytes);
+            s = p->offset;
+            if (s > 65535L)
+                s = 3;
+            else if (s > 255)
+                s = 2;
+            else if (s > 0)
+                s = 1;
+            else
+                s = 0;
+            fputc(0xC0 |
+                  (p->relative ? 0x20 : 0) |
+                  (p->number > 255 ? 0x04 : 0) | s, ofile);
+            if (p->number > 255)
+                fwriteint16_t(p->number, ofile);
+            else
+                fputc(p->number, ofile);
+            switch (s) {
+            case 0:
+                break;
+            case 1:
+                fputc(p->offset, ofile);
+                break;
+            case 2:
+                fwriteint16_t(p->offset, ofile);
+                break;
+            case 3:
+                fwriteint32_t(p->offset, ofile);
+                break;
+            }
+            break;
+        }
+}
+
+static void as86_sect_write(struct Section *sect,
+                            const uint8_t *data, uint32_t len)
+{
+    saa_wbytes(sect->data, data, len);
+    sect->datalen += len;
+}
+
+extern macros_t as86_stdmac[];
+
+const struct ofmt of_as86 = {
+    "as86 (bin86/dev86 toolchain)",
+    "as86",
+    ".o",
+    0,
+    32,
+    null_debug_arr,
+    &null_debug_form,
+    as86_stdmac,
+    as86_init,
+    null_reset,
+    nasm_do_legacy_output,
+    as86_out,
+    as86_deflabel,
+    as86_section_names,
+    NULL,
+    null_sectalign,
+    null_segbase,
+    null_directive,
+    as86_cleanup,
+    NULL                        /* pragma list */
+};
+
+#endif                          /* OF_AS86 */
diff --git a/vere/ext/nasm/output/outas86.mac b/vere/ext/nasm/output/outas86.mac
new file mode 100644
index 0000000..f7c9a48
--- /dev/null
+++ b/vere/ext/nasm/output/outas86.mac
@@ -0,0 +1,37 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: as86
+%define __?SECT?__ [section .text]
+%macro __?NASM_CDecl?__ 1
+%endmacro
diff --git a/vere/ext/nasm/output/outbin.c b/vere/ext/nasm/output/outbin.c
new file mode 100644
index 0000000..1522e5c
--- /dev/null
+++ b/vere/ext/nasm/output/outbin.c
@@ -0,0 +1,1669 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outbin.c output routines for the Netwide Assembler to produce
+ *    flat-form binary files
+ */
+
+/* This is the extended version of NASM's original binary output
+ * format.  It is backward compatible with the original BIN format,
+ * and contains support for multiple sections and advanced section
+ * ordering.
+ *
+ * Feature summary:
+ *
+ * - Users can create an arbitrary number of sections; they are not
+ *   limited to just ".text", ".data", and ".bss".
+ *
+ * - Sections can be either progbits or nobits type.
+ *
+ * - You can specify that they be aligned at a certain boundary
+ *   following the previous section ("align="), or positioned at an
+ *   arbitrary byte-granular location ("start=").
+ *
+ * - You can specify a "virtual" start address for a section, which
+ *   will be used for the calculation for all address references
+ *   with respect to that section ("vstart=").
+ *
+ * - The ORG directive, as well as the section/segment directive
+ *   arguments ("align=", "start=", "vstart="), can take a critical
+ *   expression as their value.  For example: "align=(1 << 12)".
+ *
+ * - You can generate map files using the 'map' directive.
+ *
+ */
+
+/* Uncomment the following define if you want sections to adapt
+ * their progbits/nobits state depending on what type of
+ * instructions are issued, rather than defaulting to progbits.
+ * Note that this behavior violates the specification.
+
+#define ABIN_SMART_ADAPT
+
+*/
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "saa.h"
+#include "stdscan.h"
+#include "labels.h"
+#include "eval.h"
+#include "outform.h"
+#include "outlib.h"
+
+#ifdef OF_BIN
+
+static FILE *rf = NULL;
+static void (*do_output)(void);
+
+/* Section flags keep track of which attributes the user has defined. */
+#define START_DEFINED       0x001
+#define ALIGN_DEFINED       0x002
+#define FOLLOWS_DEFINED     0x004
+#define VSTART_DEFINED      0x008
+#define VALIGN_DEFINED      0x010
+#define VFOLLOWS_DEFINED    0x020
+#define TYPE_DEFINED        0x040
+#define TYPE_PROGBITS       0x080
+#define TYPE_NOBITS         0x100
+
+/* This struct is used to keep track of symbols for map-file generation. */
+static struct bin_label {
+    char *name;
+    struct bin_label *next;
+} *no_seg_labels, **nsl_tail;
+
+static struct Section {
+    char *name;
+    struct SAA *contents;
+    int64_t length;                /* section length in bytes */
+
+/* Section attributes */
+    int flags;                  /* see flag definitions above */
+    uint64_t align;        /* section alignment */
+    uint64_t valign;       /* notional section alignment */
+    uint64_t start;        /* section start address */
+    uint64_t vstart;       /* section virtual start address */
+    char *follows;              /* the section that this one will follow */
+    char *vfollows;             /* the section that this one will notionally follow */
+    int32_t start_index;           /* NASM section id for non-relocated version */
+    int32_t vstart_index;          /* the NASM section id */
+
+    struct bin_label *labels;   /* linked-list of label handles for map output. */
+    struct bin_label **labels_end;      /* Holds address of end of labels list. */
+    struct Section *prev;       /* Points to previous section (implicit follows). */
+    struct Section *next;       /* This links sections with a defined start address. */
+
+/* The extended bin format allows for sections to have a "virtual"
+ * start address.  This is accomplished by creating two sections:
+ * one beginning at the Load Memory Address and the other beginning
+ * at the Virtual Memory Address.  The LMA section is only used to
+ * define the section.<section_name>.start label, but there isn't
+ * any other good way for us to handle that label.
+ */
+
+} *sections, *last_section;
+
+static struct Reloc {
+    struct Reloc *next;
+    int32_t posn;
+    int32_t bytes;
+    int32_t secref;
+    int32_t secrel;
+    struct Section *target;
+} *relocs, **reloctail;
+
+static uint64_t origin;
+static int origin_defined;
+
+/* Stuff we need for map-file generation. */
+#define MAP_ORIGIN       1
+#define MAP_SUMMARY      2
+#define MAP_SECTIONS     4
+#define MAP_SYMBOLS      8
+static int map_control = 0;
+
+extern macros_t bin_stdmac[];
+
+static void add_reloc(struct Section *s, int32_t bytes, int32_t secref,
+                      int32_t secrel)
+{
+    struct Reloc *r;
+
+    r = *reloctail = nasm_malloc(sizeof(struct Reloc));
+    reloctail = &r->next;
+    r->next = NULL;
+    r->posn = s->length;
+    r->bytes = bytes;
+    r->secref = secref;
+    r->secrel = secrel;
+    r->target = s;
+}
+
+static struct Section *find_section_by_name(const char *name)
+{
+    struct Section *s;
+
+    list_for_each(s, sections)
+        if (!strcmp(s->name, name))
+            break;
+    return s;
+}
+
+static struct Section *find_section_by_index(int32_t index)
+{
+    struct Section *s;
+
+    list_for_each(s, sections)
+        if ((index == s->vstart_index) || (index == s->start_index))
+            break;
+    return s;
+}
+
+static struct Section *create_section(char *name)
+{
+    struct Section *s = nasm_zalloc(sizeof(*s));
+
+    s->prev         = last_section;
+    s->name         = nasm_strdup(name);
+    s->labels_end   = &(s->labels);
+    s->contents     = saa_init(1L);
+
+    /* Register our sections with NASM. */
+    s->vstart_index = seg_alloc();
+    s->start_index  = seg_alloc();
+
+    /* FIXME: Append to a tail, we need some helper */
+    last_section->next = s;
+    last_section = s;
+
+    return last_section;
+}
+
+static void bin_cleanup(void)
+{
+    struct Section *g, **gp;
+    struct Section *gs = NULL, **gsp;
+    struct Section *s, **sp;
+    struct Section *nobits = NULL, **nt;
+    struct Section *last_progbits;
+    struct bin_label *l;
+    struct Reloc *r;
+    uint64_t pend;
+    int h;
+
+    if (debug_level(1)) {
+        nasm_debug("bin_cleanup: Sections were initially referenced in this order:\n");
+        for (h = 0, s = sections; s; h++, s = s->next)
+            nasm_debug("%i. %s\n", h, s->name);
+    }
+
+    /* Assembly has completed, so now we need to generate the output file.
+     * Step 1: Separate progbits and nobits sections into separate lists.
+     * Step 2: Sort the progbits sections into their output order.
+     * Step 3: Compute start addresses for all progbits sections.
+     * Step 4: Compute vstart addresses for all sections.
+     * Step 5: Apply relocations.
+     * Step 6: Write the sections' data to the output file.
+     * Step 7: Generate the map file.
+     * Step 8: Release all allocated memory.
+     */
+
+    /* To do: Smart section-type adaptation could leave some empty sections
+     * without a defined type (progbits/nobits).  Won't fix now since this
+     * feature will be disabled.  */
+
+    /* Step 1: Split progbits and nobits sections into separate lists. */
+
+    nt = &nobits;
+    /* Move nobits sections into a separate list.  Also pre-process nobits
+     * sections' attributes. */
+    for (sp = &sections->next, s = sections->next; s; s = *sp) {        /* Skip progbits sections. */
+        if (s->flags & TYPE_PROGBITS) {
+            sp = &s->next;
+            continue;
+        }
+        /* Do some special pre-processing on nobits sections' attributes. */
+        if (s->flags & (START_DEFINED | ALIGN_DEFINED | FOLLOWS_DEFINED)) {     /* Check for a mixture of real and virtual section attributes. */
+            if (s->flags & (VSTART_DEFINED | VALIGN_DEFINED |
+			    VFOLLOWS_DEFINED))
+                nasm_fatal("cannot mix real and virtual attributes"
+                           " in nobits section (%s)", s->name);
+            /* Real and virtual attributes mean the same thing for nobits sections. */
+            if (s->flags & START_DEFINED) {
+                s->vstart = s->start;
+                s->flags |= VSTART_DEFINED;
+            }
+            if (s->flags & ALIGN_DEFINED) {
+                s->valign = s->align;
+                s->flags |= VALIGN_DEFINED;
+            }
+            if (s->flags & FOLLOWS_DEFINED) {
+                s->vfollows = s->follows;
+                s->flags |= VFOLLOWS_DEFINED;
+                s->flags &= ~FOLLOWS_DEFINED;
+            }
+        }
+        /* Every section must have a start address. */
+        if (s->flags & VSTART_DEFINED) {
+            s->start = s->vstart;
+            s->flags |= START_DEFINED;
+        }
+        /* Move the section into the nobits list. */
+        *sp = s->next;
+        s->next = NULL;
+        *nt = s;
+        nt = &s->next;
+    }
+
+    /* Step 2: Sort the progbits sections into their output order. */
+
+    /* In Step 2 we move around sections in groups.  A group
+     * begins with a section (group leader) that has a user-
+     * defined start address or follows section.  The remainder
+     * of the group is made up of the sections that implicitly
+     * follow the group leader (i.e., they were defined after
+     * the group leader and were not given an explicit start
+     * address or follows section by the user). */
+
+    /* For anyone attempting to read this code:
+     * g (group) points to a group of sections, the first one of which has
+     *   a user-defined start address or follows section.
+     * gp (g previous) holds the location of the pointer to g.
+     * gs (g scan) is a temp variable that we use to scan to the end of the group.
+     * gsp (gs previous) holds the location of the pointer to gs.
+     * nt (nobits tail) points to the nobits section-list tail.
+     */
+
+    /* Link all 'follows' groups to their proper position.  To do
+     * this we need to know three things: the start of the group
+     * to relocate (g), the section it is following (s), and the
+     * end of the group we're relocating (gs). */
+    for (gp = &sections, g = sections; g; g = gs) {     /* Find the next follows group that is out of place (g). */
+        if (!(g->flags & FOLLOWS_DEFINED)) {
+            while (g->next) {
+                if ((g->next->flags & FOLLOWS_DEFINED) &&
+                    strcmp(g->name, g->next->follows))
+                    break;
+                g = g->next;
+            }
+            if (!g->next)
+                break;
+            gp = &g->next;
+            g = g->next;
+        }
+        /* Find the section that this group follows (s). */
+        for (sp = &sections, s = sections;
+             s && strcmp(s->name, g->follows);
+             sp = &s->next, s = s->next) ;
+        if (!s)
+            nasm_fatal("section %s follows an invalid or"
+                  " unknown section (%s)", g->name, g->follows);
+        if (s == g)
+            nasm_fatal("section %s is self following", s->name);
+        if (s->next && (s->next->flags & FOLLOWS_DEFINED) &&
+            !strcmp(s->name, s->next->follows))
+            nasm_fatal("sections %s and %s can't both follow"
+                  " section %s", g->name, s->next->name, s->name);
+        /* Find the end of the current follows group (gs). */
+        for (gsp = &g->next, gs = g->next;
+             gs && (gs != s) && !(gs->flags & START_DEFINED);
+             gsp = &gs->next, gs = gs->next) {
+            if (gs->next && (gs->next->flags & FOLLOWS_DEFINED) &&
+                strcmp(gs->name, gs->next->follows)) {
+                gsp = &gs->next;
+                gs = gs->next;
+                break;
+            }
+        }
+        /* Re-link the group after its follows section. */
+        *gsp = s->next;
+        s->next = g;
+        *gp = gs;
+    }
+
+    /* Link all 'start' groups to their proper position.  Once
+     * again we need to know g, s, and gs (see above).  The main
+     * difference is we already know g since we sort by moving
+     * groups from the 'unsorted' list into a 'sorted' list (g
+     * will always be the first section in the unsorted list). */
+    for (g = sections, sections = NULL; g; g = gs) {    /* Find the section that we will insert this group before (s). */
+        for (sp = &sections, s = sections; s; sp = &s->next, s = s->next)
+            if ((s->flags & START_DEFINED) && (g->start < s->start))
+                break;
+        /* Find the end of the group (gs). */
+        for (gs = g->next, gsp = &g->next;
+             gs && !(gs->flags & START_DEFINED);
+             gsp = &gs->next, gs = gs->next) ;
+        /* Re-link the group before the target section. */
+        *sp = g;
+        *gsp = s;
+    }
+
+    /* Step 3: Compute start addresses for all progbits sections. */
+
+    /* Make sure we have an origin and a start address for the first section. */
+    if (origin_defined) {
+	if (sections->flags & START_DEFINED) {
+            /* Make sure this section doesn't begin before the origin. */
+            if (sections->start < origin)
+                nasm_fatal("section %s begins"
+                      " before program origin", sections->name);
+	} else if (sections->flags & ALIGN_DEFINED) {
+            sections->start = ALIGN(origin, sections->align);
+	} else {
+            sections->start = origin;
+	}
+    } else {
+        if (!(sections->flags & START_DEFINED))
+            sections->start = 0;
+        origin = sections->start;
+    }
+    sections->flags |= START_DEFINED;
+
+    /* Make sure each section has an explicit start address.  If it
+     * doesn't, then compute one based its alignment and the end of
+     * the previous section. */
+    for (pend = sections->start, g = s = sections; g; g = g->next) {    /* Find the next section that could cause an overlap situation
+                                                                         * (has a defined start address, and is not zero length). */
+        if (g == s)
+            for (s = g->next;
+                 s && ((s->length == 0) || !(s->flags & START_DEFINED));
+                 s = s->next) ;
+        /* Compute the start address of this section, if necessary. */
+        if (!(g->flags & START_DEFINED)) {      /* Default to an alignment of 4 if unspecified. */
+            if (!(g->flags & ALIGN_DEFINED)) {
+                g->align = 4;
+                g->flags |= ALIGN_DEFINED;
+            }
+            /* Set the section start address. */
+            g->start = ALIGN(pend, g->align);
+            g->flags |= START_DEFINED;
+        }
+        /* Ugly special case for progbits sections' virtual attributes:
+         *   If there is a defined valign, but no vstart and no vfollows, then
+         *   we valign after the previous progbits section.  This case doesn't
+         *   really make much sense for progbits sections with a defined start
+         *   address, but it is possible and we must do *something*.
+         * Not-so-ugly special case:
+         *   If a progbits section has no virtual attributes, we set the
+         *   vstart equal to the start address.  */
+        if (!(g->flags & (VSTART_DEFINED | VFOLLOWS_DEFINED))) {
+            if (g->flags & VALIGN_DEFINED)
+                g->vstart = ALIGN(pend, g->valign);
+            else
+                g->vstart = g->start;
+            g->flags |= VSTART_DEFINED;
+        }
+        /* Ignore zero-length sections. */
+        if (g->start < pend)
+            continue;
+        /* Compute the span of this section. */
+        pend = g->start + g->length;
+        /* Check for section overlap. */
+        if (s) {
+	    if (s->start < origin)
+		nasm_fatal("section %s beings before program origin",
+		      s->name);
+	    if (g->start > s->start)
+                nasm_fatal("sections %s ~ %s and %s overlap!",
+                      gs->name, g->name, s->name);
+            if (pend > s->start)
+                nasm_fatal("sections %s and %s overlap!",
+                      g->name, s->name);
+        }
+        /* Remember this section as the latest >0 length section. */
+        gs = g;
+    }
+
+    /* Step 4: Compute vstart addresses for all sections. */
+
+    /* Attach the nobits sections to the end of the progbits sections. */
+    for (s = sections; s->next; s = s->next) ;
+    s->next = nobits;
+    last_progbits = s;
+    /*
+     * Scan for sections that don't have a vstart address.  If we find
+     * one we'll attempt to compute its vstart.  If we can't compute
+     * the vstart, we leave it alone and come back to it in a
+     * subsequent scan.  We continue scanning and re-scanning until
+     * we've gone one full cycle without computing any vstarts.
+     */
+    do {                        /* Do one full scan of the sections list. */
+        for (h = 0, g = sections; g; g = g->next) {
+            if (g->flags & VSTART_DEFINED)
+                continue;
+            /* Find the section that this one virtually follows.  */
+            if (g->flags & VFOLLOWS_DEFINED) {
+                for (s = sections; s && strcmp(g->vfollows, s->name);
+                     s = s->next) ;
+                if (!s)
+                    nasm_fatal("section %s vfollows unknown section (%s)",
+                               g->name, g->vfollows);
+            } else if (g->prev != NULL)
+                for (s = sections; s && (s != g->prev); s = s->next) ;
+            /* The .bss section is the only one with prev = NULL.
+	       In this case we implicitly follow the last progbits
+	       section.  */
+            else
+                s = last_progbits;
+
+            /* If the section we're following has a vstart, we can proceed. */
+            if (s->flags & VSTART_DEFINED) {    /* Default to virtual alignment of four. */
+                if (!(g->flags & VALIGN_DEFINED)) {
+                    g->valign = 4;
+                    g->flags |= VALIGN_DEFINED;
+                }
+                /* Compute the vstart address. */
+                g->vstart = ALIGN(s->vstart + s->length, g->valign);
+                g->flags |= VSTART_DEFINED;
+                h++;
+                /* Start and vstart mean the same thing for nobits sections. */
+                if (g->flags & TYPE_NOBITS)
+                    g->start = g->vstart;
+            }
+        }
+    } while (h);
+
+    /* Now check for any circular vfollows references, which will manifest
+     * themselves as sections without a defined vstart. */
+    for (h = 0, s = sections; s; s = s->next) {
+        if (!(s->flags & VSTART_DEFINED)) {     /* Non-fatal errors after assembly has completed are generally a
+                                                 * no-no, but we'll throw a fatal one eventually so it's ok.  */
+            nasm_nonfatal("cannot compute vstart for section %s", s->name);
+            h++;
+        }
+    }
+    if (h)
+        nasm_fatal("circular vfollows path detected");
+
+    if (debug_level(1)) {
+        nasm_debug("bin_cleanup: Confirm final section order for output file:\n");
+        for (h = 0, s = sections; s && (s->flags & TYPE_PROGBITS);
+             h++, s = s->next)
+            nasm_debug("%i. %s\n", h, s->name);
+    }
+
+    /* Step 5: Apply relocations. */
+
+    /* Prepare the sections for relocating. */
+    list_for_each(s, sections)
+        saa_rewind(s->contents);
+    /* Apply relocations. */
+    list_for_each(r, relocs) {
+        uint8_t *p, mydata[8];
+        int64_t l;
+        int b;
+
+        nasm_assert(r->bytes <= 8);
+
+        memset(mydata, 0, sizeof(mydata));
+
+        saa_fread(r->target->contents, r->posn, mydata, r->bytes);
+        p = mydata;
+        l = 0;
+        for (b = r->bytes - 1; b >= 0; b--)
+            l = (l << 8) + mydata[b];
+
+        s = find_section_by_index(r->secref);
+        if (s) {
+            if (r->secref == s->start_index)
+                l += s->start;
+            else
+                l += s->vstart;
+        }
+        s = find_section_by_index(r->secrel);
+        if (s) {
+            if (r->secrel == s->start_index)
+                l -= s->start;
+            else
+                l -= s->vstart;
+        }
+
+        WRITEADDR(p, l, r->bytes);
+        saa_fwrite(r->target->contents, r->posn, mydata, r->bytes);
+    }
+
+    /* Step 6: Write the section data to the output file. */
+    do_output();
+
+    /* Step 7: Generate the map file. */
+
+    if (map_control) {
+        static const char not_defined[] = "not defined";
+
+        /* Display input and output file names. */
+        fprintf(rf, "\n- NASM Map file ");
+        for (h = 63; h; h--)
+            fputc('-', rf);
+        fprintf(rf, "\n\nSource file:  %s\nOutput file:  %s\n\n",
+                inname, outname);
+
+        if (map_control & MAP_ORIGIN) { /* Display program origin. */
+            fprintf(rf, "-- Program origin ");
+            for (h = 61; h; h--)
+                fputc('-', rf);
+            fprintf(rf, "\n\n%08"PRIX64"\n\n", origin);
+        }
+        /* Display sections summary. */
+        if (map_control & MAP_SUMMARY) {
+            fprintf(rf, "-- Sections (summary) ");
+            for (h = 57; h; h--)
+                fputc('-', rf);
+            fprintf(rf, "\n\nVstart            Start             Stop              "
+                    "Length    Class     Name\n");
+            list_for_each(s, sections) {
+                fprintf(rf, "%16"PRIX64"  %16"PRIX64"  %16"PRIX64"  %08"PRIX64"  ",
+                        s->vstart, s->start, s->start + s->length,
+                        s->length);
+                if (s->flags & TYPE_PROGBITS)
+                    fprintf(rf, "progbits  ");
+                else
+                    fprintf(rf, "nobits    ");
+                fprintf(rf, "%s\n", s->name);
+            }
+            fprintf(rf, "\n");
+        }
+        /* Display detailed section information. */
+        if (map_control & MAP_SECTIONS) {
+            fprintf(rf, "-- Sections (detailed) ");
+            for (h = 56; h; h--)
+                fputc('-', rf);
+            fprintf(rf, "\n\n");
+            list_for_each(s, sections) {
+                fprintf(rf, "---- Section %s ", s->name);
+                if (strlen(s->name) < 65)
+                for (h = 65 - strlen(s->name); h; h--)
+                    fputc('-', rf);
+                fprintf(rf, "\n\nclass:     ");
+                if (s->flags & TYPE_PROGBITS)
+                    fprintf(rf, "progbits");
+                else
+                    fprintf(rf, "nobits");
+                fprintf(rf, "\nlength:    %16"PRIX64"\nstart:     %16"PRIX64""
+                        "\nalign:     ", s->length, s->start);
+                if (s->flags & ALIGN_DEFINED)
+                    fprintf(rf, "%16"PRIX64"", s->align);
+                else
+                    fputs(not_defined, rf);
+                fprintf(rf, "\nfollows:   ");
+                if (s->flags & FOLLOWS_DEFINED)
+                    fprintf(rf, "%s", s->follows);
+                else
+                    fputs(not_defined, rf);
+                fprintf(rf, "\nvstart:    %16"PRIX64"\nvalign:    ", s->vstart);
+                if (s->flags & VALIGN_DEFINED)
+                    fprintf(rf, "%16"PRIX64"", s->valign);
+                else
+                    fputs(not_defined, rf);
+                fprintf(rf, "\nvfollows:  ");
+                if (s->flags & VFOLLOWS_DEFINED)
+                    fprintf(rf, "%s", s->vfollows);
+                else
+                    fputs(not_defined, rf);
+                fprintf(rf, "\n\n");
+            }
+        }
+        /* Display symbols information. */
+        if (map_control & MAP_SYMBOLS) {
+            int32_t segment;
+            int64_t offset;
+            enum label_type found_label;
+
+            fprintf(rf, "-- Symbols ");
+            for (h = 68; h; h--)
+                fputc('-', rf);
+            fprintf(rf, "\n\n");
+            if (no_seg_labels) {
+                fprintf(rf, "---- No Section ");
+                for (h = 63; h; h--)
+                    fputc('-', rf);
+                fprintf(rf, "\n\nValue     Name\n");
+                list_for_each(l, no_seg_labels) {
+                    found_label = lookup_label(l->name, &segment, &offset);
+                    nasm_assert(found_label != LBL_none);
+                    fprintf(rf, "%08"PRIX64"  %s\n", offset, l->name);
+                }
+                fprintf(rf, "\n\n");
+            }
+            list_for_each(s, sections) {
+                if (s->labels) {
+                    fprintf(rf, "---- Section %s ", s->name);
+                    for (h = 65 - strlen(s->name); h; h--)
+                        fputc('-', rf);
+                    fprintf(rf, "\n\nReal              Virtual           Name\n");
+                    list_for_each(l, s->labels) {
+                        found_label = lookup_label(l->name, &segment, &offset);
+                        nasm_assert(found_label != LBL_none);
+                        fprintf(rf, "%16"PRIX64"  %16"PRIX64"  %s\n",
+                                s->start + offset, s->vstart + offset,
+                                l->name);
+                    }
+                    fprintf(rf, "\n");
+                }
+            }
+        }
+    }
+
+    /* Close the report file. */
+    if (map_control && (rf != stdout) && (rf != stderr))
+        fclose(rf);
+
+    /* Step 8: Release all allocated memory. */
+
+    /* Free sections, label pointer structs, etc.. */
+    while (sections) {
+        s = sections;
+        sections = s->next;
+        saa_free(s->contents);
+        nasm_free(s->name);
+        if (s->flags & FOLLOWS_DEFINED)
+            nasm_free(s->follows);
+        if (s->flags & VFOLLOWS_DEFINED)
+            nasm_free(s->vfollows);
+        while (s->labels) {
+            l = s->labels;
+            s->labels = l->next;
+            nasm_free(l);
+        }
+        nasm_free(s);
+    }
+
+    /* Free no-section labels. */
+    while (no_seg_labels) {
+        l = no_seg_labels;
+        no_seg_labels = l->next;
+        nasm_free(l);
+    }
+
+    /* Free relocation structures. */
+    while (relocs) {
+        r = relocs->next;
+        nasm_free(relocs);
+        relocs = r;
+    }
+}
+
+static void bin_out(int32_t segto, const void *data,
+		    enum out_type type, uint64_t size,
+                    int32_t segment, int32_t wrt)
+{
+    uint8_t *p, mydata[8];
+    struct Section *s;
+
+    if (wrt != NO_SEG) {
+        wrt = NO_SEG;           /* continue to do _something_ */
+        nasm_nonfatal("WRT not supported by binary output format");
+    }
+
+    /* Find the segment we are targeting. */
+    s = find_section_by_index(segto);
+    if (!s)
+        nasm_panic("code directed to nonexistent segment?");
+
+    /* "Smart" section-type adaptation code. */
+    if (!(s->flags & TYPE_DEFINED)) {
+        if (type == OUT_RESERVE)
+            s->flags |= TYPE_DEFINED | TYPE_NOBITS;
+        else
+            s->flags |= TYPE_DEFINED | TYPE_PROGBITS;
+    }
+
+    if ((s->flags & TYPE_NOBITS) && (type != OUT_RESERVE))
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in a"
+                  " nobits section: ignored");
+
+    switch (type) {
+    case OUT_ADDRESS:
+    {
+        int asize = abs((int)size);
+
+        if (segment != NO_SEG && !find_section_by_index(segment)) {
+            if (segment % 2)
+                nasm_nonfatal("binary output format does not support"
+                              " segment base references");
+            else
+                nasm_nonfatal("binary output format does not support"
+                              " external references");
+            segment = NO_SEG;
+        }
+        if (s->flags & TYPE_PROGBITS) {
+            if (segment != NO_SEG)
+                add_reloc(s, asize, segment, -1L);
+            p = mydata;
+	    WRITEADDR(p, *(int64_t *)data, asize);
+            saa_wbytes(s->contents, mydata, asize);
+        }
+
+        /*
+         * Reassign size with sign dropped, we will need it
+         * for section length calculation.
+         */
+        size = asize;
+	break;
+    }
+
+    case OUT_RAWDATA:
+        if (s->flags & TYPE_PROGBITS)
+            saa_wbytes(s->contents, data, size);
+	break;
+
+    case OUT_RESERVE:
+        if (s->flags & TYPE_PROGBITS) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+                      " %s section: zeroing", s->name);
+            saa_wbytes(s->contents, NULL, size);
+        }
+	break;
+
+    case OUT_REL1ADR:
+    case OUT_REL2ADR:
+    case OUT_REL4ADR:
+    case OUT_REL8ADR:
+    {
+	int64_t addr = *(int64_t *)data - size;
+	size = realsize(type, size);
+        if (segment != NO_SEG && !find_section_by_index(segment)) {
+            if (segment % 2)
+                nasm_nonfatal("binary output format does not support"
+                              " segment base references");
+            else
+                nasm_nonfatal("binary output format does not support"
+                              " external references");
+            segment = NO_SEG;
+        }
+        if (s->flags & TYPE_PROGBITS) {
+            add_reloc(s, size, segment, segto);
+            p = mydata;
+	    WRITEADDR(p, addr - s->length, size);
+            saa_wbytes(s->contents, mydata, size);
+        }
+	break;
+    }
+
+    default:
+	nasm_nonfatal("unsupported relocation type %d\n", type);
+	break;
+    }
+
+    s->length += size;
+}
+
+static void bin_deflabel(char *name, int32_t segment, int64_t offset,
+                         int is_global, char *special)
+{
+    (void)segment;              /* Don't warn that this parameter is unused */
+    (void)offset;               /* Don't warn that this parameter is unused */
+
+    if (special)
+        nasm_nonfatal("binary format does not support any"
+                      " special symbol types");
+    else if (name[0] == '.' && name[1] == '.' && name[2] != '@')
+        nasm_nonfatal("unrecognised special symbol `%s'", name);
+    else if (is_global == 2)
+        nasm_nonfatal("binary output format does not support common"
+                      " variables");
+    else {
+        struct Section *s;
+        struct bin_label ***ltp;
+
+        /* Remember label definition so we can look it up later when
+         * creating the map file. */
+        s = find_section_by_index(segment);
+        if (s)
+            ltp = &(s->labels_end);
+        else
+            ltp = &nsl_tail;
+        (**ltp) = nasm_malloc(sizeof(struct bin_label));
+        (**ltp)->name = name;
+        (**ltp)->next = NULL;
+        *ltp = &((**ltp)->next);
+    }
+
+}
+
+/* These constants and the following function are used
+ * by bin_secname() to parse attribute assignments. */
+
+enum { ATTRIB_START, ATTRIB_ALIGN, ATTRIB_FOLLOWS,
+    ATTRIB_VSTART, ATTRIB_VALIGN, ATTRIB_VFOLLOWS,
+    ATTRIB_NOBITS, ATTRIB_PROGBITS
+};
+
+static int bin_read_attribute(char **line, int *attribute,
+                              uint64_t *value)
+{
+    expr *e;
+    int attrib_name_size;
+    struct tokenval tokval;
+    char *exp;
+
+    /* Skip whitespace. */
+    while (**line && nasm_isspace(**line))
+        (*line)++;
+    if (!**line)
+        return 0;
+
+    /* Figure out what attribute we're reading. */
+    if (!nasm_strnicmp(*line, "align=", 6)) {
+        *attribute = ATTRIB_ALIGN;
+        attrib_name_size = 6;
+    } else {
+        if (!nasm_strnicmp(*line, "start=", 6)) {
+            *attribute = ATTRIB_START;
+            attrib_name_size = 6;
+        } else if (!nasm_strnicmp(*line, "follows=", 8)) {
+            *attribute = ATTRIB_FOLLOWS;
+            *line += 8;
+            return 1;
+        } else if (!nasm_strnicmp(*line, "vstart=", 7)) {
+            *attribute = ATTRIB_VSTART;
+            attrib_name_size = 7;
+        } else if (!nasm_strnicmp(*line, "valign=", 7)) {
+            *attribute = ATTRIB_VALIGN;
+            attrib_name_size = 7;
+        } else if (!nasm_strnicmp(*line, "vfollows=", 9)) {
+            *attribute = ATTRIB_VFOLLOWS;
+            *line += 9;
+            return 1;
+        } else if (!nasm_strnicmp(*line, "nobits", 6) &&
+                   (nasm_isspace((*line)[6]) || ((*line)[6] == '\0'))) {
+            *attribute = ATTRIB_NOBITS;
+            *line += 6;
+            return 1;
+        } else if (!nasm_strnicmp(*line, "progbits", 8) &&
+                   (nasm_isspace((*line)[8]) || ((*line)[8] == '\0'))) {
+            *attribute = ATTRIB_PROGBITS;
+            *line += 8;
+            return 1;
+        } else
+            return 0;
+    }
+
+    /* Find the end of the expression. */
+    if ((*line)[attrib_name_size] != '(') {
+        /* Single term (no parenthesis). */
+        exp = *line += attrib_name_size;
+        while (**line && !nasm_isspace(**line))
+            (*line)++;
+        if (**line) {
+            **line = '\0';
+            (*line)++;
+        }
+    } else {
+        char c;
+        int pcount = 1;
+
+        /* Full expression (delimited by parenthesis) */
+        exp = *line += attrib_name_size + 1;
+        while (1) {
+            (*line) += strcspn(*line, "()'\"");
+            if (**line == '(') {
+                ++(*line);
+                ++pcount;
+            }
+            if (**line == ')') {
+                ++(*line);
+                --pcount;
+                if (!pcount)
+                    break;
+            }
+            if ((**line == '"') || (**line == '\'')) {
+                c = **line;
+                while (**line) {
+                    ++(*line);
+                    if (**line == c)
+                        break;
+                }
+                if (!**line) {
+                    nasm_nonfatal("invalid syntax in `section' directive");
+                    return -1;
+                }
+                ++(*line);
+            }
+            if (!**line) {
+                nasm_nonfatal("expecting `)'");
+                return -1;
+            }
+        }
+        *(*line - 1) = '\0';    /* Terminate the expression. */
+    }
+
+    /* Check for no value given. */
+    if (!*exp) {
+        nasm_warn(WARN_OTHER, "No value given to attribute in"
+                  " `section' directive");
+        return -1;
+    }
+
+    /* Read and evaluate the expression. */
+    stdscan_reset();
+    stdscan_set(exp);
+    tokval.t_type = TOKEN_INVALID;
+    e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
+    if (e) {
+        if (!is_really_simple(e)) {
+            nasm_nonfatal("section attribute value must be"
+                          " a critical expression");
+            return -1;
+        }
+    } else {
+        nasm_nonfatal("Invalid attribute value"
+                      " specified in `section' directive.");
+        return -1;
+    }
+    *value = (uint64_t)reloc_value(e);
+    return 1;
+}
+
+static void bin_sectalign(int32_t seg, unsigned int value)
+{
+    struct Section *s = find_section_by_index(seg);
+
+    if (!s || !is_power2(value))
+        return;
+
+    if (value > s->align)
+        s->align = value;
+
+    if (!(s->flags & ALIGN_DEFINED))
+        s->flags |= ALIGN_DEFINED;
+}
+
+static void bin_assign_attributes(struct Section *sec, char *astring)
+{
+    int attribute, check;
+    uint64_t value;
+    char *p;
+
+    while (1) {                 /* Get the next attribute. */
+        check = bin_read_attribute(&astring, &attribute, &value);
+        /* Skip bad attribute. */
+        if (check == -1)
+            continue;
+        /* Unknown section attribute, so skip it and warn the user. */
+        if (!check) {
+            if (!*astring)
+                break;          /* End of line. */
+            else {
+                p = astring;
+                while (*astring && !nasm_isspace(*astring))
+                    astring++;
+                if (*astring) {
+                    *astring = '\0';
+                    astring++;
+                }
+                nasm_warn(WARN_OTHER, "ignoring unknown section attribute: \"%s\"", p);
+            }
+            continue;
+        }
+
+        switch (attribute) {    /* Handle nobits attribute. */
+        case ATTRIB_NOBITS:
+            if ((sec->flags & TYPE_DEFINED)
+                && (sec->flags & TYPE_PROGBITS))
+                nasm_nonfatal("attempt to change section type"
+                              " from progbits to nobits");
+            else
+                sec->flags |= TYPE_DEFINED | TYPE_NOBITS;
+            continue;
+
+            /* Handle progbits attribute. */
+        case ATTRIB_PROGBITS:
+            if ((sec->flags & TYPE_DEFINED) && (sec->flags & TYPE_NOBITS))
+                nasm_nonfatal("attempt to change section type"
+                              " from nobits to progbits");
+            else
+                sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
+            continue;
+
+            /* Handle align attribute. */
+        case ATTRIB_ALIGN:
+            if (!value || ((value - 1) & value)) {
+                nasm_nonfatal("argument to `align' is not a power of two");
+            } else {
+                /*
+                 * Alignment is already satisfied if
+                 * the previous align value is greater
+                 */
+                if ((sec->flags & ALIGN_DEFINED) && (value < sec->align))
+                    value = sec->align;
+
+                /* Don't allow a conflicting align value. */
+                if ((sec->flags & START_DEFINED) && (sec->start & (value - 1))) {
+                    nasm_nonfatal("`align' value conflicts with section start address");
+                } else {
+                    sec->align  = value;
+                    sec->flags |= ALIGN_DEFINED;
+                }
+            }
+            continue;
+
+            /* Handle valign attribute. */
+        case ATTRIB_VALIGN:
+            if (!value || ((value - 1) & value))
+                nasm_nonfatal("argument to `valign' is not a power of two");
+            else {              /* Alignment is already satisfied if the previous
+                                 * align value is greater. */
+                if ((sec->flags & VALIGN_DEFINED) && (value < sec->valign))
+                    value = sec->valign;
+
+                /* Don't allow a conflicting valign value. */
+                if ((sec->flags & VSTART_DEFINED)
+                    && (sec->vstart & (value - 1)))
+                    nasm_nonfatal("`valign' value conflicts with `vstart' address");
+                else {
+                    sec->valign = value;
+                    sec->flags |= VALIGN_DEFINED;
+                }
+            }
+            continue;
+
+            /* Handle start attribute. */
+        case ATTRIB_START:
+            if (sec->flags & FOLLOWS_DEFINED)
+                nasm_nonfatal("cannot combine `start' and `follows'"
+                              " section attributes");
+            else if ((sec->flags & START_DEFINED) && (value != sec->start))
+                nasm_nonfatal("section start address redefined");
+            else {
+                sec->start = value;
+                sec->flags |= START_DEFINED;
+                if (sec->flags & ALIGN_DEFINED) {
+                    if (sec->start & (sec->align - 1))
+                        nasm_nonfatal("`start' address conflicts"
+                                      " with section alignment");
+                    sec->flags ^= ALIGN_DEFINED;
+                }
+            }
+            continue;
+
+            /* Handle vstart attribute. */
+        case ATTRIB_VSTART:
+            if (sec->flags & VFOLLOWS_DEFINED)
+                nasm_nonfatal("cannot combine `vstart' and `vfollows'"
+                              " section attributes");
+            else if ((sec->flags & VSTART_DEFINED)
+                     && (value != sec->vstart))
+                nasm_nonfatal("section virtual start address"
+                              " (vstart) redefined");
+            else {
+                sec->vstart = value;
+                sec->flags |= VSTART_DEFINED;
+                if (sec->flags & VALIGN_DEFINED) {
+                    if (sec->vstart & (sec->valign - 1))
+                        nasm_nonfatal("`vstart' address conflicts"
+                                      " with `valign' value");
+                    sec->flags ^= VALIGN_DEFINED;
+                }
+            }
+            continue;
+
+            /* Handle follows attribute. */
+        case ATTRIB_FOLLOWS:
+            p = astring;
+            astring += strcspn(astring, " \t");
+            if (astring == p)
+                nasm_nonfatal("expecting section name for `follows'"
+                              " attribute");
+            else {
+                *(astring++) = '\0';
+                if (sec->flags & START_DEFINED)
+                    nasm_nonfatal("cannot combine `start' and `follows'"
+                                  " section attributes");
+                sec->follows = nasm_strdup(p);
+                sec->flags |= FOLLOWS_DEFINED;
+            }
+            continue;
+
+            /* Handle vfollows attribute. */
+        case ATTRIB_VFOLLOWS:
+            if (sec->flags & VSTART_DEFINED)
+                nasm_nonfatal("cannot combine `vstart' and `vfollows'"
+                              " section attributes");
+            else {
+                p = astring;
+                astring += strcspn(astring, " \t");
+                if (astring == p)
+                    nasm_nonfatal("expecting section name for `vfollows'"
+                                  " attribute");
+                else {
+                    *(astring++) = '\0';
+                    sec->vfollows = nasm_strdup(p);
+                    sec->flags |= VFOLLOWS_DEFINED;
+                }
+            }
+            continue;
+        }
+    }
+}
+
+static void bin_define_section_labels(void)
+{
+    static int labels_defined = 0;
+    struct Section *sec;
+    char *label_name;
+    size_t base_len;
+
+    if (labels_defined)
+        return;
+    list_for_each(sec, sections) {
+        base_len = strlen(sec->name) + 8;
+        label_name = nasm_malloc(base_len + 8);
+        strcpy(label_name, "section.");
+        strcpy(label_name + 8, sec->name);
+
+        /* section.<name>.start */
+        strcpy(label_name + base_len, ".start");
+        define_label(label_name, sec->start_index, 0L, false);
+
+        /* section.<name>.vstart */
+        strcpy(label_name + base_len, ".vstart");
+        define_label(label_name, sec->vstart_index, 0L, false);
+
+        nasm_free(label_name);
+    }
+    labels_defined = 1;
+}
+
+static int32_t bin_secname(char *name, int *bits)
+{
+    char *p;
+    struct Section *sec;
+
+    /* bin_secname is called with *name = NULL at the start of each
+     * pass.  Use this opportunity to establish the default section
+     * (default is BITS-16 ".text" segment).
+     */
+    if (!name) {
+        /* Reset ORG and section attributes at the start of each pass. */
+        origin_defined = 0;
+        list_for_each(sec, sections)
+            sec->flags &= ~(START_DEFINED | VSTART_DEFINED |
+                            ALIGN_DEFINED | VALIGN_DEFINED);
+
+        /* Define section start and vstart labels. */
+        if (!pass_first())
+            bin_define_section_labels();
+
+        /* Establish the default (.text) section. */
+        *bits = 16;
+        sec = find_section_by_name(".text");
+        sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
+        return sec->vstart_index;
+    }
+
+    /* Attempt to find the requested section.  If it does not
+     * exist, create it. */
+    p = name;
+    while (*p && !nasm_isspace(*p))
+        p++;
+    if (*p)
+        *p++ = '\0';
+    sec = find_section_by_name(name);
+    if (!sec) {
+        sec = create_section(name);
+        if (!strcmp(name, ".data"))
+            sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
+        else if (!strcmp(name, ".bss")) {
+            sec->flags |= TYPE_DEFINED | TYPE_NOBITS;
+            sec->prev = NULL;
+        }
+    }
+
+    /* Handle attribute assignments. */
+    if (!pass_first())
+        bin_assign_attributes(sec, p);
+
+#ifndef ABIN_SMART_ADAPT
+    /* The following line disables smart adaptation of
+     * PROGBITS/NOBITS section types (it forces sections to
+     * default to PROGBITS). */
+    if (!pass_first() && !(sec->flags & TYPE_DEFINED))
+        sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
+#endif
+
+    return sec->vstart_index;
+}
+
+static enum directive_result
+bin_directive(enum directive directive, char *args)
+{
+    switch (directive) {
+    case D_ORG:
+    {
+        struct tokenval tokval;
+        uint64_t value;
+        expr *e;
+
+        stdscan_reset();
+        stdscan_set(args);
+        tokval.t_type = TOKEN_INVALID;
+        e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
+        if (e) {
+            if (!is_really_simple(e))
+                nasm_nonfatal("org value must be a critical"
+                      " expression");
+            else {
+                value = reloc_value(e);
+                /* Check for ORG redefinition. */
+                if (origin_defined && (value != origin))
+                    nasm_nonfatal("program origin redefined");
+                else {
+                    origin = value;
+                    origin_defined = 1;
+                }
+            }
+        } else
+            nasm_nonfatal("No or invalid offset specified"
+                          " in ORG directive.");
+        return DIRR_OK;
+    }
+    case D_MAP:
+    {
+    /* The 'map' directive allows the user to generate section
+     * and symbol information to stdout, stderr, or to a file. */
+	char *p;
+
+        if (!pass_first())
+            return DIRR_OK;
+        args += strspn(args, " \t");
+        while (*args) {
+            p = args;
+            args += strcspn(args, " \t");
+            if (*args != '\0')
+                *(args++) = '\0';
+            if (!nasm_stricmp(p, "all"))
+                map_control |=
+                    MAP_ORIGIN | MAP_SUMMARY | MAP_SECTIONS | MAP_SYMBOLS;
+            else if (!nasm_stricmp(p, "brief"))
+                map_control |= MAP_ORIGIN | MAP_SUMMARY;
+            else if (!nasm_stricmp(p, "sections"))
+                map_control |= MAP_ORIGIN | MAP_SUMMARY | MAP_SECTIONS;
+            else if (!nasm_stricmp(p, "segments"))
+                map_control |= MAP_ORIGIN | MAP_SUMMARY | MAP_SECTIONS;
+            else if (!nasm_stricmp(p, "symbols"))
+                map_control |= MAP_SYMBOLS;
+            else if (!rf) {
+                if (!nasm_stricmp(p, "stdout"))
+                    rf = stdout;
+                else if (!nasm_stricmp(p, "stderr"))
+                    rf = stderr;
+                else {          /* Must be a filename. */
+                    rf = nasm_open_write(p, NF_TEXT);
+                    if (!rf) {
+                        nasm_warn(WARN_OTHER, "unable to open map file `%s'", p);
+                        map_control = 0;
+                        return DIRR_OK;
+                    }
+                }
+            } else
+                nasm_warn(WARN_OTHER, "map file already specified");
+        }
+        if (map_control == 0)
+            map_control |= MAP_ORIGIN | MAP_SUMMARY;
+        if (!rf)
+            rf = stdout;
+        return DIRR_OK;
+    }
+    default:
+	return DIRR_UNKNOWN;
+    }
+}
+
+const struct ofmt of_bin, of_ith, of_srec;
+static void binfmt_init(void);
+static void do_output_bin(void);
+static void do_output_ith(void);
+static void do_output_srec(void);
+
+static void bin_init(void)
+{
+    do_output = do_output_bin;
+    binfmt_init();
+}
+
+static void ith_init(void)
+{
+    do_output = do_output_ith;
+    binfmt_init();
+}
+
+static void srec_init(void)
+{
+    do_output = do_output_srec;
+    binfmt_init();
+}
+
+static void binfmt_init(void)
+{
+    relocs = NULL;
+    reloctail = &relocs;
+    origin_defined = 0;
+    no_seg_labels = NULL;
+    nsl_tail = &no_seg_labels;
+
+    /* Create default section (.text). */
+    sections = last_section = nasm_zalloc(sizeof(struct Section));
+    last_section->name          = nasm_strdup(".text");
+    last_section->contents      = saa_init(1L);
+    last_section->flags         = TYPE_DEFINED | TYPE_PROGBITS;
+    last_section->labels_end    = &(last_section->labels);
+    last_section->start_index   = seg_alloc();
+    last_section->vstart_index  = seg_alloc();
+}
+
+/* Generate binary file output */
+static void do_output_bin(void)
+{
+    struct Section *s;
+    uint64_t addr = origin;
+
+    /* Write the progbits sections to the output file. */
+    list_for_each(s, sections) {
+	/* Skip non-progbits sections */
+	if (!(s->flags & TYPE_PROGBITS))
+	    continue;
+	/* Skip zero-length sections */
+	if (s->length == 0)
+            continue;
+
+        /* Pad the space between sections. */
+	nasm_assert(addr <= s->start);
+	fwritezero(s->start - addr, ofile);
+
+        /* Write the section to the output file. */
+	saa_fpwrite(s->contents, ofile);
+
+	/* Keep track of the current file position */
+	addr = s->start + s->length;
+    }
+}
+
+/* Generate Intel hex file output */
+static void write_ith_record(unsigned int len, uint16_t addr,
+                             uint8_t type, void *data)
+{
+    char buf[1+2+4+2+255*2+2+2];
+    char *p = buf;
+    uint8_t csum, *dptr = data;
+    unsigned int i;
+
+    nasm_assert(len <= 255);
+
+    csum = len + addr + (addr >> 8) + type;
+    for (i = 0; i < len; i++)
+	csum += dptr[i];
+    csum = -csum;
+
+    p += sprintf(p, ":%02X%04X%02X", len, addr, type);
+    for (i = 0; i < len; i++)
+	p += sprintf(p, "%02X", dptr[i]);
+    p += sprintf(p, "%02X\n", csum);
+
+    nasm_write(buf, p-buf, ofile);
+}
+
+static void do_output_ith(void)
+{
+    uint8_t buf[32];
+    struct Section *s;
+    uint64_t addr, hiaddr, hilba;
+    uint64_t length;
+    unsigned int chunk;
+
+    /* Write the progbits sections to the output file. */
+    hilba = 0;
+    list_for_each(s, sections) {
+	/* Skip non-progbits sections */
+	if (!(s->flags & TYPE_PROGBITS))
+	    continue;
+	/* Skip zero-length sections */
+	if (s->length == 0)
+            continue;
+
+	addr   = s->start;
+	length = s->length;
+	saa_rewind(s->contents);
+
+	while (length) {
+	    hiaddr = addr >> 16;
+	    if (hiaddr != hilba) {
+		buf[0] = hiaddr >> 8;
+		buf[1] = hiaddr;
+		write_ith_record(2, 0, 4, buf);
+		hilba = hiaddr;
+	    }
+
+	    chunk = 32 - (addr & 31);
+	    if (length < chunk)
+		chunk = length;
+
+	    saa_rnbytes(s->contents, buf, chunk);
+	    write_ith_record(chunk, (uint16_t)addr, 0, buf);
+
+	    addr += chunk;
+	    length -= chunk;
+	}
+    }
+
+    /* Write closing record */
+    write_ith_record(0, 0, 1, NULL);
+}
+
+/* Generate Motorola S-records */
+static void write_srecord(unsigned int len,  unsigned int alen,
+                          uint32_t addr, uint8_t type, void *data)
+{
+    char buf[2+2+8+255*2+2+2];
+    char *p = buf;
+    uint8_t csum, *dptr = data;
+    unsigned int i;
+
+    nasm_assert(len <= 255);
+
+    switch (alen) {
+    case 2:
+	addr &= 0xffff;
+	break;
+    case 3:
+	addr &= 0xffffff;
+	break;
+    case 4:
+	break;
+    default:
+	panic();
+	break;
+    }
+
+    csum = (len+alen+1) + addr + (addr >> 8) + (addr >> 16) + (addr >> 24);
+    for (i = 0; i < len; i++)
+	csum += dptr[i];
+    csum = 0xff-csum;
+
+    p += sprintf(p, "S%c%02X%0*X", type, len+alen+1, alen*2, addr);
+    for (i = 0; i < len; i++)
+	p += sprintf(p, "%02X", dptr[i]);
+    p += sprintf(p, "%02X\n", csum);
+
+    nasm_write(buf, p-buf, ofile);
+}
+
+static void do_output_srec(void)
+{
+    uint8_t buf[32];
+    struct Section *s;
+    uint64_t addr, maxaddr;
+    uint64_t length;
+    int alen;
+    unsigned int chunk;
+    char dtype, etype;
+
+    maxaddr = 0;
+    list_for_each(s, sections) {
+	/* Skip non-progbits sections */
+	if (!(s->flags & TYPE_PROGBITS))
+	    continue;
+	/* Skip zero-length sections */
+	if (s->length == 0)
+            continue;
+
+	addr = s->start + s->length - 1;
+	if (addr > maxaddr)
+	    maxaddr = addr;
+    }
+
+    if (maxaddr <= 0xffff) {
+	alen  = 2;
+	dtype = '1';		/* S1 = 16-bit data */
+	etype = '9';		/* S9 = 16-bit end */
+    } else if (maxaddr <= 0xffffff) {
+	alen = 3;
+	dtype = '2';		/* S2 = 24-bit data */
+	etype = '8';		/* S8 = 24-bit end */
+    } else {
+	alen = 4;
+	dtype = '3';		/* S3 = 32-bit data */
+	etype = '7';		/* S7 = 32-bit end */
+    }
+
+    /* Write head record */
+    write_srecord(0, 2, 0, '0', NULL);
+
+    /* Write the progbits sections to the output file. */
+    list_for_each(s, sections) {
+	/* Skip non-progbits sections */
+	if (!(s->flags & TYPE_PROGBITS))
+	    continue;
+	/* Skip zero-length sections */
+	if (s->length == 0)
+            continue;
+
+	addr   = s->start;
+	length = s->length;
+	saa_rewind(s->contents);
+
+	while (length) {
+	    chunk = 32 - (addr & 31);
+	    if (length < chunk)
+		chunk = length;
+
+	    saa_rnbytes(s->contents, buf, chunk);
+	    write_srecord(chunk, alen, (uint32_t)addr, dtype, buf);
+
+	    addr += chunk;
+	    length -= chunk;
+	}
+    }
+
+    /* Write closing record */
+    write_srecord(0, alen, 0, etype, NULL);
+}
+
+
+const struct ofmt of_bin = {
+    "Flat raw binary (MS-DOS, embedded, ...)",
+    "bin",
+    "",
+    0,
+    64,
+    null_debug_arr,
+    &null_debug_form,
+    bin_stdmac,
+    bin_init,
+    null_reset,
+    nasm_do_legacy_output,
+    bin_out,
+    bin_deflabel,
+    bin_secname,
+    NULL,
+    bin_sectalign,
+    null_segbase,
+    bin_directive,
+    bin_cleanup,
+    NULL                        /* pragma list */
+};
+
+const struct ofmt of_ith = {
+    "Intel Hex encoded flat binary",
+    "ith",
+    ".ith",                     /* really should have been ".hex"... */
+    OFMT_TEXT,
+    64,
+    null_debug_arr,
+    &null_debug_form,
+    bin_stdmac,
+    ith_init,
+    null_reset,
+    nasm_do_legacy_output,
+    bin_out,
+    bin_deflabel,
+    bin_secname,
+    NULL,
+    bin_sectalign,
+    null_segbase,
+    bin_directive,
+    bin_cleanup,
+    NULL                        /* pragma list */
+};
+
+const struct ofmt of_srec = {
+    "Motorola S-records encoded flat binary",
+    "srec",
+    ".srec",
+    OFMT_TEXT,
+    64,
+    null_debug_arr,
+    &null_debug_form,
+    bin_stdmac,
+    srec_init,
+    null_reset,
+    nasm_do_legacy_output,
+    bin_out,
+    bin_deflabel,
+    bin_secname,
+    NULL,
+    bin_sectalign,
+    null_segbase,
+    bin_directive,
+    bin_cleanup,
+    NULL                        /* pragma list */
+};
+
+#endif                          /* #ifdef OF_BIN */
diff --git a/vere/ext/nasm/output/outbin.mac b/vere/ext/nasm/output/outbin.mac
new file mode 100644
index 0000000..99c15b6
--- /dev/null
+++ b/vere/ext/nasm/output/outbin.mac
@@ -0,0 +1,40 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: bin
+%define __?SECT?__ [section .text]
+%imacro org 1+.nolist
+[org %1]
+%endmacro
+%macro __?NASM_CDecl?__ 1
+%endmacro
diff --git a/vere/ext/nasm/output/outcoff.c b/vere/ext/nasm/output/outcoff.c
new file mode 100644
index 0000000..c2b4eb6
--- /dev/null
+++ b/vere/ext/nasm/output/outcoff.c
@@ -0,0 +1,1436 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outcoff.c    output routines for the Netwide Assembler to produce
+ *              COFF object files (for DJGPP and Win32)
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+#include <time.h>
+#include "ver.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "ilog2.h"
+#include "error.h"
+#include "saa.h"
+#include "raa.h"
+#include "eval.h"
+#include "outform.h"
+#include "outlib.h"
+#include "pecoff.h"
+
+#if defined(OF_COFF) || defined(OF_WIN32) || defined(OF_WIN64)
+
+/*
+ * Notes on COFF:
+ *
+ * (0) When I say `standard COFF' below, I mean `COFF as output and
+ * used by DJGPP'. I assume DJGPP gets it right.
+ *
+ * (1) Win32 appears to interpret the term `relative relocation'
+ * differently from standard COFF. Standard COFF understands a
+ * relative relocation to mean that during relocation you add the
+ * address of the symbol you're referencing, and subtract the base
+ * address of the section you're in. Win32 COFF, by contrast, seems
+ * to add the address of the symbol and then subtract the address
+ * of THE BYTE AFTER THE RELOCATED DWORD. Hence the two formats are
+ * subtly incompatible.
+ *
+ * (2) Win32 doesn't bother putting any flags in the header flags
+ * field (at offset 0x12 into the file).
+ *
+ * (3) Win32/64 uses some extra flags into the section header table:
+ * it defines flags 0x80000000 (writable), 0x40000000 (readable)
+ * and 0x20000000 (executable), and uses them in the expected
+ * combinations. It also defines 0x00100000 through 0x00f00000 for
+ * section alignments of 1 through 8192 bytes.
+ *
+ * (4) Both standard COFF and Win32 COFF seem to use the DWORD
+ * field directly after the section name in the section header
+ * table for something strange: they store what the address of the
+ * section start point _would_ be, if you laid all the sections end
+ * to end starting at zero. Dunno why. Microsoft's documentation
+ * lists this field as "Virtual Size of Section", which doesn't
+ * seem to fit at all. In fact, Win32 even includes non-linked
+ * sections such as .drectve in this calculation.
+ *
+ * Newer versions of MASM seem to have changed this to be zero, and
+ * that apparently matches the COFF spec, so go with that.
+ *
+ * (5) Standard COFF does something very strange to common
+ * variables: the relocation point for a common variable is as far
+ * _before_ the variable as its size stretches out _after_ it. So
+ * we must fix up common variable references. Win32 seems to be
+ * sensible on this one.
+ */
+
+/* Flag which version of COFF we are currently outputting. */
+bool win32, win64;
+
+static int32_t imagebase_sect;
+#define WRT_IMAGEBASE "..imagebase"
+
+/*
+ * Some common section flags by default
+ */
+#define TEXT_FLAGS_WIN                                  \
+        (IMAGE_SCN_CNT_CODE                     |       \
+         IMAGE_SCN_ALIGN_16BYTES                |       \
+         IMAGE_SCN_MEM_EXECUTE                  |       \
+         IMAGE_SCN_MEM_READ)
+#define TEXT_FLAGS_DOS                                  \
+        (IMAGE_SCN_CNT_CODE)
+
+#define DATA_FLAGS_WIN                                  \
+        (IMAGE_SCN_CNT_INITIALIZED_DATA         |       \
+         IMAGE_SCN_ALIGN_4BYTES                 |       \
+         IMAGE_SCN_MEM_READ                     |       \
+         IMAGE_SCN_MEM_WRITE)
+#define DATA_FLAGS_DOS                                  \
+        (IMAGE_SCN_CNT_INITIALIZED_DATA)
+
+#define BSS_FLAGS_WIN                                   \
+        (IMAGE_SCN_CNT_UNINITIALIZED_DATA       |       \
+         IMAGE_SCN_ALIGN_4BYTES                 |       \
+         IMAGE_SCN_MEM_READ                     |       \
+         IMAGE_SCN_MEM_WRITE)
+#define BSS_FLAGS_DOS                                   \
+        (IMAGE_SCN_CNT_UNINITIALIZED_DATA)
+
+#define RDATA_FLAGS_WIN                                 \
+        (IMAGE_SCN_CNT_INITIALIZED_DATA         |       \
+         IMAGE_SCN_ALIGN_8BYTES                 |       \
+         IMAGE_SCN_MEM_READ)
+
+#define RDATA_FLAGS_DOS                                 \
+        (IMAGE_SCN_CNT_INITIALIZED_DATA)
+
+#define PDATA_FLAGS                                     \
+        (IMAGE_SCN_CNT_INITIALIZED_DATA         |       \
+         IMAGE_SCN_ALIGN_4BYTES                 |       \
+         IMAGE_SCN_MEM_READ)
+
+#define XDATA_FLAGS                                     \
+        (IMAGE_SCN_CNT_INITIALIZED_DATA         |       \
+         IMAGE_SCN_ALIGN_8BYTES                 |       \
+         IMAGE_SCN_MEM_READ)
+
+#define INFO_FLAGS                                      \
+        (IMAGE_SCN_ALIGN_1BYTES                 |       \
+         IMAGE_SCN_LNK_INFO                     |       \
+         IMAGE_SCN_LNK_REMOVE)
+
+#define TEXT_FLAGS      ((win32 | win64) ? TEXT_FLAGS_WIN  : TEXT_FLAGS_DOS)
+#define DATA_FLAGS      ((win32 | win64) ? DATA_FLAGS_WIN  : DATA_FLAGS_DOS)
+#define BSS_FLAGS       ((win32 | win64) ? BSS_FLAGS_WIN   : BSS_FLAGS_DOS)
+#define RDATA_FLAGS     ((win32 | win64) ? RDATA_FLAGS_WIN : RDATA_FLAGS_DOS)
+
+#define COFF_MAX_ALIGNMENT 8192
+
+#define SECT_DELTA 32
+struct coff_Section **coff_sects;
+static int sectlen;
+int coff_nsects;
+
+struct SAA *coff_syms;
+uint32_t coff_nsyms;
+
+static int32_t def_seg;
+
+static int initsym;
+
+static struct RAA *bsym, *symval;
+
+struct SAA *coff_strs;
+static uint32_t strslen;
+
+static void coff_gen_init(void);
+static void coff_sect_write(struct coff_Section *, const uint8_t *, uint32_t);
+static void coff_write(void);
+static void coff_section_header(char *, int32_t, int32_t, int32_t, int32_t, int32_t, int, int32_t);
+static void coff_write_relocs(struct coff_Section *);
+static void coff_write_symbols(void);
+static void coff_defcomdatname(char *name, int32_t segment);
+
+#define COMDAT_PLACEHOLDER_NAME ".tmpcmdt"
+
+static void coff_win32_init(void)
+{
+    win32 = true;
+    win64 = false;
+    coff_gen_init();
+}
+
+static void coff_win64_init(void)
+{
+    win32 = false;
+    win64 = true;
+    coff_gen_init();
+    imagebase_sect = seg_alloc()+1;
+    backend_label(WRT_IMAGEBASE, imagebase_sect, 0);
+}
+
+static void coff_std_init(void)
+{
+    win32 = win64 = false;
+    coff_gen_init();
+}
+
+static void coff_gen_init(void)
+{
+
+    coff_sects = NULL;
+    coff_nsects = sectlen = 0;
+    coff_syms = saa_init(sizeof(struct coff_Symbol));
+    coff_nsyms = 0;
+    bsym = raa_init();
+    symval = raa_init();
+    coff_strs = saa_init(1);
+    strslen = 0;
+    def_seg = seg_alloc();
+}
+
+static void coff_cleanup(void)
+{
+    struct coff_Reloc *r;
+    int i;
+
+    dfmt->cleanup();
+
+    coff_write();
+    for (i = 0; i < coff_nsects; i++) {
+        if (coff_sects[i]->data)
+            saa_free(coff_sects[i]->data);
+        while (coff_sects[i]->head) {
+            r = coff_sects[i]->head;
+            coff_sects[i]->head = coff_sects[i]->head->next;
+            nasm_free(r);
+        }
+        nasm_free(coff_sects[i]->name);
+        nasm_free(coff_sects[i]->comdat_name);
+        nasm_free(coff_sects[i]);
+    }
+    nasm_free(coff_sects);
+    saa_free(coff_syms);
+    raa_free(bsym);
+    raa_free(symval);
+    saa_free(coff_strs);
+}
+
+int coff_make_section(char *name, uint32_t flags)
+{
+    struct coff_Section *s;
+    size_t namelen;
+
+    s = nasm_zalloc(sizeof(*s));
+
+    if (flags != BSS_FLAGS)
+        s->data = saa_init(1);
+    s->tail = &s->head;
+    if (!strcmp(name, ".text"))
+        s->index = def_seg;
+    else
+        s->index = seg_alloc();
+    s->namepos = -1;
+    namelen = strlen(name);
+    if (namelen > 8) {
+        if (win32 || win64) {
+            s->namepos = strslen + 4;
+            saa_wbytes(coff_strs, name, namelen + 1);
+            strslen += namelen + 1;
+        } else {
+            namelen = 8;
+        }
+    }
+    s->name = nasm_malloc(namelen + 1);
+    strncpy(s->name, name, namelen);
+    s->name[namelen] = '\0';
+    s->flags = flags;
+
+    if (coff_nsects >= sectlen) {
+        sectlen += SECT_DELTA;
+        coff_sects = nasm_realloc(coff_sects, sectlen * sizeof(*coff_sects));
+    }
+    coff_sects[coff_nsects++] = s;
+
+    return coff_nsects - 1;
+}
+
+/*
+ * Update the name and flags of an existing section
+ */
+static void coff_update_section(int section, char *name, uint32_t flags)
+{
+    struct coff_Section *s = coff_sects[section];
+    size_t namelen = strlen(name);
+
+    if (namelen > 8) {
+        if (win32 || win64) {
+            s->namepos = strslen + 4;
+            saa_wbytes(coff_strs, name, namelen + 1);
+            strslen += namelen + 1;
+        } else {
+            namelen = 8;
+        }
+    }
+
+    nasm_free(s->name);
+    s->name = nasm_malloc(namelen + 1);
+    strncpy(s->name, name, namelen);
+    s->name[namelen] = '\0';
+    s->flags = flags;
+}
+
+/*
+ * Convert an alignment value to the corresponding flags.
+ * An alignment value of 0 means no flags should be set.
+ */
+static inline uint32_t coff_sectalign_flags(unsigned int align)
+{
+    return (alignlog2_32(align) + 1) << 20;
+}
+
+/*
+ * Get the default section flags (based on section name)
+ */
+static uint32_t coff_section_flags(char *name, uint32_t flags)
+{
+    if (!flags) {
+        flags = TEXT_FLAGS;
+
+        if (!strcmp(name, ".data")) {
+            flags = DATA_FLAGS;
+        } else if (!strcmp(name, ".rdata")) {
+            flags = RDATA_FLAGS;
+        } else if (!strcmp(name, ".bss")) {
+            flags = BSS_FLAGS;
+        } else if (win64) {
+            if (!strcmp(name, ".pdata"))
+                flags = PDATA_FLAGS;
+            else if (!strcmp(name, ".xdata"))
+                flags = XDATA_FLAGS;
+        }
+    }
+
+    return flags;
+}
+
+static int32_t coff_section_names(char *name, int *bits)
+{
+    char *p, *comdat_name;
+    uint32_t flags, align_flags;
+    int i, j;
+    int8_t comdat_selection;
+    int32_t comdat_associated;
+
+    /*
+     * Set default bits.
+     */
+    if (!name) {
+        if(win64)
+            *bits = 64;
+        else
+            *bits = 32;
+
+        return def_seg;
+    }
+
+    p = name;
+    while (*p && !nasm_isspace(*p))
+        p++;
+    if (*p)
+        *p++ = '\0';
+    if (strlen(name) > 8) {
+        if (!win32 && !win64) {
+            nasm_warn(WARN_OTHER, "COFF section names limited to 8 characters:  truncating");
+            name[8] = '\0';
+        }
+    }
+    flags = align_flags = comdat_selection = comdat_associated = 0;
+    comdat_name = NULL;
+
+    while (*p && nasm_isspace(*p))
+        p++;
+    while (*p) {
+        char *q = p;
+        while (*p && !nasm_isspace(*p))
+            p++;
+        if (*p)
+            *p++ = '\0';
+        while (*p && nasm_isspace(*p))
+            p++;
+
+        if (!nasm_stricmp(q, "code") || !nasm_stricmp(q, "text")) {
+            flags = TEXT_FLAGS;
+        } else if (!nasm_stricmp(q, "data")) {
+            flags = DATA_FLAGS;
+        } else if (!nasm_stricmp(q, "rdata")) {
+            if (win32 | win64)
+                flags = RDATA_FLAGS;
+            else {
+                flags = DATA_FLAGS;     /* gotta do something */
+                nasm_nonfatal("standard COFF does not support"
+                              " read-only data sections");
+            }
+        } else if (!nasm_stricmp(q, "bss")) {
+            flags = BSS_FLAGS;
+        } else if (!nasm_stricmp(q, "info")) {
+            if (win32 | win64)
+                flags = INFO_FLAGS;
+            else {
+                flags = DATA_FLAGS;     /* gotta do something */
+                nasm_nonfatal("standard COFF does not support"
+                              " informational sections");
+            }
+        } else if (!nasm_strnicmp(q, "align=", 6)) {
+            if (q[6 + strspn(q + 6, "0123456789")])
+                nasm_nonfatal("argument to `align' is not numeric");
+            else {
+                unsigned int align = atoi(q + 6);
+                /* Allow align=0 meaning use default */
+                if (!align) {
+                    align_flags = 0;
+                } else if (!is_power2(align)) {
+                    nasm_nonfatal("argument to `align' is not a"
+                                  " power of two");
+                } else if (align > COFF_MAX_ALIGNMENT) {
+                    nasm_nonfatal("maximum alignment in COFF is %d bytes",
+                                  COFF_MAX_ALIGNMENT);
+                } else {
+                    align_flags = coff_sectalign_flags(align);
+                }
+            }
+        } else if (!nasm_strnicmp(q, "comdat=", 7)) {
+            /*
+             * Expected format: comdat=num:name]
+             * where
+             *   num is a number: one of the IMAGE_COMDAT_SELECT_* constants
+             *   name is a string: the "COMDAT name"
+             */
+            comdat_selection = strtoul(q + 7, &q, 10);
+            if (!comdat_selection)
+                nasm_nonfatal("invalid argument to `comdat'");
+            else if (*q != ':' || q[1] == '\0')
+                nasm_nonfatal("missing name in `comdat'");
+            else {
+                comdat_name = q + 1;
+            }
+        }
+    }
+
+    for (i = 0; i < coff_nsects; i++)
+        if (!strcmp(name, coff_sects[i]->name)) {
+            if (!comdat_name && !coff_sects[i]->comdat_name)
+                break;
+            else if (comdat_name && coff_sects[i]->comdat_name &&
+                     !strcmp(comdat_name, coff_sects[i]->comdat_name)) {
+                /*
+                 * For COMDAT, it makes sense to have multiple sections with
+                 * the same name (different comdat name though)
+                 */
+                if ((coff_sects[i]->comdat_selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE &&
+                    comdat_selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) ||
+                    (coff_sects[i]->comdat_selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE &&
+                    comdat_selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE)) {
+                    /*
+                     * Let's also allow an associative/other pair with the same name
+                     */
+                    break;
+                }
+            }
+        }
+        else if (comdat_name && coff_sects[i]->comdat_name &&
+                 !coff_sects[i]->comdat_selection &&
+                 !strcmp(comdat_name, coff_sects[i]->comdat_name) &&
+                 comdat_selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
+            /*
+             * This seems to be a "placeholder section" we've created before
+             * to be the associate of a previous comdat section.
+             * We'll just update the name and flags with the real ones now.
+             */
+            flags = coff_section_flags(name, flags);
+            coff_update_section(i, name, flags | IMAGE_SCN_LNK_COMDAT);
+            coff_sects[i]->comdat_selection = comdat_selection;
+            break;
+        }
+
+    if (i == coff_nsects) {
+        flags = coff_section_flags(name, flags);
+
+        if (comdat_name) {
+            flags |= IMAGE_SCN_LNK_COMDAT;
+
+            if (comdat_selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
+                /*
+                 * Find an existing section with given comdat name
+                 */
+                for (j = 0; j < coff_nsects; j++)
+                    if (coff_sects[j]->comdat_name &&
+                        !strcmp(coff_sects[j]->comdat_name, comdat_name))
+                        break;
+
+                if (j == coff_nsects) {
+                    /*
+                     * The associated section doesn't exist (yet)
+                     * Even though the specs don't enforce a particular order,
+                     * VS (2019) linker doesn't accept .obj files where the
+                     * target section is a later one (than the one with sel==5)
+                     *
+                     * So let's insert another section now (a placeholder),
+                     * hoping it will be turned into the target section later.
+                     */
+                    j = coff_make_section(COMDAT_PLACEHOLDER_NAME, TEXT_FLAGS);
+                    coff_sects[j]->comdat_name = nasm_strdup(comdat_name);
+                }
+
+                comdat_associated = j + 1;
+            }
+        }
+
+        i = coff_make_section(name, flags);
+        coff_sects[i]->align_flags = align_flags;
+
+        if (comdat_name) {
+            coff_sects[i]->comdat_selection = comdat_selection;
+            coff_sects[i]->comdat_associated = comdat_associated;
+            coff_sects[i]->comdat_name = nasm_strdup(comdat_name);
+        }
+    } else {
+        if (flags) {
+            if (comdat_name)
+                flags |= IMAGE_SCN_LNK_COMDAT;
+
+            /* Warn if non-alignment flags differ */
+            if (((flags ^ coff_sects[i]->flags) & ~IMAGE_SCN_ALIGN_MASK) &&
+                coff_sects[i]->pass_last_seen == pass_count()) {
+                nasm_warn(WARN_OTHER, "section attributes changed on"
+                          " redeclaration of section `%s'", name);
+            }
+        }
+
+        /*
+         * Alignment can be increased, but never decreased. However,
+         * specifying a narrower alignment is permitted and ignored.
+         */
+        if (align_flags > coff_sects[i]->align_flags) {
+            coff_sects[i]->align_flags = align_flags;
+        }
+
+        if (comdat_name) {
+            if ((coff_sects[i]->comdat_selection != comdat_selection) &&
+                coff_sects[i]->pass_last_seen == pass_count()) {
+                nasm_warn(WARN_OTHER, "comdat selection changed on"
+                          " redeclaration of name `%s'", comdat_name);
+            }
+        }
+    }
+
+    coff_sects[i]->pass_last_seen = pass_count();
+    return coff_sects[i]->index;
+}
+
+static void coff_deflabel(char *name, int32_t segment, int64_t offset,
+                          int is_global, char *special)
+{
+    int pos, section;
+    struct coff_Symbol *sym;
+
+    if (special)
+        nasm_nonfatal("COFF format does not support any"
+                      " special symbol types");
+
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+        if (strcmp(name,WRT_IMAGEBASE))
+            nasm_nonfatal("unrecognized special symbol `%s'", name);
+        return;
+    }
+
+    if (segment == NO_SEG)
+        section = -1;      /* absolute symbol */
+    else {
+        int i;
+        section = 0;
+        for (i = 0; i < coff_nsects; i++)
+            if (segment == coff_sects[i]->index) {
+                section = i + 1;
+
+                if (coff_sects[i]->comdat_name && !coff_sects[i]->comdat_symbol) {
+                    /*
+                     * The "comdat symbol" must be the first one in symbol table
+                     * So we'll insert/define it - before defining the other one
+                     */
+                    coff_sects[i]->comdat_symbol = 1;
+
+                    if (coff_sects[i]->comdat_selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE &&
+                        0 != strcmp(coff_sects[i]->comdat_name, name)) {
+                        coff_defcomdatname(coff_sects[i]->comdat_name, segment);
+                    }
+                }
+                break;
+            }
+    }
+
+    pos = strslen + 4;
+    if (strlen(name) > 8) {
+        size_t nlen = strlen(name)+1;
+        saa_wbytes(coff_strs, name, nlen);
+        strslen += nlen;
+    } else
+        pos = -1;
+
+    sym = saa_wstruct(coff_syms);
+
+    sym->strpos = pos;
+    sym->namlen = strlen(name);
+    if (pos == -1)
+        strcpy(sym->name, name);
+    sym->is_global = !!is_global;
+    sym->type = 0;              /* Default to T_NULL (no type) */
+    sym->section = section;
+    if (!sym->section)
+        sym->is_global = true;
+    if (is_global == 2)
+        sym->value = offset;
+    else
+        sym->value = (sym->section == 0 ? 0 : offset);
+
+    /*
+     * define the references from external-symbol segment numbers
+     * to these symbol records.
+     */
+    if (sym->section == 0)
+        bsym = raa_write(bsym, segment, coff_nsyms);
+
+    if (segment != NO_SEG)
+        symval = raa_write(symval, segment, sym->section ? 0 : sym->value);
+
+    coff_nsyms++;
+}
+
+static int32_t coff_add_reloc(struct coff_Section *sect, int32_t segment,
+                              int16_t type)
+{
+    struct coff_Reloc *r;
+
+    r = *sect->tail = nasm_malloc(sizeof(struct coff_Reloc));
+    sect->tail = &r->next;
+    r->next = NULL;
+
+    r->address = sect->len;
+    if (segment == NO_SEG) {
+        r->symbol = 0, r->symbase = ABS_SYMBOL;
+    } else {
+        int i;
+        r->symbase = REAL_SYMBOLS;
+        for (i = 0; i < coff_nsects; i++) {
+            if (segment == coff_sects[i]->index) {
+                r->symbol = i * 2;
+                r->symbase = SECT_SYMBOLS;
+                break;
+            }
+        }
+        if (r->symbase == REAL_SYMBOLS)
+            r->symbol = raa_read(bsym, segment);
+    }
+    r->type = type;
+
+    sect->nrelocs++;
+
+    /*
+     * Return the fixup for standard COFF common variables.
+     */
+    if (r->symbase == REAL_SYMBOLS && !(win32 | win64))
+        return raa_read(symval, segment);
+
+    return 0;
+}
+
+static void coff_out(int32_t segto, const void *data,
+                     enum out_type type, uint64_t size,
+                     int32_t segment, int32_t wrt)
+{
+    struct coff_Section *s;
+    uint8_t mydata[8], *p;
+    int i;
+
+    if (wrt != NO_SEG && !win64) {
+        wrt = NO_SEG;           /* continue to do _something_ */
+        nasm_nonfatal("WRT not supported by COFF output formats");
+    }
+
+    s = NULL;
+    for (i = 0; i < coff_nsects; i++) {
+        if (segto == coff_sects[i]->index) {
+            s = coff_sects[i];
+            break;
+        }
+    }
+    if (!s) {
+        int tempint;            /* ignored */
+        if (segto != coff_section_names(".text", &tempint))
+            nasm_panic("strange segment conditions in COFF driver");
+        else
+            s = coff_sects[coff_nsects - 1];
+    }
+
+    /* magically default to 'wrt ..imagebase' in .pdata and .xdata */
+    if (win64 && wrt == NO_SEG) {
+        if (!strcmp(s->name,".pdata") || !strcmp(s->name,".xdata"))
+            wrt = imagebase_sect;
+    }
+
+    if (!s->data && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in"
+                  " BSS section `%s': ignored", s->name);
+        s->len += realsize(type, size);
+        return;
+    }
+
+    memset(mydata, 0, sizeof(mydata));
+
+    if (dfmt && dfmt->debug_output) {
+        struct coff_DebugInfo dinfo;
+        dinfo.segto = segto;
+        dinfo.seg = segment;
+        dinfo.section = s;
+
+        if (type == OUT_ADDRESS)
+            dinfo.size = abs((int)size);
+        else
+            dinfo.size = realsize(type, size);
+
+        dfmt->debug_output(type, &dinfo);
+    }
+
+    if (type == OUT_RESERVE) {
+        if (s->data) {
+            nasm_warn(WARN_ZEROING, "uninitialised space declared in"
+                      " non-BSS section `%s': zeroing", s->name);
+            coff_sect_write(s, NULL, size);
+        } else
+            s->len += size;
+    } else if (type == OUT_RAWDATA) {
+        coff_sect_write(s, data, size);
+    } else if (type == OUT_ADDRESS) {
+        int asize = abs((int)size);
+        if (!win64) {
+            if (asize != 4 && (segment != NO_SEG || wrt != NO_SEG)) {
+                nasm_nonfatal("COFF format does not support non-32-bit"
+                              " relocations");
+            } else {
+                int32_t fix = 0;
+                if (segment != NO_SEG || wrt != NO_SEG) {
+                    if (wrt != NO_SEG) {
+                        nasm_nonfatal("COFF format does not support WRT types");
+                    } else if (segment % 2) {
+                        nasm_nonfatal("COFF format does not support"
+                                      " segment base references");
+                    } else
+                        fix = coff_add_reloc(s, segment, IMAGE_REL_I386_DIR32);
+                }
+                p = mydata;
+                WRITELONG(p, *(int64_t *)data + fix);
+                coff_sect_write(s, mydata, asize);
+            }
+        } else {
+            int32_t fix = 0;
+            p = mydata;
+            if (asize == 8) {
+                if (wrt == imagebase_sect) {
+                    nasm_nonfatal("operand size mismatch: 'wrt "
+                                  WRT_IMAGEBASE "' is a 32-bit operand");
+                }
+                fix = coff_add_reloc(s, segment, IMAGE_REL_AMD64_ADDR64);
+                WRITEDLONG(p, *(int64_t *)data + fix);
+                coff_sect_write(s, mydata, asize);
+            } else {
+                fix = coff_add_reloc(s, segment,
+                        wrt == imagebase_sect ?	IMAGE_REL_AMD64_ADDR32NB:
+                                                IMAGE_REL_AMD64_ADDR32);
+                WRITELONG(p, *(int64_t *)data + fix);
+                coff_sect_write(s, mydata, asize);
+            }
+        }
+    } else if (type == OUT_REL2ADR) {
+        nasm_nonfatal("COFF format does not support 16-bit relocations");
+    } else if (type == OUT_REL4ADR) {
+        if (segment == segto && !(win64))  /* Acceptable for RIP-relative */
+            nasm_panic("intra-segment OUT_REL4ADR");
+        else if (segment == NO_SEG && win32)
+            nasm_nonfatal("Win32 COFF does not correctly support"
+                          " relative references to absolute addresses");
+        else {
+            int32_t fix = 0;
+            if (segment != NO_SEG && segment % 2) {
+                nasm_nonfatal("COFF format does not support"
+                              " segment base references");
+            } else
+                fix = coff_add_reloc(s, segment,
+                        win64 ? IMAGE_REL_AMD64_REL32 : IMAGE_REL_I386_REL32);
+            p = mydata;
+            if (win32 | win64) {
+                WRITELONG(p, *(int64_t *)data + 4 - size + fix);
+            } else {
+                WRITELONG(p, *(int64_t *)data - (size + s->len) + fix);
+            }
+            coff_sect_write(s, mydata, 4L);
+        }
+
+    }
+}
+
+static void coff_sect_write(struct coff_Section *sect,
+                            const uint8_t *data, uint32_t len)
+{
+    saa_wbytes(sect->data, data, len);
+    sect->len += len;
+}
+
+typedef struct tagString {
+    struct tagString *next;
+    int len;
+    char *String;
+} STRING;
+
+#define EXPORT_SECTION_NAME ".drectve"
+#define EXPORT_SECTION_FLAGS INFO_FLAGS
+/*
+ * #define EXPORT_SECTION_NAME ".text"
+ * #define EXPORT_SECTION_FLAGS TEXT_FLAGS
+ */
+
+static STRING *Exports = NULL;
+static struct coff_Section *directive_sec;
+static void AddExport(char *name)
+{
+    STRING *rvp = Exports, *newS;
+
+    newS = (STRING *) nasm_malloc(sizeof(STRING));
+    newS->len = strlen(name);
+    newS->next = NULL;
+    newS->String = (char *)nasm_malloc(newS->len + 1);
+    strcpy(newS->String, name);
+    if (rvp == NULL) {
+        int i;
+
+        for (i = 0; i < coff_nsects; i++) {
+            if (!strcmp(EXPORT_SECTION_NAME, coff_sects[i]->name))
+                break;
+        }
+
+        if (i == coff_nsects)
+            i = coff_make_section(EXPORT_SECTION_NAME, EXPORT_SECTION_FLAGS);
+
+        directive_sec = coff_sects[i];
+        Exports = newS;
+    } else {
+        while (rvp->next) {
+            if (!strcmp(rvp->String, name))
+                return;
+            rvp = rvp->next;
+        }
+        rvp->next = newS;
+    }
+}
+
+static void BuildExportTable(STRING **rvp)
+{
+    STRING *p, *t;
+
+    if (!rvp || !*rvp)
+        return;
+
+    list_for_each_safe(p, t, *rvp) {
+        coff_sect_write(directive_sec, (uint8_t *)"-export:", 8);
+        coff_sect_write(directive_sec, (uint8_t *)p->String, p->len);
+        coff_sect_write(directive_sec, (uint8_t *)" ", 1);
+        nasm_free(p->String);
+        nasm_free(p);
+    }
+
+    *rvp = NULL;
+}
+
+static void coff_defcomdatname(char *name, int32_t segment)
+{
+    coff_deflabel(name, segment, 0, 1, NULL);
+}
+
+static enum directive_result
+coff_directives(enum directive directive, char *value)
+{
+    switch (directive) {
+    case D_EXPORT:
+    {
+        char *q, *name;
+
+        /*
+         * XXX: pass_first() is really wrong here, but AddExport()
+         * needs to be modified to handle duplicate calls for the
+         * same value in order to change that. The right thing to do
+         * is probably to mark a label as an export in the label
+         * structure, in case the label doesn't actually exist.
+         */
+        if (!pass_first())
+            return DIRR_OK;           /* ignore in pass two */
+        name = q = value;
+        while (*q && !nasm_isspace(*q))
+            q++;
+        if (nasm_isspace(*q)) {
+            *q++ = '\0';
+            while (*q && nasm_isspace(*q))
+                q++;
+        }
+
+        if (!*name) {
+            nasm_nonfatal("`export' directive requires export name");
+            return DIRR_ERROR;
+        }
+        if (*q) {
+            nasm_nonfatal("unrecognized export qualifier `%s'", q);
+            return DIRR_ERROR;
+        }
+        AddExport(name);
+        return DIRR_OK;
+    }
+    case D_SAFESEH:
+    {
+        static int sxseg=-1;
+        int i;
+
+        if (!win32) /* Only applicable for -f win32 */
+            return 0;
+
+        if (sxseg == -1) {
+            for (i = 0; i < coff_nsects; i++)
+                if (!strcmp(".sxdata",coff_sects[i]->name))
+                    break;
+            if (i == coff_nsects)
+                sxseg = coff_make_section(".sxdata", IMAGE_SCN_LNK_INFO);
+            else
+                sxseg = i;
+        }
+        /*
+         * pass_final() is the only time when the full set of symbols are
+         * guaranteed to be present as it is the final output pass.
+         */
+        if (pass_final()) {
+            uint32_t n;
+            saa_rewind(coff_syms);
+            for (n = 0; n < coff_nsyms; n++) {
+                struct coff_Symbol *sym = saa_rstruct(coff_syms);
+                bool equals;
+
+                /*
+                 * sym->strpos is biased by 4, because symbol
+                 * table is prefixed with table length
+                 */
+                if (sym->strpos >=4) {
+                    char *name = nasm_malloc(sym->namlen+1);
+                    saa_fread(coff_strs, sym->strpos-4, name, sym->namlen);
+                    name[sym->namlen] = '\0';
+                    equals = !strcmp(value,name);
+                    nasm_free(name);
+                } else {
+                    equals = !strcmp(value,sym->name);
+                }
+
+                if (equals) {
+                    /*
+                     * this value arithmetic effectively reflects
+                     * initsym in coff_write(): 2 for file, 1 for
+                     * .absolute and two per each section
+                     */
+                    unsigned char value[4],*p=value;
+                    WRITELONG(p,n + 2 + 1 + coff_nsects*2);
+                    coff_sect_write(coff_sects[sxseg],value,4);
+                    sym->type = 0x20;
+                    break;
+                }
+            }
+            if (n == coff_nsyms) {
+                nasm_nonfatal("`safeseh' directive requires valid symbol");
+                return DIRR_ERROR;
+            }
+        }
+        return DIRR_OK;
+    }
+    default:
+        return DIRR_UNKNOWN;
+    }
+}
+
+/* handle relocations storm, valid for win32/64 only */
+static inline void coff_adjust_relocs(struct coff_Section *s)
+{
+    if (s->nrelocs < IMAGE_SCN_MAX_RELOC)
+        return;
+#ifdef OF_COFF
+    else
+    {
+        if (ofmt == &of_coff)
+            nasm_fatal("Too many relocations (%d) for section `%s'",
+                       s->nrelocs, s->name);
+    }
+#endif
+
+    s->flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
+    s->nrelocs++;
+}
+
+/*
+ * Make sure we satisfy all section alignment requirements and put the
+ * resulting alignment flags into the flags value in the header.  If
+ * no user-specified alignment is given, use the default for the
+ * section type; then either way round up to alignment specified by
+ * sectalign directives.
+ */
+static inline void coff_adjust_alignment(struct coff_Section *s)
+{
+    uint32_t align_flags = s->align_flags;
+
+    if (!align_flags) {
+        /* No user-specified alignment, use default for partition type */
+        align_flags = s->flags & IMAGE_SCN_ALIGN_MASK;
+    }
+
+    if (align_flags < s->sectalign_flags)
+        align_flags = s->sectalign_flags;
+
+    s->flags = (s->flags & ~IMAGE_SCN_ALIGN_MASK) | align_flags;
+}
+
+static void coff_write(void)
+{
+    int32_t pos, sympos, vsize;
+    int i;
+
+    /* fill in the .drectve section with -export's */
+    BuildExportTable(&Exports);
+
+    if (win32) {
+        /* add default value for @feat.00, this allows to 'link /safeseh' */
+        uint32_t n;
+
+        saa_rewind(coff_syms);
+        for (n = 0; n < coff_nsyms; n++) {
+            struct coff_Symbol *sym = saa_rstruct(coff_syms);
+            if (sym->strpos == -1 && !strcmp("@feat.00",sym->name))
+                break;
+        }
+        if (n == coff_nsyms)
+            coff_deflabel("@feat.00", NO_SEG, 1, 0, NULL);
+    }
+
+    /*
+     * Check all comdat sections
+     */
+    for (i = 0; i < coff_nsects; i++)
+        if (coff_sects[i]->comdat_name) {
+            if (!coff_sects[i]->comdat_symbol &&
+                coff_sects[i]->comdat_selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
+                /*
+                 * This section doesn't have its comdat symbol defined; do it
+                 */
+                coff_defcomdatname(coff_sects[i]->comdat_name, coff_sects[i]->index);
+            }
+            if (!coff_sects[i]->comdat_selection) {
+                /*
+                 * This is a placeholder section that wasn't properly defined
+                 */
+                nasm_nonfatal("`comdat' associate with symbol `%s` wasn't defined",
+                              coff_sects[i]->comdat_name);
+            }
+        }
+
+    /*
+     * Work out how big the file will get.
+     * Calculate the start of the `real' symbols at the same time.
+     * Check for massive relocations.
+     */
+    pos = 0x14 + 0x28 * coff_nsects;
+    initsym = 3;                /* two for the file, one absolute */
+    for (i = 0; i < coff_nsects; i++) {
+        coff_adjust_alignment(coff_sects[i]);
+        if (coff_sects[i]->data) {
+            coff_adjust_relocs(coff_sects[i]);
+            coff_sects[i]->pos = pos;
+            pos += coff_sects[i]->len;
+            coff_sects[i]->relpos = pos;
+            pos += 10 * coff_sects[i]->nrelocs;
+        } else
+            coff_sects[i]->pos = coff_sects[i]->relpos = 0L;
+        initsym += 2;           /* two for each section */
+    }
+    sympos = pos;
+
+    /*
+     * Output the COFF header.
+     */
+    if (win64)
+        i = IMAGE_FILE_MACHINE_AMD64;
+    else
+        i = IMAGE_FILE_MACHINE_I386;
+    fwriteint16_t(i,                    ofile); /* machine type */
+    fwriteint16_t(coff_nsects,               ofile); /* number of sections */
+    fwriteint32_t(posix_timestamp(), ofile); /* timestamp */
+    fwriteint32_t(sympos,               ofile);
+    fwriteint32_t(coff_nsyms + initsym,      ofile);
+    fwriteint16_t(0,                    ofile); /* no optional header */
+    /* Flags: 32-bit, no line numbers. Win32 doesn't even bother with them. */
+    fwriteint16_t((win32 | win64) ? 0 : 0x104, ofile);
+
+    /*
+     * Output the section headers.
+     */
+    vsize = 0L;
+    for (i = 0; i < coff_nsects; i++) {
+        coff_section_header(coff_sects[i]->name, coff_sects[i]->namepos, vsize, coff_sects[i]->len,
+                            coff_sects[i]->pos, coff_sects[i]->relpos,
+                            coff_sects[i]->nrelocs, coff_sects[i]->flags);
+        vsize += coff_sects[i]->len;
+    }
+
+    /*
+     * Output the sections and their relocations.
+     */
+    for (i = 0; i < coff_nsects; i++)
+        if (coff_sects[i]->data) {
+            saa_fpwrite(coff_sects[i]->data, ofile);
+            coff_write_relocs(coff_sects[i]);
+
+            if (coff_sects[i]->flags & IMAGE_SCN_LNK_COMDAT) {
+                /*
+                 * Checksum the section data
+                 */
+                uint32_t checksum = 0;
+                const char *data;
+                size_t len;
+
+                saa_rewind(coff_sects[i]->data);
+                while (len = coff_sects[i]->data->datalen,
+                        (data = saa_rbytes(coff_sects[i]->data, &len)) != NULL)
+                    checksum = crc32b(checksum, data, len);
+
+                coff_sects[i]->checksum = checksum;
+            }
+        }
+
+    /*
+     * Output the symbol and string tables.
+     */
+    coff_write_symbols();
+    fwriteint32_t(strslen + 4, ofile);     /* length includes length count */
+    saa_fpwrite(coff_strs, ofile);
+}
+
+static void coff_section_header(char *name, int32_t namepos, int32_t vsize,
+                                int32_t datalen, int32_t datapos,
+                                int32_t relpos, int nrelocs, int32_t flags)
+{
+    char padname[8];
+
+    (void)vsize;
+
+    if (namepos == -1) {
+        strncpy(padname, name, 8);
+        nasm_write(padname, 8, ofile);
+    } else {
+        /*
+         * If name is longer than 8 bytes, write '/' followed
+         * by offset into the strings table represented as
+         * decimal number.
+         */
+        namepos = namepos % 100000000;
+        padname[0] = '/';
+        padname[1] = '0' + (namepos / 1000000);
+        namepos = namepos % 1000000;
+        padname[2] = '0' + (namepos / 100000);
+        namepos = namepos % 100000;
+        padname[3] = '0' + (namepos / 10000);
+        namepos = namepos % 10000;
+        padname[4] = '0' + (namepos / 1000);
+        namepos = namepos % 1000;
+        padname[5] = '0' + (namepos / 100);
+        namepos = namepos % 100;
+        padname[6] = '0' + (namepos / 10);
+        namepos = namepos % 10;
+        padname[7] = '0' + (namepos);
+        nasm_write(padname, 8, ofile);
+    }
+
+    fwriteint32_t(0,            ofile); /* Virtual size field - set to 0 or vsize */
+    fwriteint32_t(0L,           ofile); /* RVA/offset - we ignore */
+    fwriteint32_t(datalen,      ofile);
+    fwriteint32_t(datapos,      ofile);
+    fwriteint32_t(relpos,       ofile);
+    fwriteint32_t(0L,           ofile); /* no line numbers - we don't do 'em */
+
+    /*
+     * a special case -- if there are too many relocs
+     * we have to put IMAGE_SCN_MAX_RELOC here and write
+     * the real relocs number into VirtualAddress of first
+     * relocation
+     */
+    if (flags & IMAGE_SCN_LNK_NRELOC_OVFL)
+        fwriteint16_t(IMAGE_SCN_MAX_RELOC, ofile);
+    else
+        fwriteint16_t(nrelocs,  ofile);
+
+    fwriteint16_t(0,            ofile); /* again, no line numbers */
+    fwriteint32_t(flags,        ofile);
+}
+
+static void coff_write_relocs(struct coff_Section *s)
+{
+    struct coff_Reloc *r;
+
+    /* a real number of relocations if needed */
+    if (s->flags & IMAGE_SCN_LNK_NRELOC_OVFL) {
+        fwriteint32_t(s->nrelocs, ofile);
+        fwriteint32_t(0, ofile);
+        fwriteint16_t(0, ofile);
+    }
+
+    for (r = s->head; r; r = r->next) {
+        fwriteint32_t(r->address, ofile);
+        fwriteint32_t(r->symbol + (r->symbase == REAL_SYMBOLS ? initsym :
+                                   r->symbase == ABS_SYMBOL   ? initsym - 1 :
+                                   r->symbase == SECT_SYMBOLS ? 2 : 0),
+                      ofile);
+        fwriteint16_t(r->type, ofile);
+    }
+}
+
+static void coff_symbol(char *name, int32_t strpos, int32_t value,
+                        int section, int type, int storageclass, int aux)
+{
+    char padname[8];
+
+    if (name) {
+        strncpy(padname, name, 8);
+        nasm_write(padname, 8, ofile);
+    } else {
+        fwriteint32_t(0, ofile);
+        fwriteint32_t(strpos, ofile);
+    }
+
+    fwriteint32_t(value,        ofile);
+    fwriteint16_t(section,      ofile);
+    fwriteint16_t(type,         ofile);
+
+    fputc(storageclass, ofile);
+    fputc(aux, ofile);
+}
+
+static void coff_write_symbols(void)
+{
+    char filename[18];
+    uint32_t i;
+
+    /*
+     * The `.file' record, and the file name auxiliary record.
+     */
+    coff_symbol(".file", 0L, 0L, -2, 0, 0x67, 1);
+    if (reproducible)
+        memset(filename, 0, 18);
+    else
+        strncpy(filename, inname, 18);
+    nasm_write(filename, 18, ofile);
+
+    /*
+     * The section records, with their auxiliaries.
+     */
+    memset(filename, 0, 18);    /* useful zeroed buffer */
+
+    for (i = 0; i < (uint32_t) coff_nsects; i++) {
+        coff_symbol(coff_sects[i]->name, 0L, 0L, i + 1, 0, 3, 1);
+        fwriteint32_t(coff_sects[i]->len,    ofile);
+        fwriteint16_t(coff_sects[i]->nrelocs,ofile);
+        if (coff_sects[i]->flags & IMAGE_SCN_LNK_COMDAT) {
+            fwriteint16_t(0, ofile);
+            fwriteint32_t(coff_sects[i]->checksum, ofile);
+            fwriteint16_t(coff_sects[i]->comdat_associated, ofile);
+            fputc(coff_sects[i]->comdat_selection, ofile);
+            nasm_write(filename, 3, ofile);
+        }
+        else
+            nasm_write(filename, 12, ofile);
+    }
+
+    /*
+     * The absolute symbol, for relative-to-absolute relocations.
+     */
+    coff_symbol(".absolut", 0L, 0L, -1, 0, 3, 0);
+
+    /*
+     * The real symbols.
+     */
+    saa_rewind(coff_syms);
+    for (i = 0; i < coff_nsyms; i++) {
+        struct coff_Symbol *sym = saa_rstruct(coff_syms);
+        coff_symbol(sym->strpos == -1 ? sym->name : NULL,
+                    sym->strpos, sym->value, sym->section,
+                    sym->type, sym->is_global ? 2 : 3, 0);
+    }
+}
+
+static void coff_sectalign(int32_t seg, unsigned int value)
+{
+    struct coff_Section *s = NULL;
+    uint32_t flags;
+    int i;
+
+    for (i = 0; i < coff_nsects; i++) {
+        if (coff_sects[i]->index == seg) {
+            s = coff_sects[i];
+            break;
+        }
+    }
+
+    if (!s || !is_power2(value))
+        return;
+
+    if (value > COFF_MAX_ALIGNMENT)
+        value = COFF_MAX_ALIGNMENT; /* Do our best... */
+
+    flags = coff_sectalign_flags(value);
+    if (flags > s->sectalign_flags)
+        s->sectalign_flags = flags;
+}
+
+extern macros_t coff_stdmac[];
+
+#endif /* defined(OF_COFF) || defined(OF_WIN32) */
+
+#ifdef OF_COFF
+
+static const struct pragma_facility coff_pragma_list[] = {
+    { "coff", NULL },
+    { NULL,   NULL }
+};
+
+const struct ofmt of_coff = {
+    "COFF (i386) (DJGPP, some Unix variants)",
+    "coff",
+    ".o",
+    0,
+    32,
+    null_debug_arr,
+    &null_debug_form,
+    coff_stdmac,
+    coff_std_init,
+    null_reset,
+    nasm_do_legacy_output,
+    coff_out,
+    coff_deflabel,
+    coff_section_names,
+    NULL,
+    coff_sectalign,
+    null_segbase,
+    coff_directives,
+    coff_cleanup,
+    coff_pragma_list
+};
+
+#endif
+
+
+#ifdef OF_WIN32
+
+static const struct pragma_facility coff_win_pragma_list[] = {
+    { "win",  NULL },
+    { "coff", NULL },
+    { NULL,   NULL }
+};
+
+extern const struct dfmt df_cv8;
+static const struct dfmt * const win32_debug_arr[2] = { &df_cv8, NULL };
+
+const struct ofmt of_win32 = {
+    "Microsoft extended COFF for Win32 (i386)",
+    "win32",
+    ".obj",
+    0,
+    32,
+    win32_debug_arr,
+    &df_cv8,
+    coff_stdmac,
+    coff_win32_init,
+    null_reset,
+    nasm_do_legacy_output,
+    coff_out,
+    coff_deflabel,
+    coff_section_names,
+    NULL,
+    coff_sectalign,
+    null_segbase,
+    coff_directives,
+    coff_cleanup,
+    coff_win_pragma_list
+};
+
+#endif
+
+#ifdef OF_WIN64
+
+static const struct dfmt * const win64_debug_arr[2] = { &df_cv8, NULL };
+
+const struct ofmt of_win64 = {
+    "Microsoft extended COFF for Win64 (x86-64)",
+    "win64",
+    ".obj",
+    0,
+    64,
+    win64_debug_arr,
+    &df_cv8,
+    coff_stdmac,
+    coff_win64_init,
+    null_reset,
+    nasm_do_legacy_output,
+    coff_out,
+    coff_deflabel,
+    coff_section_names,
+    NULL,
+    coff_sectalign,
+    null_segbase,
+    coff_directives,
+    coff_cleanup,
+    coff_win_pragma_list
+};
+
+#endif
diff --git a/vere/ext/nasm/output/outcoff.mac b/vere/ext/nasm/output/outcoff.mac
new file mode 100644
index 0000000..8d338ef
--- /dev/null
+++ b/vere/ext/nasm/output/outcoff.mac
@@ -0,0 +1,43 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: coff win32 win64
+%define __?SECT?__ [section .text]
+%macro __?NASM_CDecl?__ 1
+%endmacro
+%imacro export 1+.nolist
+[export %1]
+%endmacro
+%imacro safeseh 1.nolist
+[safeseh %1]
+%endmacro
diff --git a/vere/ext/nasm/output/outdbg.c b/vere/ext/nasm/output/outdbg.c
new file mode 100644
index 0000000..e7a9a4e
--- /dev/null
+++ b/vere/ext/nasm/output/outdbg.c
@@ -0,0 +1,576 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outdbg.c	output routines for the Netwide Assembler to produce
+ *		a debugging trace
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+#include <errno.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "outform.h"
+#include "outlib.h"
+#include "insns.h"
+#include "dbginfo.h"
+
+#ifdef OF_DBG
+
+struct Section {
+    struct Section *next;
+    int32_t number;
+    char *name;
+} *dbgsect;
+
+static unsigned long dbg_max_data_dump = 128;
+static bool section_labels = true;
+static bool subsections_via_symbols = false;
+static int32_t init_seg;
+
+const struct ofmt of_dbg;
+static void dbg_init(void)
+{
+    dbgsect = NULL;
+    fprintf(ofile, "NASM Output format debug dump\n");
+    fprintf(ofile, "input file  = %s\n", inname);
+    fprintf(ofile, "output file = %s\n", outname);
+    init_seg = seg_alloc();
+}
+
+static void dbg_reset(void)
+{
+    fprintf(ofile, "*** pass reset: pass = %"PRId64" (%s)\n",
+            pass_count(), pass_type_name());
+}
+
+static void dbg_cleanup(void)
+{
+    dfmt->cleanup();
+    while (dbgsect) {
+        struct Section *tmp = dbgsect;
+        dbgsect = dbgsect->next;
+        nasm_free(tmp->name);
+        nasm_free(tmp);
+    }
+}
+
+static int32_t dbg_add_section(char *name, int *bits, const char *whatwecallit)
+{
+    int seg;
+
+    /*
+     * We must have an initial default: let's make it 16.
+     */
+    if (!name)
+        *bits = 16;
+
+    if (!name) {
+        fprintf(ofile, "section_name on init: returning %d\n", init_seg);
+        seg = init_seg;
+    } else {
+        int n = strcspn(name, " \t");
+        char *sname = nasm_strndup(name, n);
+        char *tail = nasm_skip_spaces(name+n);
+        struct Section *s;
+
+        seg = NO_SEG;
+        for (s = dbgsect; s; s = s->next)
+            if (!strcmp(s->name, sname))
+                seg = s->number;
+
+        if (seg == NO_SEG) {
+            s = nasm_malloc(sizeof(*s));
+            s->name = sname;
+            s->number = seg = seg_alloc();
+            s->next = dbgsect;
+            dbgsect = s;
+            fprintf(ofile, "%s %s (%s) pass %"PRId64" (%s) : returning %d\n",
+                    whatwecallit, name, tail, pass_count(), pass_type_name(), seg);
+
+            if (section_labels)
+                backend_label(s->name, s->number + 1, 0);
+        }
+    }
+    return seg;
+}
+
+static int32_t dbg_section_names(char *name, int *bits)
+{
+    return dbg_add_section(name, bits, "section_names");
+}
+
+static int32_t dbg_herelabel(const char *name, enum label_type type,
+                             int32_t oldseg, int32_t *subsection,
+                             bool *copyoffset)
+{
+    int32_t newseg = oldseg;
+
+    if (subsections_via_symbols && type != LBL_LOCAL) {
+        newseg = *subsection;
+        if (newseg == NO_SEG) {
+            newseg = *subsection = seg_alloc();
+            *copyoffset = true; /* Minic MachO for now */
+        }
+    }
+    fprintf(ofile, "herelabel %s type %d (seg %08x) -> %08x\n",
+            name, type, oldseg, newseg);
+
+    return newseg;
+}
+
+static void dbg_deflabel(char *name, int32_t segment, int64_t offset,
+                         int is_global, char *special)
+{
+    fprintf(ofile, "deflabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
+            name, segment, offset,
+            is_global == 2 ? "common" : is_global ? "global" : "local",
+            is_global, special ? ": " : "", special);
+}
+
+static const char *out_type(enum out_type type)
+{
+    static const char *out_types[] = {
+        "rawdata",
+        "reserve",
+        "zerodata",
+        "address",
+        "reladdr",
+        "segment"
+    };
+    static char invalid_buf[64];
+
+    if (type >= sizeof(out_types)/sizeof(out_types[0])) {
+        sprintf(invalid_buf, "[invalid type %d]", type);
+        return invalid_buf;
+    }
+
+    return out_types[type];
+}
+
+static const char *out_flags(enum out_flags flags)
+{
+    static const char *out_flags[] = {
+        "signed",
+        "unsigned"
+    };
+    static char flags_buf[1024];
+    unsigned long flv = flags;
+    size_t n;
+    size_t left = sizeof flags_buf - 1;
+    char *p = flags_buf;
+    unsigned int i;
+
+    for (i = 0; flv; flv >>= 1, i++) {
+        if (flv & 1) {
+            if (i < ARRAY_SIZE(out_flags))
+                n = snprintf(p, left, "%s,", out_flags[i]);
+            else
+                n = snprintf(p, left, "%u,", i);
+            if (n >= left)
+                break;
+            left -= n;
+            p += n;
+        }
+    }
+    if (p > flags_buf)
+        p--;                    /* Delete final comma */
+    *p = '\0';
+
+    return flags_buf;
+}
+
+static void dbg_out(const struct out_data *data)
+{
+    fprintf(ofile,
+            "out to %"PRIx32":%"PRIx64" %s(%s) bits %d insoffs %d/%d "
+            "size %"PRIu64,
+            data->segment, data->offset,
+            out_type(data->type), out_flags(data->flags),
+            data->bits, data->insoffs, data->inslen, data->size);
+    if (data->itemp) {
+        fprintf(ofile, " ins %s(%d)",
+                nasm_insn_names[data->itemp->opcode], data->itemp->operands);
+    } else {
+        fprintf(ofile, " no ins (plain data)");
+    }
+
+    if (data->type == OUT_ADDRESS || data->type == OUT_RELADDR ||
+        data->type == OUT_SEGMENT) {
+        fprintf(ofile, " target %"PRIx32":%"PRIx64,
+                data->tsegment, data->toffset);
+        if (data->twrt != NO_SEG)
+            fprintf(ofile, " wrt %"PRIx32, data->twrt);
+    }
+    if (data->type == OUT_RELADDR)
+        fprintf(ofile, " relbase %"PRIx64, data->relbase);
+
+    putc('\n', ofile);
+
+    if (data->type == OUT_RAWDATA) {
+        if ((size_t)data->size != data->size) {
+            fprintf(ofile, "  data: <error: impossible size>\n");
+        } else if (!data->data) {
+            fprintf(ofile, "  data: <error: null pointer>\n");
+        } else if (dbg_max_data_dump != -1UL &&
+                   data->size > dbg_max_data_dump) {
+            fprintf(ofile, "  data: <%"PRIu64" bytes>\n", data->size);
+        } else {
+            size_t i, j;
+            const uint8_t *bytes = data->data;
+            for (i = 0; i < data->size; i += 16) {
+                fprintf(ofile, "  data:");
+                for (j = 0; j < 16; j++) {
+                    if (i+j >= data->size)
+                        fprintf(ofile, "   ");
+                    else
+                        fprintf(ofile, "%c%02x",
+                                (j == 8) ? '-' : ' ', bytes[i+j]);
+                }
+                fprintf(ofile,"    ");
+                for (j = 0; j < 16; j++) {
+                    if (i+j >= data->size) {
+                        putc(' ', ofile);
+                    } else {
+                        if (bytes[i+j] >= 32 && bytes[i+j] <= 126)
+                            putc(bytes[i+j], ofile);
+                        else
+                            putc('.', ofile);
+                    }
+                }
+                putc('\n', ofile);
+            }
+        }
+    }
+
+    /* This is probably the only place were we'll call this this way... */
+    nasm_do_legacy_output(data);
+}
+
+static void dbg_legacy_out(int32_t segto, const void *data,
+                           enum out_type type, uint64_t size,
+                           int32_t segment, int32_t wrt)
+{
+    int32_t ldata;
+
+    if (type == OUT_ADDRESS)
+        fprintf(ofile, "  legacy: out to %"PRIx32", len = %d: ",
+                segto, (int)abs((int)size));
+    else
+        fprintf(ofile, "  legacy: out to %"PRIx32", len = %"PRId64" (0x%"PRIx64"): ",
+                segto, (int64_t)size, size);
+
+    switch (type) {
+    case OUT_RESERVE:
+        fprintf(ofile, "reserved.\n");
+        break;
+    case OUT_RAWDATA:
+        fprintf(ofile, "rawdata\n"); /* Already have a data dump */
+        break;
+    case OUT_ADDRESS:
+	ldata = *(int64_t *)data;
+        fprintf(ofile, "addr %08"PRIx32" (seg %08"PRIx32", wrt %08"PRIx32")\n",
+                ldata, segment, wrt);
+        break;
+    case OUT_REL1ADR:
+        fprintf(ofile, "rel1adr %02"PRIx8" (seg %08"PRIx32")\n",
+		(uint8_t)*(int64_t *)data, segment);
+        break;
+    case OUT_REL2ADR:
+        fprintf(ofile, "rel2adr %04"PRIx16" (seg %08"PRIx32")\n",
+		(uint16_t)*(int64_t *)data, segment);
+        break;
+    case OUT_REL4ADR:
+        fprintf(ofile, "rel4adr %08"PRIx32" (seg %08"PRIx32")\n",
+		(uint32_t)*(int64_t *)data,
+                segment);
+        break;
+    case OUT_REL8ADR:
+        fprintf(ofile, "rel8adr %016"PRIx64" (seg %08"PRIx32")\n",
+		(uint64_t)*(int64_t *)data, segment);
+        break;
+    default:
+        fprintf(ofile, "unknown\n");
+        break;
+    }
+}
+
+static void dbg_sectalign(int32_t seg, unsigned int value)
+{
+    fprintf(ofile, "set alignment (%d) for segment (%u)\n",
+            seg, value);
+}
+
+static enum directive_result
+dbg_directive(enum directive directive, char *value)
+{
+    switch (directive) {
+        /*
+         * The .obj GROUP directive is nontrivial to emulate in a macro.
+         * It effectively creates a "pseudo-section" containing the first
+         * space-separated argument; the rest we ignore.
+         */
+    case D_GROUP:
+    {
+        int dummy;
+        dbg_add_section(value, &dummy, "directive:group");
+        break;
+    }
+
+    default:
+        break;
+    }
+
+    fprintf(ofile, "directive [%s] value [%s] pass %"PRId64" (%s)\n",
+            directive_dname(directive), value, pass_count(), pass_type_name());
+    return DIRR_OK;
+}
+
+static enum directive_result
+dbg_pragma(const struct pragma *pragma);
+
+static const struct pragma_facility dbg_pragma_list[] = {
+    { NULL, dbg_pragma }
+};
+
+static enum directive_result
+dbg_pragma(const struct pragma *pragma)
+{
+    fprintf(ofile, "pragma %s(%s) %s[%s] %s\n",
+            pragma->facility_name,
+            pragma->facility->name ? pragma->facility->name : "<default>",
+            pragma->opname, directive_dname(pragma->opcode),
+            pragma->tail);
+
+    if (pragma->facility == &dbg_pragma_list[0]) {
+        switch (pragma->opcode) {
+        case D_MAXDUMP:
+            if (!nasm_stricmp(pragma->tail, "unlimited")) {
+                dbg_max_data_dump = -1UL;
+            } else {
+                char *ep;
+                unsigned long arg;
+
+                errno = 0;
+                arg = strtoul(pragma->tail, &ep, 0);
+                if (errno || *nasm_skip_spaces(ep)) {
+                    nasm_warn(WARN_PRAGMA_BAD | ERR_PASS2,
+                               "invalid %%pragma dbg maxdump argument");
+                    return DIRR_ERROR;
+                } else {
+                    dbg_max_data_dump = arg;
+                }
+            }
+            break;
+        case D_NOSECLABELS:
+            section_labels = false;
+            break;
+        case D_SUBSECTIONS_VIA_SYMBOLS:
+            subsections_via_symbols = true;
+            break;
+        default:
+            break;
+        }
+    }
+    return DIRR_OK;
+}
+
+static const char * const types[] = {
+    "unknown", "label", "byte", "word", "dword", "float", "qword", "tbyte"
+};
+static void dbgdbg_init(void)
+{
+    fprintf(ofile, "dbg init: debug information enabled\n");
+}
+static void dbgdbg_cleanup(void)
+{
+    fprintf(ofile, "dbg cleanup: called\n");
+}
+
+static void dbgdbg_linnum(const char *lnfname, int32_t lineno, int32_t segto)
+{
+    fprintf(ofile, "dbg linenum: %s(%"PRId32") segment %"PRIx32"\n",
+	    lnfname, lineno, segto);
+}
+static void dbgdbg_deflabel(char *name, int32_t segment,
+                            int64_t offset, int is_global, char *special)
+{
+    fprintf(ofile, "dbg deflabel: %s = %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
+            name,
+            segment, offset,
+            is_global == 2 ? "common" : is_global ? "global" : "local",
+            is_global, special ? ": " : "", special);
+}
+
+static void dbgdbg_debug_smacros(bool define, const char *def)
+{
+    fprintf(ofile, "dbg define: %s [%s]\n",
+            define ? "define " : "undef ", def);
+}
+static void dbgdbg_debug_include(bool start, struct src_location outer,
+                                 struct src_location inner)
+{
+    fprintf(ofile, "dbg include: %s include: %s:%"PRId32" %s %s:%"PRId32"\n",
+            start ? "start" : "end", outer.filename, outer.lineno,
+            start ? "->" : "<-", inner.filename, inner.lineno);
+}
+
+static void dbgdbg_output(int output_type, void *param)
+{
+    (void)output_type;
+    (void)param;
+    fprintf(ofile, "dbg output: called\n");
+}
+static void dbgdbg_typevalue(int32_t type)
+{
+    fprintf(ofile, "dbg typevalue: %s(%"PRIX32")\n",
+            types[TYM_TYPE(type) >> 3], TYM_ELEMENTS(type));
+}
+
+static void
+write_macro_inv_list(const struct debug_macro_inv *inv, int level)
+{
+    int indent = (level+1) << 1;
+
+    while (inv) {
+        const struct rbtree *rb;
+
+        fprintf(ofile, "%*smacro: %s, invoked at %s:%"PRId32
+                ", %"PRIu32" ranges\n",
+                indent, "", inv->def->name, inv->where.filename,
+                inv->where.lineno, inv->naddr);
+
+        for (rb = rb_first(inv->addr.tree); rb; rb = rb_next(rb)) {
+            const struct debug_macro_addr *addr =
+                (const struct debug_macro_addr *)rb;
+            if (!addr->len) {
+                fprintf(ofile, "%*s%08"PRIx32": empty\n",
+                        indent+2, "", debug_macro_seg(addr));
+            } else {
+                fprintf(ofile,
+                        "%*s%08"PRIx32":[%016"PRIx64" ... %016"PRIx64"] "
+                        "len %"PRIu64"\n",
+                        indent+2, "",
+                        debug_macro_seg(addr), addr->start,
+                        addr->start + addr->len - 1, addr->len);
+            }
+        }
+
+        write_macro_inv_list(inv->down.l, level+1);
+        inv = inv->next;
+    }
+}
+
+static void dbgdbg_debug_mmacros(const struct debug_macro_info *dmi)
+{
+    const struct debug_macro_def *def;
+
+    fprintf(ofile, "dbg macros: %llu macros defined\n",
+            (unsigned long long)dmi->def.n);
+
+    fprintf(ofile, "  macro definitions:\n");
+    list_for_each(def, dmi->def.l) {
+        fprintf(ofile, "    macro: %s, count %llu, defined at %s:%"PRId32"\n",
+                def->name, (unsigned long long)def->ninv,
+                def->where.filename, def->where.lineno);
+    }
+
+    fprintf(ofile, "  macro invocations:\n");
+    write_macro_inv_list(dmi->inv.l, 1);
+
+    fprintf(ofile, "  end macro debug information\n");
+}
+
+static void dbgdbg_debug_directive(const char *id, const char *value)
+{
+    fprintf(ofile, "dbg directive: id [%s] value [%s] pass %"PRId64" (%s)\n",
+            id, value, pass_count(), pass_type_name());
+}
+
+
+static const struct pragma_facility dbgdbg_pragma_list[] = {
+    { "dbgdbg", dbg_pragma },
+    { NULL, dbg_pragma }        /* Won't trigger, "debug" is a reserved ns */
+};
+
+static const struct dfmt debug_debug_form = {
+    "Trace of all info passed to debug stage",
+    "debug",
+    dbgdbg_init,
+    dbgdbg_linnum,
+    dbgdbg_deflabel,
+    dbgdbg_debug_smacros,
+    dbgdbg_debug_include,
+    dbgdbg_debug_mmacros,
+    dbgdbg_debug_directive,
+    dbgdbg_typevalue,
+    dbgdbg_output,
+    dbgdbg_cleanup,
+    dbgdbg_pragma_list
+};
+
+static const struct dfmt * const debug_debug_arr[3] = {
+    &debug_debug_form,
+    &null_debug_form,
+    NULL
+};
+
+extern macros_t dbg_stdmac[];
+
+const struct ofmt of_dbg = {
+    "Trace of all info passed to output stage",
+    "dbg",
+    ".dbg",
+    OFMT_TEXT|OFMT_KEEP_ADDR,
+    64,
+    debug_debug_arr,
+    &debug_debug_form,
+    dbg_stdmac,
+    dbg_init,
+    dbg_reset,
+    dbg_out,
+    dbg_legacy_out,
+    dbg_deflabel,
+    dbg_section_names,
+    dbg_herelabel,
+    dbg_sectalign,
+    null_segbase,
+    dbg_directive,
+    dbg_cleanup,
+    dbg_pragma_list
+};
+
+#endif                          /* OF_DBG */
diff --git a/vere/ext/nasm/output/outdbg.mac b/vere/ext/nasm/output/outdbg.mac
new file mode 100644
index 0000000..44cd11c
--- /dev/null
+++ b/vere/ext/nasm/output/outdbg.mac
@@ -0,0 +1,56 @@
+;; --------------------------------------------------------------------------
+;;
+;;   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;
+; Define a few macros which lets the dbg format process files intended
+; for the .obj and .bin formats.
+;
+OUT: dbg
+%define __?SECT?__ [section .text]
+%imacro group 1+.nolist
+[group %1]
+%endmacro
+%imacro uppercase 0+.nolist
+ %pragma dbg uppercase %1
+%endmacro
+%imacro export 1+.nolist
+ %pragma dbg export %1
+%endmacro
+%imacro import 1+.nolist
+ %pragma dbg import %1
+%endmacro
+%imacro org 1+.nolist
+ %pragma dbg org %1
+%endmacro
+%macro __?NASM_CDecl?__ 1
+%endmacro
diff --git a/vere/ext/nasm/output/outelf.c b/vere/ext/nasm/output/outelf.c
new file mode 100644
index 0000000..ad8d210
--- /dev/null
+++ b/vere/ext/nasm/output/outelf.c
@@ -0,0 +1,3672 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Common code for outelf32 and outelf64
+ */
+
+#include "compiler.h"
+
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "saa.h"
+#include "raa.h"
+#include "stdscan.h"
+#include "eval.h"
+#include "outform.h"
+#include "outlib.h"
+#include "rbtree.h"
+#include "hashtbl.h"
+#include "ver.h"
+
+#include "dwarf.h"
+#include "stabs.h"
+#include "outelf.h"
+#include "elf.h"
+
+#if defined(OF_ELF32) || defined(OF_ELF64) || defined(OF_ELFX32)
+
+#define SECT_DELTA 32
+static struct elf_section **sects;
+static int nsects, sectlen;
+
+#define SHSTR_DELTA 256
+static char *shstrtab;
+static int shstrtablen, shstrtabsize;
+
+static struct SAA *syms;
+static uint32_t nlocals, nglobs, ndebugs; /* Symbol counts */
+
+static int32_t def_seg;
+
+static struct RAA *bsym;
+
+static struct SAA *symtab, *symtab_shndx;
+
+static struct SAA *strs;
+static uint32_t strslen;
+
+static struct RAA *section_by_index;
+static struct hash_table section_by_name;
+
+static struct elf_symbol *fwds;
+
+static char elf_module[FILENAME_MAX];
+static char elf_dir[FILENAME_MAX];
+
+extern const struct ofmt of_elf32;
+extern const struct ofmt of_elf64;
+extern const struct ofmt of_elfx32;
+
+static struct ELF_SECTDATA {
+    void                *data;
+    int64_t             len;
+    bool                is_saa;
+} *elf_sects;
+
+static int elf_nsect, nsections;
+static int64_t elf_foffs;
+
+static void elf_write(void);
+static void elf_sect_write(struct elf_section *, const void *, size_t);
+static void elf_sect_writeaddr(struct elf_section *, int64_t, size_t);
+static void elf_section_header(int name, int type, uint64_t flags,
+                               void *data, bool is_saa, uint64_t datalen,
+                               int link, int info,
+                               uint64_t align, uint64_t entsize);
+static void elf_write_sections(void);
+static size_t elf_build_symtab(void);
+static int add_sectname(const char *, const char *);
+
+/* First debugging section index */
+static int sec_debug;
+
+struct symlininfo {
+    int                 offset;
+    int                 section;        /* index into sects[] */
+    int                 segto;          /* internal section number */
+    char                *name;          /* shallow-copied pointer of section name */
+};
+
+struct linelist {
+    struct linelist     *next;
+    struct linelist     *last;
+    struct symlininfo   info;
+    char                *filename;
+    int                 line;
+};
+
+struct sectlist {
+    struct SAA          *psaa;
+    int                 section;
+    int                 line;
+    int                 offset;
+    int                 file;
+    struct sectlist     *next;
+    struct sectlist     *last;
+};
+
+/* common debug variables */
+static int currentline = 1;
+static int debug_immcall = 0;
+
+/* stabs debug variables */
+static struct linelist *stabslines = 0;
+static int numlinestabs = 0;
+static char *stabs_filename = 0;
+static uint8_t *stabbuf = 0, *stabstrbuf = 0, *stabrelbuf = 0;
+static int stablen, stabstrlen, stabrellen;
+
+/* dwarf debug variables */
+static struct linelist *dwarf_flist = 0, *dwarf_clist = 0, *dwarf_elist = 0;
+static struct sectlist *dwarf_fsect = 0, *dwarf_csect = 0, *dwarf_esect = 0;
+static int dwarf_numfiles = 0, dwarf_nsections;
+static uint8_t *arangesbuf = 0, *arangesrelbuf = 0, *pubnamesbuf = 0, *infobuf = 0,  *inforelbuf = 0,
+               *abbrevbuf = 0, *linebuf = 0, *linerelbuf = 0, *framebuf = 0, *locbuf = 0;
+static int8_t line_base = -5, line_range = 14, opcode_base = 13;
+static int arangeslen, arangesrellen, pubnameslen, infolen, inforellen,
+           abbrevlen, linelen, linerellen, framelen, loclen;
+static int64_t dwarf_infosym, dwarf_abbrevsym, dwarf_linesym;
+
+static struct elf_symbol *lastsym;
+
+/* common debugging routines */
+static void debug_typevalue(int32_t);
+
+/* stabs debugging routines */
+static void stabs_linenum(const char *filename, int32_t linenumber, int32_t);
+static void stabs_output(int, void *);
+static void stabs_generate(void);
+static void stabs_cleanup(void);
+
+/* dwarf debugging routines */
+
+/* This should match the order in elf_write() */
+enum dwarf_sect {
+    DWARF_ARANGES,
+    DWARF_RELA_ARANGES,
+    DWARF_PUBNAMES,
+    DWARF_INFO,
+    DWARF_RELA_INFO,
+    DWARF_ABBREV,
+    DWARF_LINE,
+    DWARF_RELA_LINE,
+    DWARF_FRAME,
+    DWARF_LOC,
+    DWARF_NSECT
+};
+
+struct dwarf_format {
+    uint16_t dwarf_version;
+    uint16_t sect_version[DWARF_NSECT];
+    /* ... add more here to generalize further */
+};
+const struct dwarf_format *dwfmt;
+
+static void dwarf32_init(void);
+static void dwarfx32_init(void);
+static void dwarf64_init(void);
+static void dwarf_linenum(const char *filename, int32_t linenumber, int32_t);
+static void dwarf_output(int, void *);
+static void dwarf_generate(void);
+static void dwarf_cleanup(void);
+static void dwarf_findfile(const char *);
+static void dwarf_findsect(const int);
+
+struct elf_format_info {
+    size_t word;                /* Word size (4 or 8) */
+    size_t ehdr_size;           /* Size of the ELF header */
+    size_t shdr_size;           /* Size of a section header */
+    size_t sym_size;            /* Size of a symbol */
+    size_t relsize;             /* Size of a reltype relocation */
+    char relpfx[8];             /* Relocation section prefix */
+    uint32_t reltype;           /* Relocation section type */
+    uint16_t e_machine;         /* Header e_machine field */
+    uint8_t ei_class;           /* ELFCLASS32 or ELFCLASS64 */
+    bool elf64;                 /* 64-bit ELF */
+
+    /* Write a symbol */
+    void (*elf_sym)(const struct elf_symbol *);
+
+    /* Build a relocation table */
+    struct SAA *(*elf_build_reltab)(const struct elf_reloc *);
+};
+static const struct elf_format_info *efmt;
+
+static void elf32_sym(const struct elf_symbol *sym);
+static void elf64_sym(const struct elf_symbol *sym);
+
+static struct SAA *elf32_build_reltab(const struct elf_reloc *r);
+static struct SAA *elfx32_build_reltab(const struct elf_reloc *r);
+static struct SAA *elf64_build_reltab(const struct elf_reloc *r);
+
+static bool dfmt_is_stabs(void);
+static bool dfmt_is_dwarf(void);
+
+/*
+ * Special NASM section numbers which are used to define ELF special
+ * symbols.
+ */
+static int32_t elf_gotpc_sect, elf_gotoff_sect;
+static int32_t elf_got_sect, elf_plt_sect;
+static int32_t elf_sym_sect, elf_gottpoff_sect, elf_tlsie_sect;
+
+uint8_t elf_osabi = 0;      /* Default OSABI = 0 (System V or Linux) */
+uint8_t elf_abiver = 0;     /* Current ABI version */
+
+/* Known sections with nonstandard defaults. -n means n*pointer size. */
+struct elf_known_section {
+    const char *name;   /* Name of section */
+    int type;           /* Section type (SHT_) */
+    uint32_t flags;     /* Section flags (SHF_) */
+    int align;          /* Section alignment */
+    int entsize;	/* Entry size, if applicable */
+};
+
+static const struct elf_known_section elf_known_sections[] = {
+    { ".text",          SHT_PROGBITS,      SHF_ALLOC|SHF_EXECINSTR,     16,  0 },
+    { ".rodata",        SHT_PROGBITS,      SHF_ALLOC,                    4,  0 },
+    { ".lrodata",       SHT_PROGBITS,      SHF_ALLOC,                    4,  0 },
+    { ".data",          SHT_PROGBITS,      SHF_ALLOC|SHF_WRITE,          4,  0 },
+    { ".ldata",         SHT_PROGBITS,      SHF_ALLOC|SHF_WRITE,          4,  0 },
+    { ".bss",           SHT_NOBITS,        SHF_ALLOC|SHF_WRITE,          4,  0 },
+    { ".lbss",          SHT_NOBITS,        SHF_ALLOC|SHF_WRITE,          4,  0 },
+    { ".tdata",         SHT_PROGBITS,      SHF_ALLOC|SHF_WRITE|SHF_TLS,  4,  0 },
+    { ".tbss",          SHT_NOBITS,        SHF_ALLOC|SHF_WRITE|SHF_TLS,  4,  0 },
+    { ".comment",       SHT_PROGBITS,      0,                            1,  0 },
+    { ".preinit_array", SHT_PREINIT_ARRAY, SHF_ALLOC,                   -1, -1 },
+    { ".init_array",    SHT_INIT_ARRAY,    SHF_ALLOC,                   -1, -1 },
+    { ".fini_array",    SHT_FINI_ARRAY,    SHF_ALLOC,                   -1, -1 },
+    { ".note",          SHT_NOTE,          0,                            4,  0 },
+    { NULL /*default*/, SHT_PROGBITS,      SHF_ALLOC,                    1,  0 }
+};
+
+struct size_unit {
+    char name[8];
+    int bytes;
+    int align;
+};
+static const struct size_unit size_units[] =
+{
+    { "byte",     1,  1 },
+    { "word",     2,  2 },
+    { "dword",    4,  4 },
+    { "qword",    8,  8 },
+    { "tword",   10,  2 },
+    { "tbyte",   10,  2 },
+    { "oword",   16, 16 },
+    { "xword",   16, 16 },
+    { "yword",   32, 32 },
+    { "zword",   64, 64 },
+    { "pointer", -1, -1 },
+    { "",         0,  0 }
+};
+
+static inline size_t to_bytes(int val)
+{
+    return (val >= 0) ? (size_t)val : -val * efmt->word;
+}
+
+/* parse section attributes */
+static void elf_section_attrib(char *name, char *attr, uint32_t *flags_and, uint32_t *flags_or,
+                               uint64_t *alignp, uint64_t *entsize, int *type)
+{
+    char *opt, *val, *next;
+    uint64_t align = 0;
+    uint64_t xalign = 0;
+
+    opt = nasm_skip_spaces(attr);
+    if (!opt || !*opt)
+        return;
+
+    while ((opt = nasm_opt_val(opt, &val, &next))) {
+        if (!nasm_stricmp(opt, "align")) {
+            if (!val) {
+                nasm_nonfatal("section align without value specified");
+            } else {
+                bool err;
+                uint64_t a = readnum(val, &err);
+                if (a && !is_power2(a)) {
+                    nasm_error(ERR_NONFATAL,
+                               "section alignment %"PRId64" is not a power of two",
+                               a);
+                } else if (a > align) {
+                    align = a;
+                }
+            }
+        } else if (!nasm_stricmp(opt, "alloc")) {
+            *flags_and  |= SHF_ALLOC;
+            *flags_or   |= SHF_ALLOC;
+        } else if (!nasm_stricmp(opt, "noalloc")) {
+            *flags_and  |= SHF_ALLOC;
+            *flags_or   &= ~SHF_ALLOC;
+        } else if (!nasm_stricmp(opt, "exec")) {
+            *flags_and  |= SHF_EXECINSTR;
+            *flags_or   |= SHF_EXECINSTR;
+        } else if (!nasm_stricmp(opt, "noexec")) {
+            *flags_and  |= SHF_EXECINSTR;
+            *flags_or   &= ~SHF_EXECINSTR;
+        } else if (!nasm_stricmp(opt, "write")) {
+            *flags_and  |= SHF_WRITE;
+            *flags_or   |= SHF_WRITE;
+        } else if (!nasm_stricmp(opt, "nowrite") ||
+		   !nasm_stricmp(opt, "readonly")) {
+            *flags_and  |= SHF_WRITE;
+            *flags_or   &= ~SHF_WRITE;
+        } else if (!nasm_stricmp(opt, "tls")) {
+            *flags_and  |= SHF_TLS;
+            *flags_or   |= SHF_TLS;
+        } else if (!nasm_stricmp(opt, "notls")) {
+            *flags_and  |= SHF_TLS;
+            *flags_or   &= ~SHF_TLS;
+        } else if (!nasm_stricmp(opt, "merge")) {
+            *flags_and  |= SHF_MERGE;
+            *flags_or   |= SHF_MERGE;
+        } else if (!nasm_stricmp(opt, "nomerge")) {
+            *flags_and  |= SHF_MERGE;
+            *flags_or   &= ~SHF_MERGE;
+        } else if (!nasm_stricmp(opt, "strings")) {
+            *flags_and  |= SHF_STRINGS;
+            *flags_or   |= SHF_STRINGS;
+        } else if (!nasm_stricmp(opt, "nostrings")) {
+            *flags_and  |= SHF_STRINGS;
+            *flags_or   &= ~SHF_STRINGS;
+        } else if (!nasm_stricmp(opt, "progbits")) {
+            *type = SHT_PROGBITS;
+        } else if (!nasm_stricmp(opt, "nobits")) {
+            *type = SHT_NOBITS;
+        } else if (!nasm_stricmp(opt, "note")) {
+            *type = SHT_NOTE;
+	} else if (!nasm_stricmp(opt, "preinit_array")) {
+	    *type = SHT_PREINIT_ARRAY;
+	} else if (!nasm_stricmp(opt, "init_array")) {
+	    *type = SHT_INIT_ARRAY;
+	} else if (!nasm_stricmp(opt, "fini_array")) {
+	    *type = SHT_FINI_ARRAY;
+        } else {
+	    uint64_t mult;
+	    size_t l;
+	    const char *a = strchr(opt, '*');
+	    bool err;
+	    const struct size_unit *su;
+
+	    if (a) {
+		l = a - opt - 1;
+		mult = readnum(a+1, &err);
+	    } else {
+		l = strlen(opt);
+		mult = 1;
+	    }
+
+	    for (su = size_units; su->bytes; su++) {
+		if (!nasm_strnicmp(opt, su->name, l))
+		    break;
+	    }
+
+	    if (su->bytes) {
+		*entsize = to_bytes(su->bytes) * mult;
+		xalign = to_bytes(su->align);
+	    } else {
+		/* Unknown attribute */
+		nasm_warn(WARN_OTHER,
+			   "unknown section attribute '%s' ignored on"
+			   " declaration of section `%s'", opt, name);
+	    }
+         }
+        opt = next;
+    }
+
+    switch (*type) {
+    case SHT_PREINIT_ARRAY:
+    case SHT_INIT_ARRAY:
+    case SHT_FINI_ARRAY:
+	if (!xalign)
+	    xalign = efmt->word;
+	if (!*entsize)
+	    *entsize = efmt->word;
+	break;
+    default:
+	break;
+    }
+
+    if (!align)
+        align = xalign;
+    if (!align)
+	align = SHA_ANY;
+
+    *alignp = align;
+}
+
+static enum directive_result
+elf_directive(enum directive directive, char *value)
+{
+    int64_t n;
+    bool err;
+    char *p;
+
+    switch (directive) {
+    case D_OSABI:
+        if (!pass_first())      /* XXX: Why? */
+            return DIRR_OK;
+
+        n = readnum(value, &err);
+        if (err) {
+            nasm_nonfatal("`osabi' directive requires a parameter");
+            return DIRR_ERROR;
+        }
+
+        if (n < 0 || n > 255) {
+            nasm_nonfatal("valid osabi numbers are 0 to 255");
+            return DIRR_ERROR;
+        }
+
+        elf_osabi  = n;
+        elf_abiver = 0;
+
+        p = strchr(value,',');
+        if (!p)
+            return DIRR_OK;
+
+        n = readnum(p + 1, &err);
+        if (err || n < 0 || n > 255) {
+            nasm_nonfatal("invalid ABI version number (valid: 0 to 255)");
+            return DIRR_ERROR;
+        }
+
+        elf_abiver = n;
+        return DIRR_OK;
+
+    default:
+        return DIRR_UNKNOWN;
+    }
+}
+
+static void elf_init(void);
+
+static void elf32_init(void)
+{
+    static const struct elf_format_info ef_elf32 = {
+        4,
+        sizeof(Elf32_Ehdr),
+        sizeof(Elf32_Shdr),
+        sizeof(Elf32_Sym),
+        sizeof(Elf32_Rel),
+        ".rel",
+        SHT_REL,
+        EM_386,
+        ELFCLASS32,
+        false,
+
+        elf32_sym,
+        elf32_build_reltab
+    };
+    efmt = &ef_elf32;
+    elf_init();
+}
+
+static void elfx32_init(void)
+{
+    static const struct elf_format_info ef_elfx32 = {
+        4,
+        sizeof(Elf32_Ehdr),
+        sizeof(Elf32_Shdr),
+        sizeof(Elf32_Sym),
+        sizeof(Elf32_Rela),
+        ".rela",
+        SHT_RELA,
+        EM_X86_64,
+        ELFCLASS32,
+        false,
+
+        elf32_sym,
+        elfx32_build_reltab
+    };
+    efmt = &ef_elfx32;
+    elf_init();
+}
+
+static void elf64_init(void)
+{
+    static const struct elf_format_info ef_elf64 = {
+        8,
+        sizeof(Elf64_Ehdr),
+        sizeof(Elf64_Shdr),
+        sizeof(Elf64_Sym),
+        sizeof(Elf64_Rela),
+        ".rela",
+        SHT_RELA,
+        EM_X86_64,
+        ELFCLASS64,
+        true,
+
+        elf64_sym,
+        elf64_build_reltab
+    };
+    efmt = &ef_elf64;
+    elf_init();
+}
+
+static void elf_init(void)
+{
+    static const char * const reserved_sections[] = {
+        ".shstrtab", ".strtab", ".symtab", ".symtab_shndx", NULL
+    };
+    const char * const *p;
+    const char * cur_path = nasm_realpath(inname);
+
+    strlcpy(elf_module, inname, sizeof(elf_module));
+    strlcpy(elf_dir, nasm_dirname(cur_path), sizeof(elf_dir));
+    sects = NULL;
+    nsects = sectlen = 0;
+    syms = saa_init((int32_t)sizeof(struct elf_symbol));
+    nlocals = nglobs = ndebugs = 0;
+    bsym = raa_init();
+    strs = saa_init(1L);
+    saa_wbytes(strs, "\0", 1L);
+    saa_wbytes(strs, elf_module, strlen(elf_module)+1);
+    strslen = 2 + strlen(elf_module);
+    shstrtab = NULL;
+    shstrtablen = shstrtabsize = 0;;
+    add_sectname("", "");       /* SHN_UNDEF */
+
+    fwds = NULL;
+
+    section_by_index = raa_init();
+
+    /*
+     * Add reserved section names to the section hash, with NULL
+     * as the data pointer
+     */
+    for (p = reserved_sections; *p; p++) {
+        struct hash_insert hi;
+        hash_find(&section_by_name, *p, &hi);
+        hash_add(&hi, *p, NULL);
+    }
+
+    /*
+     * FIXME: tlsie is Elf32 only and
+     * gottpoff is Elfx32|64 only.
+     */
+    elf_gotpc_sect = seg_alloc();
+    backend_label("..gotpc", elf_gotpc_sect + 1, 0L);
+    elf_gotoff_sect = seg_alloc();
+    backend_label("..gotoff", elf_gotoff_sect + 1, 0L);
+    elf_got_sect = seg_alloc();
+    backend_label("..got", elf_got_sect + 1, 0L);
+    elf_plt_sect = seg_alloc();
+    backend_label("..plt", elf_plt_sect + 1, 0L);
+    elf_sym_sect = seg_alloc();
+    backend_label("..sym", elf_sym_sect + 1, 0L);
+    elf_gottpoff_sect = seg_alloc();
+    backend_label("..gottpoff", elf_gottpoff_sect + 1, 0L);
+    elf_tlsie_sect = seg_alloc();
+    backend_label("..tlsie", elf_tlsie_sect + 1, 0L);
+
+    def_seg = seg_alloc();
+}
+
+static void elf_cleanup(void)
+{
+    struct elf_reloc *r;
+    int i;
+
+    elf_write();
+    for (i = 0; i < nsects; i++) {
+        if (sects[i]->type != SHT_NOBITS)
+            saa_free(sects[i]->data);
+        if (sects[i]->rel)
+            saa_free(sects[i]->rel);
+        while (sects[i]->head) {
+            r = sects[i]->head;
+            sects[i]->head = sects[i]->head->next;
+            nasm_free(r);
+        }
+    }
+    hash_free(&section_by_name);
+    raa_free(section_by_index);
+    nasm_free(sects);
+    saa_free(syms);
+    raa_free(bsym);
+    saa_free(strs);
+    dfmt->cleanup();
+}
+
+/*
+ * Add entry to the elf .shstrtab section and increment nsections.
+ * Returns the section index for this new section.
+ *
+ * IMPORTANT: this needs to match the order the section headers are
+ * emitted.
+ */
+static int add_sectname(const char *firsthalf, const char *secondhalf)
+{
+    int l1 = strlen(firsthalf);
+    int l2 = strlen(secondhalf);
+
+    while (shstrtablen + l1 + l2 + 1 > shstrtabsize)
+        shstrtab = nasm_realloc(shstrtab, (shstrtabsize += SHSTR_DELTA));
+
+    memcpy(shstrtab + shstrtablen, firsthalf, l1);
+    shstrtablen += l1;
+    memcpy(shstrtab + shstrtablen, secondhalf, l2+1);
+    shstrtablen += l2 + 1;
+
+    return nsections++;
+}
+
+static struct elf_section *
+elf_make_section(char *name, int type, int flags, uint64_t align)
+{
+    struct elf_section *s;
+
+    s = nasm_zalloc(sizeof(*s));
+
+    if (type != SHT_NOBITS)
+        s->data = saa_init(1L);
+    s->tail = &s->head;
+    if (!strcmp(name, ".text"))
+        s->index = def_seg;
+    else
+        s->index = seg_alloc();
+
+    s->name     = nasm_strdup(name);
+    s->type     = type;
+    s->flags    = flags;
+    s->align    = align;
+    s->shndx    = add_sectname("", name);
+
+    if (nsects >= sectlen)
+        sects = nasm_realloc(sects, (sectlen += SECT_DELTA) * sizeof(*sects));
+    sects[nsects++] = s;
+
+    return s;
+}
+
+static int32_t elf_section_names(char *name, int *bits)
+{
+    char *p;
+    uint32_t flags, flags_and, flags_or;
+    uint64_t align, entsize;
+    void **hp;
+    struct elf_section *s;
+    struct hash_insert hi;
+    int type;
+
+    if (!name) {
+        *bits = ofmt->maxbits;
+        return def_seg;
+    }
+
+    p = nasm_skip_word(name);
+    if (*p)
+        *p++ = '\0';
+    flags_and = flags_or = type = align = entsize = 0;
+
+    elf_section_attrib(name, p, &flags_and, &flags_or, &align, &entsize, &type);
+
+    hp = hash_find(&section_by_name, name, &hi);
+    if (hp) {
+        s = *hp;
+        if (!s) {
+            nasm_nonfatal("attempt to redefine reserved section name `%s'", name);
+            return NO_SEG;
+        }
+    } else {
+        const struct elf_known_section *ks = elf_known_sections;
+
+        while (ks->name) {
+            if (!strcmp(name, ks->name))
+                break;
+            ks++;
+        }
+
+        type = type ? type : ks->type;
+	if (!align)
+	    align = to_bytes(ks->align);
+	if (!entsize)
+	    entsize = to_bytes(ks->entsize);
+        flags = (ks->flags & ~flags_and) | flags_or;
+
+        s = elf_make_section(name, type, flags, align);
+        hash_add(&hi, s->name, s);
+        section_by_index = raa_write_ptr(section_by_index, s->index >> 1, s);
+    }
+
+    if ((type && s->type != type)
+        || ((s->flags & flags_and) != flags_or)
+        || (entsize && s->entsize && entsize != s->entsize)) {
+        nasm_warn(WARN_OTHER, "incompatible section attributes ignored on"
+                  " redeclaration of section `%s'", name);
+    }
+
+    if (align > s->align)
+        s->align = align;
+
+    if (entsize && !s->entsize)
+        s->entsize = entsize;
+
+    if ((flags_or & SHF_MERGE) && s->entsize == 0) {
+        if (!(s->flags & SHF_STRINGS))
+            nasm_nonfatal("section attribute merge specified without an entry size or `strings'");
+        s->entsize = 1;
+    }
+
+    return s->index;
+}
+
+static inline bool sym_type_local(int type)
+{
+    return ELF32_ST_BIND(type) == STB_LOCAL;
+}
+
+static void elf_deflabel(char *name, int32_t segment, int64_t offset,
+                         int is_global, char *special)
+{
+    int pos = strslen;
+    struct elf_symbol *sym;
+    const char *spcword = nasm_skip_spaces(special);
+    int bind, type;             /* st_info components */
+    const struct elf_section *sec = NULL;
+
+    if (debug_level(2)) {
+        nasm_debug(" elf_deflabel: %s, seg=%"PRIx32", off=%"PRIx64", is_global=%d, %s\n",
+                   name, segment, offset, is_global, special);
+    }
+
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+        /*
+         * This is a NASM special symbol. We never allow it into
+         * the ELF symbol table, even if it's a valid one. If it
+         * _isn't_ a valid one, we should barf immediately.
+         *
+         * FIXME: tlsie is Elf32 only, and gottpoff is Elfx32|64 only.
+         */
+        if (strcmp(name, "..gotpc") && strcmp(name, "..gotoff") &&
+            strcmp(name, "..got") && strcmp(name, "..plt") &&
+            strcmp(name, "..sym") && strcmp(name, "..gottpoff") &&
+            strcmp(name, "..tlsie"))
+            nasm_nonfatal("unrecognised special symbol `%s'", name);
+        return;
+    }
+
+    if (is_global == 3) {
+        struct elf_symbol **s;
+        /*
+         * Fix up a forward-reference symbol size from the first
+         * pass.
+         */
+        for (s = &fwds; *s; s = &(*s)->nextfwd)
+            if (!strcmp((*s)->name, name)) {
+                struct tokenval tokval;
+                expr *e;
+                char *p = nasm_skip_spaces(nasm_skip_word(special));
+
+                stdscan_reset();
+                stdscan_set(p);
+                tokval.t_type = TOKEN_INVALID;
+                e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
+                if (e) {
+                    if (!is_simple(e))
+                        nasm_nonfatal("cannot use relocatable"
+                                      " expression as symbol size");
+                    else
+                        (*s)->size = reloc_value(e);
+                }
+
+                /*
+                 * Remove it from the list of unresolved sizes.
+                 */
+                nasm_free((*s)->name);
+                *s = (*s)->nextfwd;
+                return;
+            }
+        return;                 /* it wasn't an important one */
+    }
+
+    saa_wbytes(strs, name, (int32_t)(1 + strlen(name)));
+    strslen += 1 + strlen(name);
+
+    lastsym = sym = saa_wstruct(syms);
+
+    memset(&sym->symv, 0, sizeof(struct rbtree));
+
+    sym->strpos = pos;
+    bind = is_global ? STB_GLOBAL : STB_LOCAL;
+    type = STT_NOTYPE;
+    sym->other = STV_DEFAULT;
+    sym->size = 0;
+    if (segment == NO_SEG) {
+        sym->section = XSHN_ABS;
+    } else {
+        sym->section = XSHN_UNDEF;
+        if (segment == def_seg) {
+            /* we have to be sure at least text section is there */
+            int tempint;
+            if (segment != elf_section_names(".text", &tempint))
+                nasm_panic("strange segment conditions in ELF driver");
+        }
+        sec = raa_read_ptr(section_by_index, segment >> 1);
+        if (sec)
+            sym->section = sec->shndx;
+    }
+
+    if (is_global == 2) {
+        sym->size = offset;
+        sym->symv.key = 0;
+        sym->section = XSHN_COMMON;
+        /*
+         * We have a common variable. Check the special text to see
+         * if it's a valid number and power of two; if so, store it
+         * as the alignment for the common variable.
+         *
+         * XXX: this should allow an expression.
+         */
+        if (spcword) {
+            bool err;
+            sym->symv.key = readnum(spcword, &err);
+            if (err)
+                nasm_nonfatal("alignment constraint `%s' is not a"
+                              " valid number", special);
+            else if (!is_power2(sym->symv.key))
+                nasm_nonfatal("alignment constraint `%s' is not a"
+                              " power of two", special);
+            spcword = nasm_skip_spaces(nasm_skip_word(spcword));
+        }
+    } else {
+        sym->symv.key = (sym->section == XSHN_UNDEF ? 0 : offset);
+    }
+
+    if (spcword && *spcword) {
+        const char *wend;
+        bool ok = true;
+
+        while (ok) {
+            size_t wlen;
+            wend = nasm_skip_word(spcword);
+            wlen = wend - spcword;
+
+            switch (wlen) {
+            case 4:
+                if (!nasm_strnicmp(spcword, "data", wlen))
+                    type = STT_OBJECT;
+                else if (!nasm_strnicmp(spcword, "weak", wlen))
+                    bind = STB_WEAK;
+                else
+                    ok = false;
+                break;
+
+            case 6:
+                if (!nasm_strnicmp(spcword, "notype", wlen))
+                    type = STT_NOTYPE;
+                else if (!nasm_strnicmp(spcword, "object", wlen))
+                    type = STT_OBJECT;
+                else if (!nasm_strnicmp(spcword, "hidden", wlen))
+                    sym->other = STV_HIDDEN;
+                else if (!nasm_strnicmp(spcword, "strong", wlen))
+                    bind = STB_GLOBAL;
+                else
+                    ok = false;
+                break;
+
+            case 7:
+                if (!nasm_strnicmp(spcword, "default", wlen))
+                    sym->other = STV_DEFAULT;
+                else
+                    ok = false;
+                break;
+
+            case 8:
+                if (!nasm_strnicmp(spcword, "function", wlen))
+                    type = STT_FUNC;
+                else if (!nasm_stricmp(spcword, "internal"))
+                    sym->other = STV_INTERNAL;
+                else
+                    ok = false;
+                break;
+
+            case 9:
+                if (!nasm_strnicmp(spcword, "protected", wlen))
+                    sym->other = STV_PROTECTED;
+                else
+                    ok = false;
+                break;
+
+            default:
+                ok = false;
+                break;
+            }
+
+            if (ok)
+                spcword = nasm_skip_spaces(wend);
+        }
+        if (!is_global && bind != STB_LOCAL) {
+            nasm_nonfatal("weak and strong only applies to global symbols");
+            bind = STB_LOCAL;
+        }
+
+        if (spcword && *spcword) {
+            struct tokenval tokval;
+            expr *e;
+            int fwd = 0;
+            char *saveme = stdscan_get();
+
+            /*
+             * We have a size expression; attempt to
+             * evaluate it.
+             */
+            stdscan_reset();
+            stdscan_set((char *)spcword);
+            tokval.t_type = TOKEN_INVALID;
+            e = evaluate(stdscan, NULL, &tokval, &fwd, 0, NULL);
+            if (fwd) {
+                sym->nextfwd = fwds;
+                fwds = sym;
+                sym->name = nasm_strdup(name);
+            } else if (e) {
+                if (!is_simple(e))
+                    nasm_nonfatal("cannot use relocatable"
+                                  " expression as symbol size");
+                else
+                    sym->size = reloc_value(e);
+            }
+            stdscan_set(saveme);
+        }
+    }
+
+    /*
+     * If it is in a TLS segment, mark symbol accordingly.
+     */
+    if (sec && (sec->flags & SHF_TLS))
+        type = STT_TLS;
+
+    /* Note: ELF32_ST_INFO() and ELF64_ST_INFO() are identical */
+    sym->type = ELF32_ST_INFO(bind, type);
+
+    if (sym_type_local(sym->type)) {
+        nlocals++;
+    } else {
+        /*
+         * If sym->section == SHN_ABS, then the first line of the
+         * else section would cause a core dump, because its a reference
+         * beyond the end of the section array.
+         * This behaviour is exhibited by this code:
+         *     GLOBAL crash_nasm
+         *     crash_nasm equ 0
+         * To avoid such a crash, such requests are silently discarded.
+         * This may not be the best solution.
+         */
+        if (sym->section == XSHN_UNDEF || sym->section == XSHN_COMMON) {
+            bsym = raa_write(bsym, segment, nglobs);
+        } else if (sym->section != XSHN_ABS) {
+            /*
+             * This is a global symbol; so we must add it to the rbtree
+             * of global symbols in its section.
+             *
+             * In addition, we check the special text for symbol
+             * type and size information.
+             */
+            sects[sym->section-1]->gsyms =
+                rb_insert(sects[sym->section-1]->gsyms, &sym->symv);
+
+        }
+        sym->globnum = nglobs;
+        nglobs++;
+    }
+}
+
+static void elf_add_reloc(struct elf_section *sect, int32_t segment,
+                          int64_t offset, int type)
+{
+    struct elf_reloc *r;
+
+    r = *sect->tail = nasm_zalloc(sizeof(struct elf_reloc));
+    sect->tail = &r->next;
+
+    r->address = sect->len;
+    r->offset = offset;
+
+    if (segment != NO_SEG) {
+        const struct elf_section *s;
+        s = raa_read_ptr(section_by_index, segment >> 1);
+        if (s)
+            r->symbol = s->shndx + 1;
+        else
+            r->symbol = GLOBAL_TEMP_BASE + raa_read(bsym, segment);
+    }
+    r->type = type;
+
+    sect->nrelocs++;
+}
+
+/*
+ * This routine deals with ..got and ..sym relocations: the more
+ * complicated kinds. In shared-library writing, some relocations
+ * with respect to global symbols must refer to the precise symbol
+ * rather than referring to an offset from the base of the section
+ * _containing_ the symbol. Such relocations call to this routine,
+ * which searches the symbol list for the symbol in question.
+ *
+ * R_386_GOT32 | R_X86_64_GOT32 references require the _exact_ symbol address to be
+ * used; R_386_32 | R_X86_64_32 references can be at an offset from the symbol.
+ * The boolean argument `exact' tells us this.
+ *
+ * Return value is the adjusted value of `addr', having become an
+ * offset from the symbol rather than the section. Should always be
+ * zero when returning from an exact call.
+ *
+ * Limitation: if you define two symbols at the same place,
+ * confusion will occur.
+ *
+ * Inefficiency: we search, currently, using a linked list which
+ * isn't even necessarily sorted.
+ */
+static int64_t elf_add_gsym_reloc(struct elf_section *sect,
+                                  int32_t segment, uint64_t offset,
+                                  int64_t pcrel, int type, bool exact)
+{
+    struct elf_reloc *r;
+    struct elf_section *s;
+    struct elf_symbol *sym;
+    struct rbtree *srb;
+
+    /*
+     * First look up the segment/offset pair and find a global
+     * symbol corresponding to it. If it's not one of our segments,
+     * then it must be an external symbol, in which case we're fine
+     * doing a normal elf_add_reloc after first sanity-checking
+     * that the offset from the symbol is zero.
+     */
+    s = raa_read_ptr(section_by_index, segment >> 1);
+    if (!s) {
+        if (exact && offset)
+            nasm_nonfatal("invalid access to an external symbol");
+        else
+            elf_add_reloc(sect, segment, offset - pcrel, type);
+        return 0;
+    }
+
+    srb = rb_search(s->gsyms, offset);
+    if (!srb || (exact && srb->key != offset)) {
+        nasm_nonfatal("unable to find a suitable global symbol"
+                      " for this reference");
+        return 0;
+    }
+    sym = container_of(srb, struct elf_symbol, symv);
+
+    r = *sect->tail = nasm_malloc(sizeof(struct elf_reloc));
+    sect->tail = &r->next;
+
+    r->next     = NULL;
+    r->address  = sect->len;
+    r->offset = offset - pcrel - sym->symv.key;
+    r->symbol   = GLOBAL_TEMP_BASE + sym->globnum;
+    r->type     = type;
+
+    sect->nrelocs++;
+    return r->offset;
+}
+
+static void elf32_out(int32_t segto, const void *data,
+                      enum out_type type, uint64_t size,
+                      int32_t segment, int32_t wrt)
+{
+    struct elf_section *s;
+    int64_t addr;
+    int reltype, bytes;
+    static struct symlininfo sinfo;
+
+    /*
+     * handle absolute-assembly (structure definitions)
+     */
+    if (segto == NO_SEG) {
+        if (type != OUT_RESERVE)
+            nasm_nonfatal("attempt to assemble code in [ABSOLUTE] space");
+        return;
+    }
+
+    s = raa_read_ptr(section_by_index, segto >> 1);
+    if (!s) {
+        int tempint;            /* ignored */
+        if (segto != elf_section_names(".text", &tempint))
+            nasm_panic("strange segment conditions in ELF driver");
+        else
+            s = sects[nsects - 1];
+    }
+
+    /* again some stabs debugging stuff */
+    sinfo.offset = s->len;
+    /* Adjust to an index of the section table. */
+    sinfo.section = s->shndx - 1;
+    sinfo.segto = segto;
+    sinfo.name = s->name;
+    dfmt->debug_output(TY_DEBUGSYMLIN, &sinfo);
+    /* end of debugging stuff */
+
+    if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in"
+                  " BSS section `%s': ignored", s->name);
+        s->len += realsize(type, size);
+        return;
+    }
+
+    switch (type) {
+    case OUT_RESERVE:
+        if (s->type != SHT_NOBITS) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+                      " non-BSS section `%s': zeroing", s->name);
+            elf_sect_write(s, NULL, size);
+        } else
+            s->len += size;
+        break;
+
+    case OUT_RAWDATA:
+        elf_sect_write(s, data, size);
+        break;
+
+    case OUT_ADDRESS:
+    {
+        bool err = false;
+        int asize = abs((int)size);
+
+        addr = *(int64_t *)data;
+        if (segment != NO_SEG) {
+            if (segment & 1) {
+                nasm_nonfatal("ELF format does not support"
+                              " segment base references");
+            } else {
+                if (wrt == NO_SEG) {
+                    /*
+                     * The if() is a hack to deal with compilers which
+                     * don't handle switch() statements with 64-bit
+                     * expressions.
+                     */
+                    switch (asize) {
+                    case 1:
+                        elf_add_reloc(s, segment, 0, R_386_8);
+                        break;
+                    case 2:
+                        elf_add_reloc(s, segment, 0, R_386_16);
+                        break;
+                    case 4:
+                        elf_add_reloc(s, segment, 0, R_386_32);
+                        break;
+                    default: /* Error issued further down */
+                        err = true;
+                        break;
+                    }
+                } else if (wrt == elf_gotpc_sect + 1) {
+                    /*
+                     * The user will supply GOT relative to $$. ELF
+                     * will let us have GOT relative to $. So we
+                     * need to fix up the data item by $-$$.
+                     */
+                    err = asize != 4;
+                    addr += s->len;
+                    elf_add_reloc(s, segment, 0, R_386_GOTPC);
+                } else if (wrt == elf_gotoff_sect + 1) {
+                    err = asize != 4;
+                    elf_add_reloc(s, segment, 0, R_386_GOTOFF);
+                } else if (wrt == elf_tlsie_sect + 1) {
+                    err = asize != 4;
+                    addr = elf_add_gsym_reloc(s, segment, addr, 0,
+                                              R_386_TLS_IE, true);
+                } else if (wrt == elf_got_sect + 1) {
+                    err = asize != 4;
+                    addr = elf_add_gsym_reloc(s, segment, addr, 0,
+                                              R_386_GOT32, true);
+                } else if (wrt == elf_sym_sect + 1) {
+                    switch (asize) {
+                    case 1:
+                        addr = elf_add_gsym_reloc(s, segment, addr, 0,
+                                                  R_386_8, false);
+                        break;
+                    case 2:
+                        addr = elf_add_gsym_reloc(s, segment, addr, 0,
+                                                  R_386_16, false);
+                        break;
+                    case 4:
+                        addr = elf_add_gsym_reloc(s, segment, addr, 0,
+                                                  R_386_32, false);
+                        break;
+                    default:
+                        err = true;
+                        break;
+                    }
+                } else if (wrt == elf_plt_sect + 1) {
+                    nasm_nonfatal("ELF format cannot produce non-PC-"
+                                  "relative PLT references");
+                } else {
+                    nasm_nonfatal("ELF format does not support this"
+                                  " use of WRT");
+                    wrt = NO_SEG; /* we can at least _try_ to continue */
+                }
+            }
+        }
+
+        if (err) {
+            nasm_nonfatal("Unsupported %d-bit ELF relocation", asize << 3);
+        }
+        elf_sect_writeaddr(s, addr, asize);
+        break;
+    }
+
+    case OUT_REL1ADR:
+        reltype = R_386_PC8;
+        bytes = 1;
+        goto rel12adr;
+    case OUT_REL2ADR:
+        reltype = R_386_PC16;
+        bytes = 2;
+        goto rel12adr;
+
+rel12adr:
+        addr = *(int64_t *)data - size;
+        nasm_assert(segment != segto);
+        if (segment != NO_SEG && (segment & 1)) {
+            nasm_nonfatal("ELF format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, 0, reltype);
+            } else {
+                nasm_nonfatal("Unsupported %d-bit ELF relocation", bytes << 3);
+            }
+        }
+        elf_sect_writeaddr(s, addr, bytes);
+        break;
+
+    case OUT_REL4ADR:
+        addr = *(int64_t *)data - size;
+        if (segment == segto)
+            nasm_panic("intra-segment OUT_REL4ADR");
+        if (segment != NO_SEG && (segment & 1)) {
+            nasm_nonfatal("ELF format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, 0, R_386_PC32);
+            } else if (wrt == elf_plt_sect + 1) {
+                elf_add_reloc(s, segment, 0, R_386_PLT32);
+            } else if (wrt == elf_gotpc_sect + 1 ||
+                       wrt == elf_gotoff_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                nasm_nonfatal("ELF format cannot produce PC-"
+                              "relative GOT references");
+            } else {
+                nasm_nonfatal("ELF format does not support this"
+                              " use of WRT");
+                wrt = NO_SEG;   /* we can at least _try_ to continue */
+            }
+        }
+        elf_sect_writeaddr(s, addr, 4);
+        break;
+
+    case OUT_REL8ADR:
+        nasm_nonfatal("32-bit ELF format does not support 64-bit relocations");
+        addr = 0;
+        elf_sect_writeaddr(s, addr, 8);
+        break;
+
+    default:
+        panic();
+    }
+}
+static void elf64_out(int32_t segto, const void *data,
+                      enum out_type type, uint64_t size,
+                      int32_t segment, int32_t wrt)
+{
+    struct elf_section *s;
+    int64_t addr;
+    int reltype, bytes;
+    static struct symlininfo sinfo;
+
+    /*
+     * handle absolute-assembly (structure definitions)
+     */
+    if (segto == NO_SEG) {
+        if (type != OUT_RESERVE)
+            nasm_nonfatal("attempt to assemble code in [ABSOLUTE] space");
+        return;
+    }
+
+    s = raa_read_ptr(section_by_index, segto >> 1);
+    if (!s) {
+        int tempint;            /* ignored */
+        if (segto != elf_section_names(".text", &tempint))
+            nasm_panic("strange segment conditions in ELF driver");
+        else
+            s = sects[nsects - 1];
+    }
+
+    /* again some stabs debugging stuff */
+    sinfo.offset = s->len;
+    /* Adjust to an index of the section table. */
+    sinfo.section = s->shndx - 1;
+    sinfo.segto = segto;
+    sinfo.name = s->name;
+    dfmt->debug_output(TY_DEBUGSYMLIN, &sinfo);
+    /* end of debugging stuff */
+
+    if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in"
+                  " BSS section `%s': ignored", s->name);
+        s->len += realsize(type, size);
+        return;
+    }
+
+    switch (type) {
+    case OUT_RESERVE:
+        if (s->type != SHT_NOBITS) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+                      " non-BSS section `%s': zeroing", s->name);
+            elf_sect_write(s, NULL, size);
+        } else
+            s->len += size;
+        break;
+
+    case OUT_RAWDATA:
+        if (segment != NO_SEG)
+            nasm_panic("OUT_RAWDATA with other than NO_SEG");
+        elf_sect_write(s, data, size);
+        break;
+
+    case OUT_ADDRESS:
+    {
+        int isize = (int)size;
+        int asize = abs((int)size);
+
+        addr = *(int64_t *)data;
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELF format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                switch (isize) {
+                case 1:
+                case -1:
+                    elf_add_reloc(s, segment, addr, R_X86_64_8);
+                    break;
+                case 2:
+                case -2:
+                    elf_add_reloc(s, segment, addr, R_X86_64_16);
+                    break;
+                case 4:
+                    elf_add_reloc(s, segment, addr, R_X86_64_32);
+                    break;
+                case -4:
+                    elf_add_reloc(s, segment, addr, R_X86_64_32S);
+                    break;
+                case 8:
+                case -8:
+                    elf_add_reloc(s, segment, addr, R_X86_64_64);
+                    break;
+                default:
+                    nasm_panic("internal error elf64-hpa-871");
+                    break;
+                }
+                addr = 0;
+            } else if (wrt == elf_gotpc_sect + 1) {
+                /*
+                 * The user will supply GOT relative to $$. ELF
+                 * will let us have GOT relative to $. So we
+                 * need to fix up the data item by $-$$.
+                 */
+                addr += s->len;
+                elf_add_reloc(s, segment, addr, R_X86_64_GOTPC32);
+                addr = 0;
+            } else if (wrt == elf_gotoff_sect + 1) {
+                if (asize != 8) {
+                    nasm_nonfatal("ELF64 requires ..gotoff "
+                                  "references to be qword");
+                } else {
+                    elf_add_reloc(s, segment, addr, R_X86_64_GOTOFF64);
+                    addr = 0;
+                }
+            } else if (wrt == elf_got_sect + 1) {
+                switch (asize) {
+                case 4:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_GOT32, true);
+                    addr = 0;
+                    break;
+                case 8:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_GOT64, true);
+                    addr = 0;
+                    break;
+                default:
+                    nasm_nonfatal("invalid ..got reference");
+                    break;
+                }
+            } else if (wrt == elf_sym_sect + 1) {
+                switch (isize) {
+                case 1:
+                case -1:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_8, false);
+                    addr = 0;
+                    break;
+                case 2:
+                case -2:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_16, false);
+                    addr = 0;
+                    break;
+                case 4:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_32, false);
+                    addr = 0;
+                    break;
+                case -4:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_32S, false);
+                    addr = 0;
+                    break;
+                case 8:
+                case -8:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_64, false);
+                    addr = 0;
+                    break;
+                default:
+                    nasm_panic("internal error elf64-hpa-903");
+                    break;
+                }
+            } else if (wrt == elf_plt_sect + 1) {
+                nasm_nonfatal("ELF format cannot produce non-PC-"
+                              "relative PLT references");
+            } else {
+                nasm_nonfatal("ELF format does not support this"
+                              " use of WRT");
+            }
+        }
+        elf_sect_writeaddr(s, addr, asize);
+        break;
+    }
+
+    case OUT_REL1ADR:
+        reltype = R_X86_64_PC8;
+        bytes = 1;
+        goto rel12adr;
+
+    case OUT_REL2ADR:
+        reltype = R_X86_64_PC16;
+        bytes = 2;
+        goto rel12adr;
+
+rel12adr:
+        addr = *(int64_t *)data - size;
+        if (segment == segto)
+            nasm_panic("intra-segment OUT_REL1ADR");
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELF format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, addr, reltype);
+                addr = 0;
+            } else {
+                nasm_nonfatal("Unsupported %d-bit ELF relocation", bytes << 3);
+            }
+        }
+        elf_sect_writeaddr(s, addr, bytes);
+        break;
+
+    case OUT_REL4ADR:
+        addr = *(int64_t *)data - size;
+        if (segment == segto)
+            nasm_panic("intra-segment OUT_REL4ADR");
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELF64 format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, addr, R_X86_64_PC32);
+                addr = 0;
+            } else if (wrt == elf_plt_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_PLT32, true);
+                addr = 0;
+            } else if (wrt == elf_gotpc_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_GOTPCREL, true);
+                addr = 0;
+            } else if (wrt == elf_gotoff_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                nasm_nonfatal("ELF64 requires ..gotoff references to be "
+                              "qword absolute");
+            } else if (wrt == elf_gottpoff_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_GOTTPOFF, true);
+                addr = 0;
+            } else {
+                nasm_nonfatal("ELF64 format does not support this"
+                              " use of WRT");
+            }
+        }
+        elf_sect_writeaddr(s, addr, 4);
+        break;
+
+    case OUT_REL8ADR:
+        addr = *(int64_t *)data - size;
+        if (segment == segto)
+            nasm_panic("intra-segment OUT_REL8ADR");
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELF64 format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, addr, R_X86_64_PC64);
+                addr = 0;
+            } else if (wrt == elf_gotpc_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_GOTPCREL64, true);
+                addr = 0;
+            } else if (wrt == elf_gotoff_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                nasm_nonfatal("ELF64 requires ..gotoff references to be "
+                              "absolute");
+            } else if (wrt == elf_gottpoff_sect + 1) {
+                nasm_nonfatal("ELF64 requires ..gottpoff references to be "
+                              "dword");
+            } else {
+                nasm_nonfatal("ELF64 format does not support this"
+                              " use of WRT");
+            }
+        }
+        elf_sect_writeaddr(s, addr, 8);
+        break;
+
+    default:
+        panic();
+    }
+}
+
+static void elfx32_out(int32_t segto, const void *data,
+                       enum out_type type, uint64_t size,
+                       int32_t segment, int32_t wrt)
+{
+    struct elf_section *s;
+    int64_t addr;
+    int reltype, bytes;
+    static struct symlininfo sinfo;
+
+    /*
+     * handle absolute-assembly (structure definitions)
+     */
+    if (segto == NO_SEG) {
+        if (type != OUT_RESERVE)
+            nasm_nonfatal("attempt to assemble code in [ABSOLUTE] space");
+        return;
+    }
+
+    s = raa_read_ptr(section_by_index, segto >> 1);
+    if (!s) {
+        int tempint;            /* ignored */
+        if (segto != elf_section_names(".text", &tempint))
+            nasm_panic("strange segment conditions in ELF driver");
+        else
+            s = sects[nsects - 1];
+    }
+
+    /* again some stabs debugging stuff */
+    sinfo.offset = s->len;
+    /* Adjust to an index of the section table. */
+    sinfo.section = s->shndx - 1;
+    sinfo.segto = segto;
+    sinfo.name = s->name;
+    dfmt->debug_output(TY_DEBUGSYMLIN, &sinfo);
+    /* end of debugging stuff */
+
+    if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in"
+                  " BSS section `%s': ignored", s->name);
+        s->len += realsize(type, size);
+        return;
+    }
+
+    switch (type) {
+    case OUT_RESERVE:
+        if (s->type != SHT_NOBITS) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+                      " non-BSS section `%s': zeroing", s->name);
+            elf_sect_write(s, NULL, size);
+        } else
+            s->len += size;
+        break;
+
+    case OUT_RAWDATA:
+        if (segment != NO_SEG)
+            nasm_panic("OUT_RAWDATA with other than NO_SEG");
+        elf_sect_write(s, data, size);
+        break;
+
+    case OUT_ADDRESS:
+    {
+        int isize = (int)size;
+        int asize = abs((int)size);
+
+        addr = *(int64_t *)data;
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELF format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                switch (isize) {
+                case 1:
+                case -1:
+                    elf_add_reloc(s, segment, addr, R_X86_64_8);
+                    break;
+                case 2:
+                case -2:
+                    elf_add_reloc(s, segment, addr, R_X86_64_16);
+                    break;
+                case 4:
+                    elf_add_reloc(s, segment, addr, R_X86_64_32);
+                    break;
+                case -4:
+                    elf_add_reloc(s, segment, addr, R_X86_64_32S);
+                    break;
+                case 8:
+                case -8:
+                    elf_add_reloc(s, segment, addr, R_X86_64_64);
+                    break;
+                default:
+                    nasm_panic("internal error elfx32-hpa-871");
+                    break;
+                }
+                addr = 0;
+            } else if (wrt == elf_gotpc_sect + 1) {
+                /*
+                 * The user will supply GOT relative to $$. ELF
+                 * will let us have GOT relative to $. So we
+                 * need to fix up the data item by $-$$.
+                 */
+                addr += s->len;
+                elf_add_reloc(s, segment, addr, R_X86_64_GOTPC32);
+                addr = 0;
+            } else if (wrt == elf_gotoff_sect + 1) {
+                nasm_nonfatal("ELFX32 doesn't support "
+                              "R_X86_64_GOTOFF64");
+            } else if (wrt == elf_got_sect + 1) {
+                switch (asize) {
+                case 4:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_GOT32, true);
+                    addr = 0;
+                    break;
+                default:
+                    nasm_nonfatal("invalid ..got reference");
+                    break;
+                }
+            } else if (wrt == elf_sym_sect + 1) {
+                switch (isize) {
+                case 1:
+                case -1:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_8, false);
+                    addr = 0;
+                    break;
+                case 2:
+                case -2:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_16, false);
+                    addr = 0;
+                    break;
+                case 4:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_32, false);
+                    addr = 0;
+                    break;
+                case -4:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_32S, false);
+                    addr = 0;
+                    break;
+                case 8:
+                case -8:
+                    elf_add_gsym_reloc(s, segment, addr, 0,
+                                       R_X86_64_64, false);
+                    addr = 0;
+                    break;
+                default:
+                    nasm_panic("internal error elfx32-hpa-903");
+                    break;
+                }
+            } else if (wrt == elf_plt_sect + 1) {
+                nasm_nonfatal("ELF format cannot produce non-PC-"
+                              "relative PLT references");
+            } else {
+                nasm_nonfatal("ELF format does not support this"
+                              " use of WRT");
+            }
+        }
+        elf_sect_writeaddr(s, addr, asize);
+        break;
+    }
+
+    case OUT_REL1ADR:
+        reltype = R_X86_64_PC8;
+        bytes = 1;
+        goto rel12adr;
+
+    case OUT_REL2ADR:
+        reltype = R_X86_64_PC16;
+        bytes = 2;
+        goto rel12adr;
+
+rel12adr:
+        addr = *(int64_t *)data - size;
+        if (segment == segto)
+            nasm_panic("intra-segment OUT_REL1ADR");
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELF format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, addr, reltype);
+                addr = 0;
+            } else {
+                nasm_nonfatal("unsupported %d-bit ELF relocation", bytes << 3);
+            }
+        }
+        elf_sect_writeaddr(s, addr, bytes);
+        break;
+
+    case OUT_REL4ADR:
+        addr = *(int64_t *)data - size;
+        if (segment == segto)
+            nasm_panic("intra-segment OUT_REL4ADR");
+        if (segment == NO_SEG) {
+            /* Do nothing */
+        } else if (segment & 1) {
+            nasm_nonfatal("ELFX32 format does not support"
+                          " segment base references");
+        } else {
+            if (wrt == NO_SEG) {
+                elf_add_reloc(s, segment, addr, R_X86_64_PC32);
+                addr = 0;
+            } else if (wrt == elf_plt_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_PLT32, true);
+                addr = 0;
+            } else if (wrt == elf_gotpc_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_GOTPCREL, true);
+                addr = 0;
+            } else if (wrt == elf_gotoff_sect + 1 ||
+                       wrt == elf_got_sect + 1) {
+                nasm_nonfatal("invalid ..gotoff reference");
+            } else if (wrt == elf_gottpoff_sect + 1) {
+                elf_add_gsym_reloc(s, segment, addr+size, size,
+                                   R_X86_64_GOTTPOFF, true);
+                addr = 0;
+            } else {
+                nasm_nonfatal("ELFX32 format does not support this use of WRT");
+            }
+        }
+        elf_sect_writeaddr(s, addr, 4);
+        break;
+
+    case OUT_REL8ADR:
+        nasm_nonfatal("32-bit ELF format does not support 64-bit relocations");
+        addr = 0;
+        elf_sect_writeaddr(s, addr, 8);
+        break;
+
+    default:
+        panic();
+    }
+}
+
+/*
+ * Section index/count with a specified overflow value (usually SHN_INDEX,
+ * but 0 for e_shnum.
+ */
+static inline uint16_t elf_shndx(int section, uint16_t overflow)
+{
+    return cpu_to_le16(section < (int)SHN_LORESERVE ? section : overflow);
+}
+
+struct ehdr_common {
+    uint8_t	e_ident[EI_NIDENT];
+    uint16_t    e_type;
+    uint16_t    e_machine;
+    uint32_t	e_version;
+};
+
+union ehdr {
+    Elf32_Ehdr ehdr32;
+    Elf64_Ehdr ehdr64;
+    struct ehdr_common com;
+};
+
+static void elf_write(void)
+{
+    int align;
+    char *p;
+    int i;
+    size_t symtablocal;
+    int sec_shstrtab, sec_symtab, sec_strtab;
+    union ehdr ehdr;
+
+    /*
+     * Add any sections we don't already have:
+     * rel/rela sections for the user sections, debug sections, and
+     * the ELF special sections.
+     */
+
+    sec_debug = nsections;
+    if (dfmt_is_stabs()) {
+        /* in case the debug information is wanted, just add these three sections... */
+        add_sectname("", ".stab");
+        add_sectname("", ".stabstr");
+        add_sectname(efmt->relpfx, ".stab");
+    } else if (dfmt_is_dwarf()) {
+        /* the dwarf debug standard specifies the following ten sections,
+           not all of which are currently implemented,
+           although all of them are defined. */
+        add_sectname("", ".debug_aranges");
+        add_sectname(efmt->relpfx, ".debug_aranges");
+        add_sectname("", ".debug_pubnames");
+        add_sectname("", ".debug_info");
+        add_sectname(efmt->relpfx, ".debug_info");
+        add_sectname("", ".debug_abbrev");
+        add_sectname("", ".debug_line");
+        add_sectname(efmt->relpfx, ".debug_line");
+        add_sectname("", ".debug_frame");
+        add_sectname("", ".debug_loc");
+    }
+
+    sec_shstrtab = add_sectname("", ".shstrtab");
+    sec_symtab   = add_sectname("", ".symtab");
+    sec_strtab   = add_sectname("", ".strtab");
+
+    /*
+     * Build the symbol table and relocation tables.
+     */
+    symtablocal = elf_build_symtab();
+
+    /* Do we need an .symtab_shndx section? */
+    if (symtab_shndx)
+        add_sectname("", ".symtab_shndx");
+
+    for (i = 0; i < nsects; i++) {
+        if (sects[i]->head) {
+            add_sectname(efmt->relpfx, sects[i]->name);
+            sects[i]->rel = efmt->elf_build_reltab(sects[i]->head);
+        }
+    }
+
+    /*
+     * Output the ELF header.
+     */
+    nasm_zero(ehdr);
+
+    /* These fields are in the same place for 32 and 64 bits */
+    memcpy(&ehdr.com.e_ident[EI_MAG0], ELFMAG, SELFMAG);
+    ehdr.com.e_ident[EI_CLASS]      = efmt->ei_class;
+    ehdr.com.e_ident[EI_DATA]       = ELFDATA2LSB;
+    ehdr.com.e_ident[EI_VERSION]    = EV_CURRENT;
+    ehdr.com.e_ident[EI_OSABI]      = elf_osabi;
+    ehdr.com.e_ident[EI_ABIVERSION] = elf_abiver;
+    ehdr.com.e_type                 = cpu_to_le16(ET_REL);
+    ehdr.com.e_machine              = cpu_to_le16(efmt->e_machine);
+    ehdr.com.e_version              = cpu_to_le16(EV_CURRENT);
+
+    if (!efmt->elf64) {
+        ehdr.ehdr32.e_shoff         = cpu_to_le32(sizeof ehdr);
+        ehdr.ehdr32.e_ehsize        = cpu_to_le16(sizeof(Elf32_Ehdr));
+        ehdr.ehdr32.e_shentsize     = cpu_to_le16(sizeof(Elf32_Shdr));
+        ehdr.ehdr32.e_shnum         = elf_shndx(nsections, 0);
+        ehdr.ehdr32.e_shstrndx      = elf_shndx(sec_shstrtab, SHN_XINDEX);
+    } else {
+        ehdr.ehdr64.e_shoff         = cpu_to_le64(sizeof ehdr);
+        ehdr.ehdr64.e_ehsize        = cpu_to_le16(sizeof(Elf64_Ehdr));
+        ehdr.ehdr64.e_shentsize     = cpu_to_le16(sizeof(Elf64_Shdr));
+        ehdr.ehdr64.e_shnum         = elf_shndx(nsections, 0);
+        ehdr.ehdr64.e_shstrndx      = elf_shndx(sec_shstrtab, SHN_XINDEX);
+    }
+
+    nasm_write(&ehdr, sizeof(ehdr), ofile);
+    elf_foffs = sizeof ehdr + efmt->shdr_size * nsections;
+
+    /*
+     * Now output the section header table.
+     */
+    align = ALIGN(elf_foffs, SEC_FILEALIGN) - elf_foffs;
+    elf_foffs += align;
+    elf_nsect = 0;
+    elf_sects = nasm_malloc(sizeof(*elf_sects) * nsections);
+
+    /* SHN_UNDEF */
+    elf_section_header(0, SHT_NULL, 0, NULL, false,
+                       nsections > (int)SHN_LORESERVE ? nsections : 0,
+                       sec_shstrtab >= (int)SHN_LORESERVE ? sec_shstrtab : 0,
+                       0, 0, 0);
+    p = shstrtab + 1;
+
+    /* The normal sections */
+    for (i = 0; i < nsects; i++) {
+        elf_section_header(p - shstrtab, sects[i]->type, sects[i]->flags,
+                           sects[i]->data, true,
+                           sects[i]->len, 0, 0,
+                           sects[i]->align, sects[i]->entsize);
+        p += strlen(p) + 1;
+    }
+
+    /* The debugging sections */
+    if (dfmt_is_stabs()) {
+        /* for debugging information, create the last three sections
+           which are the .stab , .stabstr and .rel.stab sections respectively */
+
+        /* this function call creates the stab sections in memory */
+        stabs_generate();
+
+        if (stabbuf && stabstrbuf && stabrelbuf) {
+            elf_section_header(p - shstrtab, SHT_PROGBITS, 0, stabbuf, false,
+                               stablen, sec_stabstr, 0, 4, 12);
+            p += strlen(p) + 1;
+
+            elf_section_header(p - shstrtab, SHT_STRTAB, 0, stabstrbuf, false,
+                               stabstrlen, 0, 0, 4, 0);
+            p += strlen(p) + 1;
+
+            /* link -> symtable  info -> section to refer to */
+            elf_section_header(p - shstrtab, efmt->reltype, 0,
+                               stabrelbuf, false, stabrellen,
+                               sec_symtab, sec_stab,
+                               efmt->word, efmt->relsize);
+            p += strlen(p) + 1;
+        }
+    } else if (dfmt_is_dwarf()) {
+        /* for dwarf debugging information, create the ten dwarf sections */
+
+        /* this function call creates the dwarf sections in memory */
+	if (dwarf_fsect)
+            dwarf_generate();
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, arangesbuf, false,
+                           arangeslen, 0, 0, 1, 0);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, efmt->reltype, 0, arangesrelbuf, false,
+			   arangesrellen, sec_symtab,
+                           sec_debug_aranges,
+                           efmt->word, efmt->relsize);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, pubnamesbuf,
+                           false, pubnameslen, 0, 0, 1, 0);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, infobuf, false,
+                           infolen, 0, 0, 1, 0);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, efmt->reltype, 0, inforelbuf, false,
+                           inforellen, sec_symtab,
+                           sec_debug_info,
+                           efmt->word, efmt->relsize);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, abbrevbuf, false,
+                           abbrevlen, 0, 0, 1, 0);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, linebuf, false,
+                           linelen, 0, 0, 1, 0);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, efmt->reltype, 0, linerelbuf, false,
+                           linerellen, sec_symtab,
+                           sec_debug_line,
+                           efmt->word, efmt->relsize);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, framebuf, false,
+                           framelen, 0, 0, 8, 0);
+        p += strlen(p) + 1;
+
+        elf_section_header(p - shstrtab, SHT_PROGBITS, 0, locbuf, false,
+                           loclen, 0, 0, 1, 0);
+        p += strlen(p) + 1;
+    }
+
+    /* .shstrtab */
+    elf_section_header(p - shstrtab, SHT_STRTAB, 0, shstrtab, false,
+                       shstrtablen, 0, 0, 1, 0);
+    p += strlen(p) + 1;
+
+    /* .symtab */
+    elf_section_header(p - shstrtab, SHT_SYMTAB, 0, symtab, true,
+                       symtab->datalen, sec_strtab, symtablocal,
+                       efmt->word, efmt->sym_size);
+    p += strlen(p) + 1;
+
+    /* .strtab */
+    elf_section_header(p - shstrtab, SHT_STRTAB, 0, strs, true,
+                       strslen, 0, 0, 1, 0);
+    p += strlen(p) + 1
+;
+    /* .symtab_shndx */
+    if (symtab_shndx) {
+        elf_section_header(p - shstrtab, SHT_SYMTAB_SHNDX, 0,
+                           symtab_shndx, true, symtab_shndx->datalen,
+                           sec_symtab, 0, 1, 0);
+        p += strlen(p) + 1;
+    }
+
+    /* The relocation sections */
+    for (i = 0; i < nsects; i++) {
+        if (sects[i]->rel) {
+            elf_section_header(p - shstrtab, efmt->reltype, 0,
+                               sects[i]->rel, true, sects[i]->rel->datalen,
+                               sec_symtab, sects[i]->shndx,
+                               efmt->word, efmt->relsize);
+            p += strlen(p) + 1;
+        }
+    }
+    fwritezero(align, ofile);
+
+    /*
+     * Now output the sections.
+     */
+    elf_write_sections();
+
+    nasm_free(elf_sects);
+    saa_free(symtab);
+    if (symtab_shndx)
+        saa_free(symtab_shndx);
+}
+
+static size_t nsyms;
+
+static void elf_sym(const struct elf_symbol *sym)
+{
+    int shndx = sym->section;
+
+    /*
+     * Careful here. This relies on sym->section being signed; for
+     * special section indices this value needs to be cast to
+     * (int16_t) so that it sign-extends, however, here SHN_LORESERVE
+     * is used as an unsigned constant.
+     */
+    if (shndx >= (int)SHN_LORESERVE) {
+        if (unlikely(!symtab_shndx)) {
+            /* Create symtab_shndx and fill previous entries with zero */
+            symtab_shndx = saa_init(1);
+            saa_wbytes(symtab_shndx, NULL, nsyms << 2);
+        }
+    } else {
+        shndx = 0;              /* Section index table always write zero */
+    }
+
+    if (symtab_shndx)
+        saa_write32(symtab_shndx, shndx);
+
+    efmt->elf_sym(sym);
+    nsyms++;
+}
+
+static void elf32_sym(const struct elf_symbol *sym)
+{
+    Elf32_Sym sym32;
+
+    sym32.st_name     = cpu_to_le32(sym->strpos);
+    sym32.st_value    = cpu_to_le32(sym->symv.key);
+    sym32.st_size     = cpu_to_le32(sym->size);
+    sym32.st_info     = sym->type;
+    sym32.st_other    = sym->other;
+    sym32.st_shndx    = elf_shndx(sym->section, SHN_XINDEX);
+    saa_wbytes(symtab, &sym32, sizeof sym32);
+}
+
+static void elf64_sym(const struct elf_symbol *sym)
+{
+    Elf64_Sym sym64;
+
+    sym64.st_name     = cpu_to_le32(sym->strpos);
+    sym64.st_value    = cpu_to_le64(sym->symv.key);
+    sym64.st_size     = cpu_to_le64(sym->size);
+    sym64.st_info     = sym->type;
+    sym64.st_other    = sym->other;
+    sym64.st_shndx    = elf_shndx(sym->section, SHN_XINDEX);
+    saa_wbytes(symtab, &sym64, sizeof sym64);
+}
+
+static size_t elf_build_symtab(void)
+{
+    struct elf_symbol *sym, xsym;
+    size_t nlocal;
+    int i;
+
+    symtab       = saa_init(1);
+    symtab_shndx = NULL;
+
+    /*
+     * Zero symbol first as required by spec.
+     */
+    nasm_zero(xsym);
+    elf_sym(&xsym);
+
+    /*
+     * Next, an entry for the file name.
+     */
+    nasm_zero(xsym);
+    xsym.strpos  = 1;
+    xsym.type    = ELF32_ST_INFO(STB_LOCAL, STT_FILE);
+    xsym.section = XSHN_ABS;
+    elf_sym(&xsym);
+
+    /*
+     * Now some standard symbols defining the segments, for relocation
+     * purposes.
+     */
+    nasm_zero(xsym);
+    for (i = 1; i <= nsects; i++) {
+        xsym.type    = ELF64_ST_INFO(STB_LOCAL, STT_SECTION);
+        xsym.section = i;
+        elf_sym(&xsym);
+    }
+
+    /*
+     * dwarf needs symbols for debug sections
+     * which are relocation targets.
+     */
+    if (dfmt_is_dwarf()) {
+        dwarf_infosym   = nsyms;
+        xsym.section    = sec_debug_info;
+        elf_sym(&xsym);
+
+        dwarf_abbrevsym = nsyms;
+        xsym.section    = sec_debug_abbrev;
+        elf_sym(&xsym);
+
+        dwarf_linesym   = nsyms;
+        xsym.section    = sec_debug_line;
+        elf_sym(&xsym);
+    }
+
+    /*
+     * Now the other local symbols.
+     */
+    saa_rewind(syms);
+    while ((sym = saa_rstruct(syms))) {
+        if (!sym_type_local(sym->type))
+            continue;
+
+        elf_sym(sym);
+    }
+
+    nlocal = nsyms;
+
+    /*
+     * Now the global symbols.
+     */
+    saa_rewind(syms);
+    while ((sym = saa_rstruct(syms))) {
+        if (sym_type_local(sym->type))
+            continue;
+
+        elf_sym(sym);
+    }
+
+    return nlocal;
+}
+
+static struct SAA *elf32_build_reltab(const struct elf_reloc *r)
+{
+    struct SAA *s;
+    int32_t global_offset;
+    Elf32_Rel rel32;
+
+    if (!r)
+        return NULL;
+
+    s = saa_init(1L);
+
+    /*
+     * How to onvert from a global placeholder to a real symbol index;
+     * the +2 refers to the two special entries, the null entry and
+     * the filename entry.
+     */
+    global_offset = -GLOBAL_TEMP_BASE + nsects + nlocals + ndebugs + 2;
+
+    while (r) {
+        int32_t sym = r->symbol;
+
+        if (sym >= GLOBAL_TEMP_BASE)
+            sym += global_offset;
+
+        rel32.r_offset    = cpu_to_le32(r->address);
+        rel32.r_info      = cpu_to_le32(ELF32_R_INFO(sym, r->type));
+        saa_wbytes(s, &rel32, sizeof rel32);
+
+        r = r->next;
+    }
+
+    return s;
+}
+
+static struct SAA *elfx32_build_reltab(const struct elf_reloc *r)
+{
+    struct SAA *s;
+    int32_t global_offset;
+    Elf32_Rela rela32;
+
+    if (!r)
+        return NULL;
+
+    s = saa_init(1L);
+
+    /*
+     * How to onvert from a global placeholder to a real symbol index;
+     * the +2 refers to the two special entries, the null entry and
+     * the filename entry.
+     */
+    global_offset = -GLOBAL_TEMP_BASE + nsects + nlocals + ndebugs + 2;
+
+    while (r) {
+        int32_t sym = r->symbol;
+
+        if (sym >= GLOBAL_TEMP_BASE)
+            sym += global_offset;
+
+        rela32.r_offset   = cpu_to_le32(r->address);
+        rela32.r_info     = cpu_to_le32(ELF32_R_INFO(sym, r->type));
+        rela32.r_addend   = cpu_to_le32(r->offset);
+        saa_wbytes(s, &rela32, sizeof rela32);
+
+        r = r->next;
+    }
+
+    return s;
+}
+
+static struct SAA *elf64_build_reltab(const struct elf_reloc *r)
+{
+    struct SAA *s;
+    int32_t global_offset;
+    Elf64_Rela rela64;
+
+    if (!r)
+        return NULL;
+
+    s = saa_init(1L);
+
+    /*
+     * How to onvert from a global placeholder to a real symbol index;
+     * the +2 refers to the two special entries, the null entry and
+     * the filename entry.
+     */
+    global_offset = -GLOBAL_TEMP_BASE + nsects + nlocals + ndebugs + 2;
+
+    while (r) {
+        int32_t sym = r->symbol;
+
+        if (sym >= GLOBAL_TEMP_BASE)
+            sym += global_offset;
+
+        rela64.r_offset   = cpu_to_le64(r->address);
+        rela64.r_info     = cpu_to_le64(ELF64_R_INFO(sym, r->type));
+        rela64.r_addend   = cpu_to_le64(r->offset);
+        saa_wbytes(s, &rela64, sizeof rela64);
+
+        r = r->next;
+    }
+
+    return s;
+}
+
+static void elf_section_header(int name, int type, uint64_t flags,
+                               void *data, bool is_saa, uint64_t datalen,
+                               int link, int info,
+                               uint64_t align, uint64_t entsize)
+{
+    elf_sects[elf_nsect].data = data;
+    elf_sects[elf_nsect].len = datalen;
+    elf_sects[elf_nsect].is_saa = is_saa;
+    elf_nsect++;
+
+    if (!efmt->elf64) {
+        Elf32_Shdr  shdr;
+
+        shdr.sh_name         = cpu_to_le32(name);
+        shdr.sh_type         = cpu_to_le32(type);
+        shdr.sh_flags        = cpu_to_le32(flags);
+        shdr.sh_addr         = 0;
+        shdr.sh_offset       = cpu_to_le32(type == SHT_NULL ? 0 : elf_foffs);
+        shdr.sh_size         = cpu_to_le32(datalen);
+        if (data)
+            elf_foffs += ALIGN(datalen, SEC_FILEALIGN);
+        shdr.sh_link         = cpu_to_le32(link);
+        shdr.sh_info         = cpu_to_le32(info);
+        shdr.sh_addralign    = cpu_to_le32(align);
+        shdr.sh_entsize      = cpu_to_le32(entsize);
+
+        nasm_write(&shdr, sizeof shdr, ofile);
+    } else {
+        Elf64_Shdr  shdr;
+
+        shdr.sh_name         = cpu_to_le32(name);
+        shdr.sh_type         = cpu_to_le32(type);
+        shdr.sh_flags        = cpu_to_le64(flags);
+        shdr.sh_addr         = 0;
+        shdr.sh_offset       = cpu_to_le64(type == SHT_NULL ? 0 : elf_foffs);
+        shdr.sh_size         = cpu_to_le64(datalen);
+        if (data)
+            elf_foffs += ALIGN(datalen, SEC_FILEALIGN);
+        shdr.sh_link        = cpu_to_le32(link);
+        shdr.sh_info        = cpu_to_le32(info);
+        shdr.sh_addralign   = cpu_to_le64(align);
+        shdr.sh_entsize     = cpu_to_le64(entsize);
+
+        nasm_write(&shdr, sizeof shdr, ofile);
+    }
+}
+
+static void elf_write_sections(void)
+{
+    int i;
+    for (i = 0; i < elf_nsect; i++)
+        if (elf_sects[i].data) {
+            int32_t len = elf_sects[i].len;
+            int32_t reallen = ALIGN(len, SEC_FILEALIGN);
+            int32_t align = reallen - len;
+            if (elf_sects[i].is_saa)
+                saa_fpwrite(elf_sects[i].data, ofile);
+            else
+                nasm_write(elf_sects[i].data, len, ofile);
+            fwritezero(align, ofile);
+        }
+}
+
+static void elf_sect_write(struct elf_section *sect, const void *data, size_t len)
+{
+    saa_wbytes(sect->data, data, len);
+    sect->len += len;
+}
+
+static void elf_sect_writeaddr(struct elf_section *sect, int64_t data, size_t len)
+{
+    saa_writeaddr(sect->data, data, len);
+    sect->len += len;
+}
+
+static void elf_sectalign(int32_t seg, unsigned int value)
+{
+    struct elf_section *s;
+
+    s = raa_read_ptr(section_by_index, seg >> 1);
+    if (!s || !is_power2(value))
+        return;
+
+    if (value > s->align)
+        s->align = value;
+}
+
+extern macros_t elf_stdmac[];
+
+/* Claim "elf" as a pragma namespace, for the future */
+static const struct pragma_facility elf_pragma_list[] =
+{
+    { "elf", NULL },
+    { NULL, NULL }          /* Implements the canonical output name */
+};
+
+
+static const struct dfmt elf32_df_dwarf = {
+    "ELF32 (i386) dwarf (newer)",
+    "dwarf",
+    dwarf32_init,
+    dwarf_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    debug_typevalue,
+    dwarf_output,
+    dwarf_cleanup,
+    NULL                        /* pragma list */
+};
+
+static const struct dfmt elf32_df_stabs = {
+    "ELF32 (i386) stabs (older)",
+    "stabs",
+    null_debug_init,
+    stabs_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    debug_typevalue,
+    stabs_output,
+    stabs_cleanup,
+    NULL                        /* pragma list */
+};
+
+static const struct dfmt * const elf32_debugs_arr[3] =
+  { &elf32_df_dwarf, &elf32_df_stabs, NULL };
+
+const struct ofmt of_elf32 = {
+    "ELF32 (i386) (Linux, most Unix variants)",
+    "elf32",
+    ".o",
+    0,
+    32,
+    elf32_debugs_arr,
+    &elf32_df_dwarf,
+    elf_stdmac,
+    elf32_init,
+    null_reset,
+    nasm_do_legacy_output,
+    elf32_out,
+    elf_deflabel,
+    elf_section_names,
+    NULL,
+    elf_sectalign,
+    null_segbase,
+    elf_directive,
+    elf_cleanup,
+    elf_pragma_list,
+};
+
+static const struct dfmt elf64_df_dwarf = {
+    "ELF64 (x86-64) dwarf (newer)",
+    "dwarf",
+    dwarf64_init,
+    dwarf_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    debug_typevalue,
+    dwarf_output,
+    dwarf_cleanup,
+    NULL                        /* pragma list */
+};
+
+static const struct dfmt elf64_df_stabs = {
+    "ELF64 (x86-64) stabs (older)",
+    "stabs",
+    null_debug_init,
+    stabs_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    debug_typevalue,
+    stabs_output,
+    stabs_cleanup,
+    NULL                        /* pragma list */
+};
+
+static const struct dfmt * const elf64_debugs_arr[3] =
+  { &elf64_df_dwarf, &elf64_df_stabs, NULL };
+
+const struct ofmt of_elf64 = {
+    "ELF64 (x86-64) (Linux, most Unix variants)",
+    "elf64",
+    ".o",
+    0,
+    64,
+    elf64_debugs_arr,
+    &elf64_df_dwarf,
+    elf_stdmac,
+    elf64_init,
+    null_reset,
+    nasm_do_legacy_output,
+    elf64_out,
+    elf_deflabel,
+    elf_section_names,
+    NULL,
+    elf_sectalign,
+    null_segbase,
+    elf_directive,
+    elf_cleanup,
+    elf_pragma_list,
+};
+
+static const struct dfmt elfx32_df_dwarf = {
+    "ELFx32 (x86-64) dwarf (newer)",
+    "dwarf",
+    dwarfx32_init,
+    dwarf_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    debug_typevalue,
+    dwarf_output,
+    dwarf_cleanup,
+    NULL                        /* pragma list */
+};
+
+static const struct dfmt elfx32_df_stabs = {
+    "ELFx32 (x86-64) stabs (older)",
+    "stabs",
+    null_debug_init,
+    stabs_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    debug_typevalue,
+    stabs_output,
+    stabs_cleanup,
+    elf_pragma_list,
+};
+
+static const struct dfmt * const elfx32_debugs_arr[3] =
+  { &elfx32_df_dwarf, &elfx32_df_stabs, NULL };
+
+const struct ofmt of_elfx32 = {
+    "ELFx32 (ELF32 for x86-64) (Linux)",
+    "elfx32",
+    ".o",
+    0,
+    64,
+    elfx32_debugs_arr,
+    &elfx32_df_dwarf,
+    elf_stdmac,
+    elfx32_init,
+    null_reset,
+    nasm_do_legacy_output,
+    elfx32_out,
+    elf_deflabel,
+    elf_section_names,
+    NULL,
+    elf_sectalign,
+    null_segbase,
+    elf_directive,
+    elf_cleanup,
+    NULL                        /* pragma list */
+};
+
+static bool is_elf64(void)
+{
+	return ofmt == &of_elf64;
+}
+
+static bool is_elf32(void)
+{
+	return ofmt == &of_elf32;
+}
+
+static bool is_elfx32(void)
+{
+	return ofmt == &of_elfx32;
+}
+
+static bool dfmt_is_stabs(void)
+{
+	return dfmt == &elf32_df_stabs ||
+               dfmt == &elfx32_df_stabs ||
+               dfmt == &elf64_df_stabs;
+}
+
+static bool dfmt_is_dwarf(void)
+{
+	return dfmt == &elf32_df_dwarf ||
+               dfmt == &elfx32_df_dwarf ||
+               dfmt == &elf64_df_dwarf;
+}
+
+/* common debugging routines */
+static void debug_typevalue(int32_t type)
+{
+    int32_t stype, ssize;
+    switch (TYM_TYPE(type)) {
+        case TY_LABEL:
+            ssize = 0;
+            stype = STT_NOTYPE;
+            break;
+        case TY_BYTE:
+            ssize = 1;
+            stype = STT_OBJECT;
+            break;
+        case TY_WORD:
+            ssize = 2;
+            stype = STT_OBJECT;
+            break;
+        case TY_DWORD:
+            ssize = 4;
+            stype = STT_OBJECT;
+            break;
+        case TY_FLOAT:
+            ssize = 4;
+            stype = STT_OBJECT;
+            break;
+        case TY_QWORD:
+            ssize = 8;
+            stype = STT_OBJECT;
+            break;
+        case TY_TBYTE:
+            ssize = 10;
+            stype = STT_OBJECT;
+            break;
+        case TY_OWORD:
+            ssize = 16;
+            stype = STT_OBJECT;
+            break;
+        case TY_YWORD:
+            ssize = 32;
+            stype = STT_OBJECT;
+            break;
+        case TY_ZWORD:
+            ssize = 64;
+            stype = STT_OBJECT;
+            break;
+        case TY_COMMON:
+            ssize = 0;
+            stype = STT_COMMON;
+            break;
+        case TY_SEG:
+            ssize = 0;
+            stype = STT_SECTION;
+            break;
+        case TY_EXTERN:
+            ssize = 0;
+            stype = STT_NOTYPE;
+            break;
+        case TY_EQU:
+            ssize = 0;
+            stype = STT_NOTYPE;
+            break;
+        default:
+            ssize = 0;
+            stype = STT_NOTYPE;
+            break;
+    }
+    /* Set type and size info on most recently seen symbol if we haven't set it already.
+       But avoid setting size info on object (data) symbols in absolute sections (which
+       is primarily structs); some environments get confused with non-zero-extent absolute
+       object symbols and end up showing them in backtraces for NULL fn pointer calls. */
+    if (stype == STT_OBJECT && lastsym && !lastsym->type && lastsym->section != XSHN_ABS) {
+        lastsym->size = ssize;
+        lastsym->type = stype;
+    }
+}
+
+/* stabs debugging routines */
+
+static void stabs_linenum(const char *filename, int32_t linenumber, int32_t segto)
+{
+    (void)segto;
+    if (!stabs_filename) {
+        stabs_filename = nasm_malloc(strlen(filename) + 1);
+        strcpy(stabs_filename, filename);
+    } else {
+        if (strcmp(stabs_filename, filename)) {
+            /* yep, a memory leak...this program is one-shot anyway, so who cares...
+               in fact, this leak comes in quite handy to maintain a list of files
+               encountered so far in the symbol lines... */
+
+            /* why not nasm_free(stabs_filename); we're done with the old one */
+
+            stabs_filename = nasm_malloc(strlen(filename) + 1);
+            strcpy(stabs_filename, filename);
+        }
+    }
+    debug_immcall = 1;
+    currentline = linenumber;
+}
+
+static void stabs_output(int type, void *param)
+{
+    struct symlininfo *s;
+    struct linelist *el;
+    if (type == TY_DEBUGSYMLIN) {
+        if (debug_immcall) {
+            s = (struct symlininfo *)param;
+            if (!(sects[s->section]->flags & SHF_EXECINSTR))
+                return; /* line info is only collected for executable sections */
+            numlinestabs++;
+            el = nasm_malloc(sizeof(struct linelist));
+            el->info.offset = s->offset;
+            el->info.section = s->section;
+            el->info.name = s->name;
+            el->line = currentline;
+            el->filename = stabs_filename;
+            el->next = 0;
+            if (stabslines) {
+                stabslines->last->next = el;
+                stabslines->last = el;
+            } else {
+                stabslines = el;
+                stabslines->last = el;
+            }
+        }
+    }
+    debug_immcall = 0;
+}
+
+/* for creating the .stab , .stabstr and .rel.stab sections in memory */
+
+static void stabs_generate(void)
+{
+    int i, numfiles, strsize, numstabs = 0, currfile, mainfileindex;
+    uint8_t *sbuf, *ssbuf, *rbuf, *sptr, *rptr;
+    char **allfiles;
+    int *fileidx;
+
+    struct linelist *ptr;
+
+    ptr = stabslines;
+
+    allfiles = nasm_zalloc(numlinestabs * sizeof(char *));
+    numfiles = 0;
+    while (ptr) {
+        if (numfiles == 0) {
+            allfiles[0] = ptr->filename;
+            numfiles++;
+        } else {
+            for (i = 0; i < numfiles; i++) {
+                if (!strcmp(allfiles[i], ptr->filename))
+                    break;
+            }
+            if (i >= numfiles) {
+                allfiles[i] = ptr->filename;
+                numfiles++;
+            }
+        }
+        ptr = ptr->next;
+    }
+    strsize = 1;
+    fileidx = nasm_malloc(numfiles * sizeof(int));
+    for (i = 0; i < numfiles; i++) {
+        fileidx[i] = strsize;
+        strsize += strlen(allfiles[i]) + 1;
+    }
+    currfile = mainfileindex = 0;
+    for (i = 0; i < numfiles; i++) {
+        if (!strcmp(allfiles[i], elf_module)) {
+            currfile = mainfileindex = i;
+            break;
+        }
+    }
+
+    /*
+     * worst case size of the stab buffer would be:
+     * the sourcefiles changes each line, which would mean 1 SOL, 1 SYMLIN per line
+     * plus one "ending" entry
+     */
+    sbuf = nasm_malloc((numlinestabs * 2 + 4) *
+                                    sizeof(struct stabentry));
+    ssbuf = nasm_malloc(strsize);
+    rbuf = nasm_malloc(numlinestabs * (is_elf64() ? 16 : 8) * (2 + 3));
+    rptr = rbuf;
+
+    for (i = 0; i < numfiles; i++)
+        strcpy((char *)ssbuf + fileidx[i], allfiles[i]);
+    ssbuf[0] = 0;
+
+    stabstrlen = strsize;       /* set global variable for length of stab strings */
+
+    sptr = sbuf;
+    ptr = stabslines;
+    numstabs = 0;
+
+    if (ptr) {
+        /*
+         * this is the first stab, its strx points to the filename of the
+         * source-file, the n_desc field should be set to the number
+         * of remaining stabs
+         */
+        WRITE_STAB(sptr, fileidx[0], 0, 0, 0, stabstrlen);
+
+        /* this is the stab for the main source file */
+        WRITE_STAB(sptr, fileidx[mainfileindex], N_SO, 0, 0, 0);
+
+        /* relocation table entry */
+
+        /*
+         * Since the symbol table has two entries before
+         * the section symbols, the index in the info.section
+         * member must be adjusted by adding 2
+         */
+
+        if (is_elf32()) {
+            WRITELONG(rptr, (sptr - sbuf) - 4);
+            WRITELONG(rptr, ((ptr->info.section + 2) << 8) | R_386_32);
+        } else if (is_elfx32()) {
+            WRITELONG(rptr, (sptr - sbuf) - 4);
+            WRITELONG(rptr, ((ptr->info.section + 2) << 8) | R_X86_64_32);
+            WRITELONG(rptr, 0);
+        } else {
+            nasm_assert(is_elf64());
+            WRITEDLONG(rptr, (int64_t)(sptr - sbuf) - 4);
+            WRITELONG(rptr, R_X86_64_32);
+            WRITELONG(rptr, ptr->info.section + 2);
+            WRITEDLONG(rptr, 0);
+        }
+        numstabs++;
+    }
+
+    if (is_elf32()) {
+        while (ptr) {
+            if (strcmp(allfiles[currfile], ptr->filename)) {
+                /* oops file has changed... */
+                for (i = 0; i < numfiles; i++)
+                    if (!strcmp(allfiles[i], ptr->filename))
+                        break;
+                currfile = i;
+                WRITE_STAB(sptr, fileidx[currfile], N_SOL, 0, 0,
+                           ptr->info.offset);
+                numstabs++;
+
+                /* relocation table entry */
+                WRITELONG(rptr, (sptr - sbuf) - 4);
+                WRITELONG(rptr, ((ptr->info.section + 2) << 8) | R_386_32);
+            }
+
+            WRITE_STAB(sptr, 0, N_SLINE, 0, ptr->line, ptr->info.offset);
+            numstabs++;
+
+            /* relocation table entry */
+            WRITELONG(rptr, (sptr - sbuf) - 4);
+            WRITELONG(rptr, ((ptr->info.section + 2) << 8) | R_386_32);
+
+            ptr = ptr->next;
+        }
+    } else if (is_elfx32()) {
+        while (ptr) {
+            if (strcmp(allfiles[currfile], ptr->filename)) {
+                /* oops file has changed... */
+                for (i = 0; i < numfiles; i++)
+                    if (!strcmp(allfiles[i], ptr->filename))
+                        break;
+                currfile = i;
+                WRITE_STAB(sptr, fileidx[currfile], N_SOL, 0, 0,
+                           ptr->info.offset);
+                numstabs++;
+
+                /* relocation table entry */
+                WRITELONG(rptr, (sptr - sbuf) - 4);
+                WRITELONG(rptr, ((ptr->info.section + 2) << 8) | R_X86_64_32);
+                WRITELONG(rptr, ptr->info.offset);
+            }
+
+            WRITE_STAB(sptr, 0, N_SLINE, 0, ptr->line, ptr->info.offset);
+            numstabs++;
+
+            /* relocation table entry */
+            WRITELONG(rptr, (sptr - sbuf) - 4);
+            WRITELONG(rptr, ((ptr->info.section + 2) << 8) | R_X86_64_32);
+            WRITELONG(rptr, ptr->info.offset);
+
+            ptr = ptr->next;
+        }
+    } else {
+        nasm_assert(is_elf64());
+        while (ptr) {
+            if (strcmp(allfiles[currfile], ptr->filename)) {
+                /* oops file has changed... */
+                for (i = 0; i < numfiles; i++)
+                    if (!strcmp(allfiles[i], ptr->filename))
+                        break;
+                currfile = i;
+                WRITE_STAB(sptr, fileidx[currfile], N_SOL, 0, 0,
+                           ptr->info.offset);
+                numstabs++;
+
+                /* relocation table entry */
+                WRITEDLONG(rptr, (int64_t)(sptr - sbuf) - 4);
+                WRITELONG(rptr, R_X86_64_32);
+                WRITELONG(rptr, ptr->info.section + 2);
+                WRITEDLONG(rptr, ptr->info.offset);
+            }
+
+            WRITE_STAB(sptr, 0, N_SLINE, 0, ptr->line, ptr->info.offset);
+            numstabs++;
+
+            /* relocation table entry */
+            WRITEDLONG(rptr, (int64_t)(sptr - sbuf) - 4);
+            WRITELONG(rptr, R_X86_64_32);
+            WRITELONG(rptr, ptr->info.section + 2);
+            WRITEDLONG(rptr, ptr->info.offset);
+
+            ptr = ptr->next;
+        }
+    }
+
+    /* this is an "ending" token */
+    WRITE_STAB(sptr, 0, N_SO, 0, 0, 0);
+    numstabs++;
+
+    ((struct stabentry *)sbuf)->n_desc = numstabs;
+
+    nasm_free(allfiles);
+    nasm_free(fileidx);
+
+    stablen = (sptr - sbuf);
+    stabrellen = (rptr - rbuf);
+    stabrelbuf = rbuf;
+    stabbuf = sbuf;
+    stabstrbuf = ssbuf;
+}
+
+static void stabs_cleanup(void)
+{
+    struct linelist *ptr, *del;
+    if (!stabslines)
+        return;
+
+    ptr = stabslines;
+    while (ptr) {
+        del = ptr;
+        ptr = ptr->next;
+        nasm_free(del);
+    }
+
+    nasm_free(stabbuf);
+    nasm_free(stabrelbuf);
+    nasm_free(stabstrbuf);
+}
+
+/* dwarf routines */
+
+static void dwarf_init_common(const struct dwarf_format *fmt)
+{
+    dwfmt = fmt;
+    ndebugs = 3; /* 3 debug symbols */
+}
+
+static void dwarf32_init(void)
+{
+    static const struct dwarf_format dwfmt32 = {
+        2,                          /* DWARF 2 */
+        /* section version numbers: */
+        { 2,                        /* .debug_aranges */
+          0,                        /* .rela.debug_aranges */
+          2,                        /* .debug_pubnames */
+          2,                        /* .debug_info */
+          0,                        /* .rela.debug_info */
+          0,                        /* .debug_abbrev */
+          2,                        /* .debug_line */
+          0,                        /* .rela.debug_line */
+          1,                        /* .debug_frame */
+          0 }                       /* .debug_loc */
+    };
+    dwarf_init_common(&dwfmt32);
+}
+
+static void dwarfx32_init(void)
+{
+    static const struct dwarf_format dwfmtx32 = {
+        3,                          /* DWARF 3 */
+        /* section version numbers: */
+        { 2,                        /* .debug_aranges */
+          0,                        /* .rela.debug_aranges */
+          2,                        /* .debug_pubnames */
+          3,                        /* .debug_info */
+          0,                        /* .rela.debug_info */
+          0,                        /* .debug_abbrev */
+          3,                        /* .debug_line */
+          0,                        /* .rela.debug_line */
+          3,                        /* .debug_frame */
+          0 }                       /* .debug_loc */
+    };
+    dwarf_init_common(&dwfmtx32);
+}
+
+static void dwarf64_init(void)
+{
+    static const struct dwarf_format dwfmt64 = {
+        3,                          /* DWARF 3 */
+        /* section version numbers: */
+        { 2,                        /* .debug_aranges */
+          0,                        /* .rela.debug_aranges */
+          2,                        /* .debug_pubnames */
+          3,                        /* .debug_info */
+          0,                        /* .rela.debug_info */
+          0,                        /* .debug_abbrev */
+          3,                        /* .debug_line */
+          0,                        /* .rela.debug_line */
+          3,                        /* .debug_frame */
+          0 }                       /* .debug_loc */
+    };
+    dwarf_init_common(&dwfmt64);
+}
+
+static void dwarf_linenum(const char *filename, int32_t linenumber,
+                            int32_t segto)
+{
+    (void)segto;
+    dwarf_findfile(filename);
+    debug_immcall = 1;
+    currentline = linenumber;
+}
+
+/* called from elf_out with type == TY_DEBUGSYMLIN */
+static void dwarf_output(int type, void *param)
+{
+    int ln, aa, inx, maxln, soc;
+    struct symlininfo *s;
+    struct SAA *plinep;
+
+    (void)type;
+
+    s = (struct symlininfo *)param;
+
+    /* line number info is only gathered for executable sections */
+    if (!(sects[s->section]->flags & SHF_EXECINSTR))
+        return;
+
+    /* Check if section index has changed */
+    if (!(dwarf_csect && (dwarf_csect->section) == (s->section)))
+        dwarf_findsect(s->section);
+
+    /* do nothing unless line or file has changed */
+    if (!debug_immcall)
+        return;
+
+    ln = currentline - dwarf_csect->line;
+    aa = s->offset - dwarf_csect->offset;
+    inx = dwarf_clist->line;
+    plinep = dwarf_csect->psaa;
+    /* check for file change */
+    if (!(inx == dwarf_csect->file)) {
+        saa_write8(plinep,DW_LNS_set_file);
+        saa_write8(plinep,inx);
+        dwarf_csect->file = inx;
+    }
+    /* check for line change */
+    if (ln) {
+        /* test if in range of special op code */
+        maxln = line_base + line_range;
+        soc = (ln - line_base) + (line_range * aa) + opcode_base;
+        if (ln >= line_base && ln < maxln && soc < 256) {
+            saa_write8(plinep,soc);
+        } else {
+            saa_write8(plinep,DW_LNS_advance_line);
+            saa_wleb128s(plinep,ln);
+            if (aa) {
+                saa_write8(plinep,DW_LNS_advance_pc);
+                saa_wleb128u(plinep,aa);
+            }
+            saa_write8(plinep,DW_LNS_copy);
+        }
+        dwarf_csect->line = currentline;
+        dwarf_csect->offset = s->offset;
+    }
+
+    /* show change handled */
+    debug_immcall = 0;
+}
+
+
+static void dwarf_generate(void)
+{
+    uint8_t *pbuf;
+    int indx;
+    struct linelist *ftentry;
+    struct SAA *paranges, *ppubnames, *pinfo, *pabbrev, *plines, *plinep;
+    struct SAA *parangesrel, *plinesrel, *pinforel;
+    struct sectlist *psect;
+    size_t saalen, linepoff, totlen, highaddr;
+
+    if (is_elf32()) {
+        /* write epilogues for each line program range */
+        /* and build aranges section */
+        paranges = saa_init(1L);
+        parangesrel = saa_init(1L);
+        saa_write16(paranges, dwfmt->sect_version[DWARF_ARANGES]);
+        saa_write32(parangesrel, paranges->datalen+4);
+        saa_write32(parangesrel, (dwarf_infosym << 8) +  R_386_32); /* reloc to info */
+        saa_write32(paranges,0);    /* offset into info */
+        saa_write8(paranges,4);     /* pointer size */
+        saa_write8(paranges,0);     /* not segmented */
+        saa_write32(paranges,0);    /* padding */
+        /* iterate though sectlist entries */
+        psect = dwarf_fsect;
+        totlen = 0;
+        highaddr = 0;
+        for (indx = 0; indx < dwarf_nsections; indx++) {
+            plinep = psect->psaa;
+            /* Line Number Program Epilogue */
+            saa_write8(plinep,2);           /* std op 2 */
+            saa_write8(plinep,(sects[psect->section]->len)-psect->offset);
+            saa_write8(plinep,DW_LNS_extended_op);
+            saa_write8(plinep,1);           /* operand length */
+            saa_write8(plinep,DW_LNE_end_sequence);
+            totlen += plinep->datalen;
+            /* range table relocation entry */
+            saa_write32(parangesrel, paranges->datalen + 4);
+            saa_write32(parangesrel, ((uint32_t) (psect->section + 2) << 8) +  R_386_32);
+            /* range table entry */
+            saa_write32(paranges,0x0000);   /* range start */
+            saa_write32(paranges,sects[psect->section]->len); /* range length */
+            highaddr += sects[psect->section]->len;
+            /* done with this entry */
+            psect = psect->next;
+        }
+        saa_write32(paranges,0);    /* null address */
+        saa_write32(paranges,0);    /* null length */
+        saalen = paranges->datalen;
+        arangeslen = saalen + 4;
+        arangesbuf = pbuf = nasm_malloc(arangeslen);
+        WRITELONG(pbuf,saalen);     /* initial length */
+        saa_rnbytes(paranges, pbuf, saalen);
+        saa_free(paranges);
+    } else if (is_elfx32()) {
+        /* write epilogues for each line program range */
+        /* and build aranges section */
+        paranges = saa_init(1L);
+        parangesrel = saa_init(1L);
+        saa_write16(paranges, dwfmt->sect_version[DWARF_ARANGES]);
+        saa_write32(parangesrel, paranges->datalen+4);
+        saa_write32(parangesrel, (dwarf_infosym << 8) +  R_X86_64_32); /* reloc to info */
+        saa_write32(parangesrel, 0);
+        saa_write32(paranges,0);            /* offset into info */
+        saa_write8(paranges,4);             /* pointer size */
+        saa_write8(paranges,0);             /* not segmented */
+        saa_write32(paranges,0);            /* padding */
+        /* iterate though sectlist entries */
+        psect = dwarf_fsect;
+        totlen = 0;
+        highaddr = 0;
+        for (indx = 0; indx < dwarf_nsections; indx++)  {
+            plinep = psect->psaa;
+            /* Line Number Program Epilogue */
+            saa_write8(plinep,2);			/* std op 2 */
+            saa_write8(plinep,(sects[psect->section]->len)-psect->offset);
+            saa_write8(plinep,DW_LNS_extended_op);
+            saa_write8(plinep,1);			/* operand length */
+            saa_write8(plinep,DW_LNE_end_sequence);
+            totlen += plinep->datalen;
+            /* range table relocation entry */
+            saa_write32(parangesrel, paranges->datalen + 4);
+            saa_write32(parangesrel, ((uint32_t) (psect->section + 2) << 8) +  R_X86_64_32);
+            saa_write32(parangesrel, (uint32_t) 0);
+            /* range table entry */
+            saa_write32(paranges,0x0000);		/* range start */
+            saa_write32(paranges,sects[psect->section]->len);	/* range length */
+            highaddr += sects[psect->section]->len;
+            /* done with this entry */
+            psect = psect->next;
+        }
+        saa_write32(paranges,0);		/* null address */
+        saa_write32(paranges,0);		/* null length */
+        saalen = paranges->datalen;
+        arangeslen = saalen + 4;
+        arangesbuf = pbuf = nasm_malloc(arangeslen);
+        WRITELONG(pbuf,saalen);			/* initial length */
+        saa_rnbytes(paranges, pbuf, saalen);
+        saa_free(paranges);
+    } else {
+        nasm_assert(is_elf64());
+        /* write epilogues for each line program range */
+        /* and build aranges section */
+        paranges = saa_init(1L);
+        parangesrel = saa_init(1L);
+        saa_write16(paranges, dwfmt->sect_version[DWARF_ARANGES]);
+        saa_write64(parangesrel, paranges->datalen+4);
+        saa_write64(parangesrel, (dwarf_infosym << 32) +  R_X86_64_32); /* reloc to info */
+        saa_write64(parangesrel, 0);
+        saa_write32(paranges,0);            /* offset into info */
+        saa_write8(paranges,8);             /* pointer size */
+        saa_write8(paranges,0);             /* not segmented */
+        saa_write32(paranges,0);            /* padding */
+        /* iterate though sectlist entries */
+        psect = dwarf_fsect;
+        totlen = 0;
+        highaddr = 0;
+        for (indx = 0; indx < dwarf_nsections; indx++) {
+            plinep = psect->psaa;
+            /* Line Number Program Epilogue */
+            saa_write8(plinep,2);			/* std op 2 */
+            saa_write8(plinep,(sects[psect->section]->len)-psect->offset);
+            saa_write8(plinep,DW_LNS_extended_op);
+            saa_write8(plinep,1);			/* operand length */
+            saa_write8(plinep,DW_LNE_end_sequence);
+            totlen += plinep->datalen;
+            /* range table relocation entry */
+            saa_write64(parangesrel, paranges->datalen + 4);
+            saa_write64(parangesrel, ((uint64_t) (psect->section + 2) << 32) +  R_X86_64_64);
+            saa_write64(parangesrel, (uint64_t) 0);
+            /* range table entry */
+            saa_write64(paranges,0x0000);		/* range start */
+            saa_write64(paranges,sects[psect->section]->len);	/* range length */
+            highaddr += sects[psect->section]->len;
+            /* done with this entry */
+            psect = psect->next;
+        }
+        saa_write64(paranges,0);		/* null address */
+        saa_write64(paranges,0);		/* null length */
+        saalen = paranges->datalen;
+        arangeslen = saalen + 4;
+        arangesbuf = pbuf = nasm_malloc(arangeslen);
+        WRITELONG(pbuf,saalen);			/* initial length */
+        saa_rnbytes(paranges, pbuf, saalen);
+        saa_free(paranges);
+    }
+
+    /* build rela.aranges section */
+    arangesrellen = saalen = parangesrel->datalen;
+    arangesrelbuf = pbuf = nasm_malloc(arangesrellen);
+    saa_rnbytes(parangesrel, pbuf, saalen);
+    saa_free(parangesrel);
+
+    /* build pubnames section */
+    if (0) {
+        ppubnames = saa_init(1L);
+        saa_write16(ppubnames,dwfmt->sect_version[DWARF_PUBNAMES]);
+        saa_write32(ppubnames,0);   /* offset into info */
+        saa_write32(ppubnames,0);   /* space used in info */
+        saa_write32(ppubnames,0);   /* end of list */
+        saalen = ppubnames->datalen;
+        pubnameslen = saalen + 4;
+        pubnamesbuf = pbuf = nasm_malloc(pubnameslen);
+        WRITELONG(pbuf,saalen);     /* initial length */
+        saa_rnbytes(ppubnames, pbuf, saalen);
+        saa_free(ppubnames);
+    } else {
+        /* Don't write a section without actual information */
+        pubnameslen = 0;
+    }
+
+    if (is_elf32()) {
+        /* build info section */
+        pinfo = saa_init(1L);
+        pinforel = saa_init(1L);
+        saa_write16(pinfo, dwfmt->sect_version[DWARF_INFO]);
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, (dwarf_abbrevsym << 8) +  R_386_32); /* reloc to abbrev */
+        saa_write32(pinfo,0);       /* offset into abbrev */
+        saa_write8(pinfo,4);        /* pointer size */
+        saa_write8(pinfo,1);        /* abbrviation number LEB128u */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, ((dwarf_fsect->section + 2) << 8) +  R_386_32);
+        saa_write32(pinfo,0);       /* DW_AT_low_pc */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, ((dwarf_fsect->section + 2) << 8) +  R_386_32);
+        saa_write32(pinfo,highaddr);    /* DW_AT_high_pc */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, (dwarf_linesym << 8) +  R_386_32); /* reloc to line */
+        saa_write32(pinfo,0);       /* DW_AT_stmt_list */
+        saa_wbytes(pinfo, elf_module, strlen(elf_module)+1); /* DW_AT_name */
+        saa_wbytes(pinfo, elf_dir, strlen(elf_dir)+1); /* DW_AT_comp_dir */
+        saa_wbytes(pinfo, nasm_signature(), nasm_signature_len()+1);
+        saa_write16(pinfo,DW_LANG_Mips_Assembler);
+        saa_write8(pinfo,2);        /* abbrviation number LEB128u */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, ((dwarf_fsect->section + 2) << 8) +  R_386_32);
+        saa_write32(pinfo,0);       /* DW_AT_low_pc */
+        saa_write32(pinfo,0);       /* DW_AT_frame_base */
+        saa_write8(pinfo,0);        /* end of entries */
+        saalen = pinfo->datalen;
+        infolen = saalen + 4;
+        infobuf = pbuf = nasm_malloc(infolen);
+        WRITELONG(pbuf,saalen);     /* initial length */
+        saa_rnbytes(pinfo, pbuf, saalen);
+        saa_free(pinfo);
+    } else if (is_elfx32()) {
+        /* build info section */
+        pinfo = saa_init(1L);
+        pinforel = saa_init(1L);
+        saa_write16(pinfo, dwfmt->sect_version[DWARF_INFO]);
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, (dwarf_abbrevsym << 8) + R_X86_64_32); /* reloc to abbrev */
+        saa_write32(pinforel, 0);
+        saa_write32(pinfo,0);			/* offset into abbrev */
+        saa_write8(pinfo,4);			/* pointer size */
+        saa_write8(pinfo,1);			/* abbrviation number LEB128u */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, ((dwarf_fsect->section + 2) << 8) + R_X86_64_32);
+        saa_write32(pinforel, 0);
+        saa_write32(pinfo,0);			/* DW_AT_low_pc */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, ((dwarf_fsect->section + 2) << 8) + R_X86_64_32);
+        saa_write32(pinforel, highaddr);
+        saa_write32(pinfo,0);			/* DW_AT_high_pc */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, (dwarf_linesym << 8) + R_X86_64_32); /* reloc to line */
+        saa_write32(pinforel, 0);
+        saa_write32(pinfo,0);			/* DW_AT_stmt_list */
+        saa_wbytes(pinfo, elf_module, strlen(elf_module)+1); /* DW_AT_name */
+        saa_wbytes(pinfo, elf_dir, strlen(elf_dir)+1); /* DW_AT_comp_dir */
+        saa_wbytes(pinfo, nasm_signature(), nasm_signature_len()+1);
+        saa_write16(pinfo,DW_LANG_Mips_Assembler);
+        saa_write8(pinfo,2);			/* abbrviation number LEB128u */
+        saa_write32(pinforel, pinfo->datalen + 4);
+        saa_write32(pinforel, ((dwarf_fsect->section + 2) << 8) +  R_X86_64_32);
+        saa_write32(pinforel, 0);
+        saa_write32(pinfo,0);			/* DW_AT_low_pc */
+        saa_write32(pinfo,0);			/* DW_AT_frame_base */
+        saa_write8(pinfo,0);			/* end of entries */
+        saalen = pinfo->datalen;
+        infolen = saalen + 4;
+        infobuf = pbuf = nasm_malloc(infolen);
+        WRITELONG(pbuf,saalen);     /* initial length */
+        saa_rnbytes(pinfo, pbuf, saalen);
+        saa_free(pinfo);
+    } else {
+        nasm_assert(is_elf64());
+        /* build info section */
+        pinfo = saa_init(1L);
+        pinforel = saa_init(1L);
+        saa_write16(pinfo, dwfmt->sect_version[DWARF_INFO]);
+        saa_write64(pinforel, pinfo->datalen + 4);
+        saa_write64(pinforel, (dwarf_abbrevsym << 32) +  R_X86_64_32); /* reloc to abbrev */
+        saa_write64(pinforel, 0);
+        saa_write32(pinfo,0);			/* offset into abbrev */
+        saa_write8(pinfo,8);			/* pointer size */
+        saa_write8(pinfo,1);			/* abbrviation number LEB128u */
+        saa_write64(pinforel, pinfo->datalen + 4);
+        saa_write64(pinforel, ((uint64_t)(dwarf_fsect->section + 2) << 32) +  R_X86_64_64);
+        saa_write64(pinforel, 0);
+        saa_write64(pinfo,0);			/* DW_AT_low_pc */
+        saa_write64(pinforel, pinfo->datalen + 4);
+        saa_write64(pinforel, ((uint64_t)(dwarf_fsect->section + 2) << 32) +  R_X86_64_64);
+        saa_write64(pinforel, highaddr);
+        saa_write64(pinfo,0);			/* DW_AT_high_pc */
+        saa_write64(pinforel, pinfo->datalen + 4);
+        saa_write64(pinforel, (dwarf_linesym << 32) +  R_X86_64_32); /* reloc to line */
+        saa_write64(pinforel, 0);
+        saa_write32(pinfo,0);			/* DW_AT_stmt_list */
+        saa_wbytes(pinfo, elf_module, strlen(elf_module)+1); /* DW_AT_name */
+        saa_wbytes(pinfo, elf_dir, strlen(elf_dir)+1); /* DW_AT_comp_dir */
+        saa_wbytes(pinfo, nasm_signature(), nasm_signature_len()+1);
+        saa_write16(pinfo,DW_LANG_Mips_Assembler);
+        saa_write8(pinfo,2);			/* abbrviation number LEB128u */
+        saa_write64(pinforel, pinfo->datalen + 4);
+        saa_write64(pinforel, ((uint64_t)(dwarf_fsect->section + 2) << 32) +  R_X86_64_64);
+        saa_write64(pinforel, 0);
+        saa_write64(pinfo,0);			/* DW_AT_low_pc */
+        saa_write64(pinfo,0);			/* DW_AT_frame_base */
+        saa_write8(pinfo,0);			/* end of entries */
+        saalen = pinfo->datalen;
+        infolen = saalen + 4;
+        infobuf = pbuf = nasm_malloc(infolen);
+        WRITELONG(pbuf,saalen);     /* initial length */
+        saa_rnbytes(pinfo, pbuf, saalen);
+        saa_free(pinfo);
+    }
+
+    /* build rela.info section */
+    inforellen = saalen = pinforel->datalen;
+    inforelbuf = pbuf = nasm_malloc(inforellen);
+    saa_rnbytes(pinforel, pbuf, saalen);
+    saa_free(pinforel);
+
+    /* build abbrev section */
+    pabbrev = saa_init(1L);
+    saa_write8(pabbrev,1);      /* entry number LEB128u */
+    saa_write8(pabbrev,DW_TAG_compile_unit);    /* tag LEB128u */
+    saa_write8(pabbrev,1);      /* has children */
+    /* the following attributes and forms are all LEB128u values */
+    saa_write8(pabbrev,DW_AT_low_pc);
+    saa_write8(pabbrev,DW_FORM_addr);
+    saa_write8(pabbrev,DW_AT_high_pc);
+    saa_write8(pabbrev,DW_FORM_addr);
+    saa_write8(pabbrev,DW_AT_stmt_list);
+    saa_write8(pabbrev,DW_FORM_data4);
+    saa_write8(pabbrev,DW_AT_name);
+    saa_write8(pabbrev,DW_FORM_string);
+    saa_write8(pabbrev,DW_AT_comp_dir);
+    saa_write8(pabbrev,DW_FORM_string);
+    saa_write8(pabbrev,DW_AT_producer);
+    saa_write8(pabbrev,DW_FORM_string);
+    saa_write8(pabbrev,DW_AT_language);
+    saa_write8(pabbrev,DW_FORM_data2);
+    saa_write16(pabbrev,0);     /* end of entry */
+    /* LEB128u usage same as above */
+    saa_write8(pabbrev,2);      /* entry number */
+    saa_write8(pabbrev,DW_TAG_subprogram);
+    saa_write8(pabbrev,0);      /* no children */
+    saa_write8(pabbrev,DW_AT_low_pc);
+    saa_write8(pabbrev,DW_FORM_addr);
+    saa_write8(pabbrev,DW_AT_frame_base);
+    saa_write8(pabbrev,DW_FORM_data4);
+    saa_write16(pabbrev,0);     /* end of entry */
+    /* Terminal zero entry */
+    saa_write8(pabbrev,0);
+    abbrevlen = saalen = pabbrev->datalen;
+    abbrevbuf = pbuf = nasm_malloc(saalen);
+    saa_rnbytes(pabbrev, pbuf, saalen);
+    saa_free(pabbrev);
+
+    /* build line section */
+    /* prolog */
+    plines = saa_init(1L);
+    saa_write8(plines,1);           /* Minimum Instruction Length */
+    saa_write8(plines,1);           /* Initial value of 'is_stmt' */
+    saa_write8(plines,line_base);   /* Line Base */
+    saa_write8(plines,line_range);  /* Line Range */
+    saa_write8(plines,opcode_base); /* Opcode Base */
+    /* standard opcode lengths (# of LEB128u operands) */
+    saa_write8(plines,0);           /* Std opcode 1 length */
+    saa_write8(plines,1);           /* Std opcode 2 length */
+    saa_write8(plines,1);           /* Std opcode 3 length */
+    saa_write8(plines,1);           /* Std opcode 4 length */
+    saa_write8(plines,1);           /* Std opcode 5 length */
+    saa_write8(plines,0);           /* Std opcode 6 length */
+    saa_write8(plines,0);           /* Std opcode 7 length */
+    saa_write8(plines,0);           /* Std opcode 8 length */
+    saa_write8(plines,1);           /* Std opcode 9 length */
+    saa_write8(plines,0);           /* Std opcode 10 length */
+    saa_write8(plines,0);           /* Std opcode 11 length */
+    saa_write8(plines,1);           /* Std opcode 12 length */
+    /* Directory Table */
+    saa_write8(plines,0);           /* End of table */
+    /* File Name Table */
+    ftentry = dwarf_flist;
+    for (indx = 0; indx < dwarf_numfiles; indx++) {
+        saa_wbytes(plines, ftentry->filename, (int32_t)(strlen(ftentry->filename) + 1));
+        saa_write8(plines,0);       /* directory  LEB128u */
+        saa_write8(plines,0);       /* time LEB128u */
+        saa_write8(plines,0);       /* size LEB128u */
+        ftentry = ftentry->next;
+    }
+    saa_write8(plines,0);           /* End of table */
+    linepoff = plines->datalen;
+    linelen = linepoff + totlen + 10;
+    linebuf = pbuf = nasm_malloc(linelen);
+    WRITELONG(pbuf,linelen-4);      /* initial length */
+    WRITESHORT(pbuf,dwfmt->sect_version[DWARF_LINE]);
+    WRITELONG(pbuf,linepoff);       /* offset to line number program */
+    /* write line header */
+    saalen = linepoff;
+    saa_rnbytes(plines, pbuf, saalen);   /* read a given no. of bytes */
+    pbuf += linepoff;
+    saa_free(plines);
+    /* concatenate line program ranges */
+    linepoff += 13;
+    plinesrel = saa_init(1L);
+    psect = dwarf_fsect;
+    if (is_elf32()) {
+        for (indx = 0; indx < dwarf_nsections; indx++) {
+            saa_write32(plinesrel, linepoff);
+            saa_write32(plinesrel, ((uint32_t) (psect->section + 2) << 8) +  R_386_32);
+            plinep = psect->psaa;
+            saalen = plinep->datalen;
+            saa_rnbytes(plinep, pbuf, saalen);
+            pbuf += saalen;
+            linepoff += saalen;
+            saa_free(plinep);
+            /* done with this entry */
+            psect = psect->next;
+        }
+    } else if (is_elfx32()) {
+        for (indx = 0; indx < dwarf_nsections; indx++) {
+            saa_write32(plinesrel, linepoff);
+            saa_write32(plinesrel, ((psect->section + 2) << 8) + R_X86_64_32);
+            saa_write32(plinesrel, 0);
+            plinep = psect->psaa;
+            saalen = plinep->datalen;
+            saa_rnbytes(plinep, pbuf, saalen);
+            pbuf += saalen;
+            linepoff += saalen;
+            saa_free(plinep);
+            /* done with this entry */
+            psect = psect->next;
+        }
+    } else {
+        nasm_assert(is_elf64());
+        for (indx = 0; indx < dwarf_nsections; indx++) {
+            saa_write64(plinesrel, linepoff);
+            saa_write64(plinesrel, ((uint64_t) (psect->section + 2) << 32) +  R_X86_64_64);
+            saa_write64(plinesrel, (uint64_t) 0);
+            plinep = psect->psaa;
+            saalen = plinep->datalen;
+            saa_rnbytes(plinep, pbuf, saalen);
+            pbuf += saalen;
+            linepoff += saalen;
+            saa_free(plinep);
+            /* done with this entry */
+            psect = psect->next;
+        }
+    }
+
+    /* build rela.lines section */
+    linerellen =saalen = plinesrel->datalen;
+    linerelbuf = pbuf = nasm_malloc(linerellen);
+    saa_rnbytes(plinesrel, pbuf, saalen);
+    saa_free(plinesrel);
+
+    /* build .debug_frame section */
+    if (0) {
+        framelen = 4;
+        framebuf = pbuf = nasm_malloc(framelen);
+        WRITELONG(pbuf,framelen-4); /* initial length */
+    } else {
+        /* Leave .debug_frame empty if not used! */
+        framelen = 0;
+    }
+
+    /* build .debug_loc section */
+    if (0) {
+        loclen = 16;
+        locbuf = pbuf = nasm_malloc(loclen);
+        if (is_elf32() || is_elfx32()) {
+            WRITELONG(pbuf,0);  /* null  beginning offset */
+            WRITELONG(pbuf,0);  /* null  ending offset */
+        } else {
+            nasm_assert(is_elf64());
+            WRITEDLONG(pbuf,0);  /* null  beginning offset */
+            WRITEDLONG(pbuf,0);  /* null  ending offset */
+        }
+    } else {
+        /* Leave .debug_frame empty if not used! */
+        loclen = 0;
+    }
+}
+
+static void dwarf_cleanup(void)
+{
+    nasm_free(arangesbuf);
+    nasm_free(arangesrelbuf);
+    nasm_free(pubnamesbuf);
+    nasm_free(infobuf);
+    nasm_free(inforelbuf);
+    nasm_free(abbrevbuf);
+    nasm_free(linebuf);
+    nasm_free(linerelbuf);
+    nasm_free(framebuf);
+    nasm_free(locbuf);
+}
+
+static void dwarf_findfile(const char * fname)
+{
+    int finx;
+    struct linelist *match;
+
+    /* return if fname is current file name */
+    if (dwarf_clist && !(strcmp(fname, dwarf_clist->filename)))
+        return;
+
+    /* search for match */
+    match = 0;
+    if (dwarf_flist) {
+        match = dwarf_flist;
+        for (finx = 0; finx < dwarf_numfiles; finx++) {
+            if (!(strcmp(fname, match->filename))) {
+                dwarf_clist = match;
+                return;
+            }
+            match = match->next;
+        }
+    }
+
+    /* add file name to end of list */
+    dwarf_clist = nasm_malloc(sizeof(struct linelist));
+    dwarf_numfiles++;
+    dwarf_clist->line = dwarf_numfiles;
+    dwarf_clist->filename = nasm_malloc(strlen(fname) + 1);
+    strcpy(dwarf_clist->filename,fname);
+    dwarf_clist->next = 0;
+    if (!dwarf_flist) {     /* if first entry */
+        dwarf_flist = dwarf_elist = dwarf_clist;
+        dwarf_clist->last = 0;
+    } else {                /* chain to previous entry */
+        dwarf_elist->next = dwarf_clist;
+        dwarf_elist = dwarf_clist;
+    }
+}
+
+static void dwarf_findsect(const int index)
+{
+    int sinx;
+    struct sectlist *match;
+    struct SAA *plinep;
+
+    /* return if index is current section index */
+    if (dwarf_csect && (dwarf_csect->section == index))
+        return;
+
+    /* search for match */
+    match = 0;
+    if (dwarf_fsect) {
+        match = dwarf_fsect;
+        for (sinx = 0; sinx < dwarf_nsections; sinx++) {
+            if (match->section == index) {
+                dwarf_csect = match;
+                return;
+            }
+            match = match->next;
+        }
+    }
+
+    /* add entry to end of list */
+    dwarf_csect = nasm_malloc(sizeof(struct sectlist));
+    dwarf_nsections++;
+    dwarf_csect->psaa = plinep = saa_init(1L);
+    dwarf_csect->line = 1;
+    dwarf_csect->offset = 0;
+    dwarf_csect->file = 1;
+    dwarf_csect->section = index;
+    dwarf_csect->next = 0;
+    /* set relocatable address at start of line program */
+    saa_write8(plinep,DW_LNS_extended_op);
+    saa_write8(plinep,is_elf64() ? 9 : 5);   /* operand length */
+    saa_write8(plinep,DW_LNE_set_address);
+    if (is_elf64())
+        saa_write64(plinep,0);  /* Start Address */
+    else
+        saa_write32(plinep,0);  /* Start Address */
+
+    if (!dwarf_fsect) { /* if first entry */
+        dwarf_fsect = dwarf_esect = dwarf_csect;
+        dwarf_csect->last = 0;
+    } else {            /* chain to previous entry */
+        dwarf_esect->next = dwarf_csect;
+        dwarf_esect = dwarf_csect;
+    }
+}
+
+#endif /* defined(OF_ELF32) || defined(OF_ELF64) || defined(OF_ELFX32) */
diff --git a/vere/ext/nasm/output/outelf.h b/vere/ext/nasm/output/outelf.h
new file mode 100644
index 0000000..fcb91db
--- /dev/null
+++ b/vere/ext/nasm/output/outelf.h
@@ -0,0 +1,133 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2019 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Internal definitions common to outelf32 and outelf64
+ */
+#ifndef OUTPUT_OUTELF_H
+#define OUTPUT_OUTELF_H
+
+#include "elf.h"
+#include "rbtree.h"
+#include "saa.h"
+
+#define GLOBAL_TEMP_BASE  0x40000000 /* bigger than any sane symbol index */
+
+/* alignment of sections in file */
+#define SEC_FILEALIGN 16
+
+/* this stuff is needed for the dwarf/stabs debugging format */
+#define TY_DEBUGSYMLIN 0x40     /* internal call to debug_out */
+
+/*
+ * Debugging ELF sections (section indices starting with sec_debug)
+ */
+
+/* stabs */
+#define sec_stab                (sec_debug + 0)
+#define sec_stabstr             (sec_debug + 1)
+#define sec_rel_stab            (sec_debug + 2)
+
+/* stabs symbol table format */
+struct stabentry {
+    uint32_t    n_strx;
+    uint8_t     n_type;
+    uint8_t     n_other;
+    uint16_t    n_desc;
+    uint32_t    n_value;
+};
+
+/* dwarf */
+#define sec_debug_aranges       (sec_debug + 0)
+#define sec_rela_debug_aranges  (sec_debug + 1)
+#define sec_debug_pubnames      (sec_debug + 2)
+#define sec_debug_info          (sec_debug + 3)
+#define sec_rela_debug_info     (sec_debug + 4)
+#define sec_debug_abbrev        (sec_debug + 5)
+#define sec_debug_line          (sec_debug + 6)
+#define sec_rela_debug_line     (sec_debug + 7)
+#define sec_debug_frame         (sec_debug + 8)
+#define sec_debug_loc           (sec_debug + 9)
+
+extern uint8_t elf_osabi;
+extern uint8_t elf_abiver;
+
+#define WRITE_STAB(p,n_strx,n_type,n_other,n_desc,n_value)  \
+    do {                                                    \
+        WRITELONG(p, n_strx);                               \
+        WRITECHAR(p, n_type);                               \
+        WRITECHAR(p, n_other);                              \
+        WRITESHORT(p, n_desc);                              \
+        WRITELONG(p, n_value);                              \
+    } while (0)
+
+struct elf_reloc {
+    struct elf_reloc    *next;
+    int64_t             address;        /* relative to _start_ of section */
+    int64_t             symbol;         /* symbol index */
+    int64_t             offset;         /* symbol addend */
+    int                 type;           /* type of relocation */
+};
+
+struct elf_symbol {
+    struct rbtree       symv;           /* symbol value and symbol rbtree */
+    int32_t             strpos;         /* string table position of name */
+    int32_t             section;        /* section ID of the symbol */
+    int                 type;           /* symbol type */
+    int                 other;          /* symbol visibility */
+    int32_t             size;           /* size of symbol */
+    int32_t             globnum;        /* symbol table offset if global */
+    struct elf_symbol   *nextfwd;       /* list of unresolved-size symbols */
+    char                *name;          /* used temporarily if in above list */
+};
+
+struct elf_section {
+    struct SAA          *data;
+    uint64_t            len;
+    uint64_t            size;
+    uint64_t            nrelocs;
+    int32_t             index;		/* NASM index or NO_SEG if internal */
+    int			shndx;          /* ELF index */
+    int                 type;           /* SHT_* */
+    uint64_t            align;          /* alignment: power of two */
+    uint64_t            flags;          /* section flags */
+    int64_t		pass_last_seen;
+    uint64_t		entsize;        /* entry size */
+    char                *name;
+    struct SAA          *rel;
+    struct elf_reloc    *head;
+    struct elf_reloc    **tail;
+    struct rbtree       *gsyms;         /* global symbols in section */
+};
+
+#endif /* OUTPUT_OUTELF_H */
diff --git a/vere/ext/nasm/output/outelf.mac b/vere/ext/nasm/output/outelf.mac
new file mode 100644
index 0000000..94babe3
--- /dev/null
+++ b/vere/ext/nasm/output/outelf.mac
@@ -0,0 +1,41 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: elf elf32 elf64
+%define __?SECT?__ [section .text]
+%macro __?NASM_CDecl?__ 1
+%define $_%1 $%1
+%endmacro
+%imacro osabi 1+.nolist
+[%? %1]
+%endmacro
diff --git a/vere/ext/nasm/output/outform.c b/vere/ext/nasm/output/outform.c
new file mode 100644
index 0000000..a2fdde8
--- /dev/null
+++ b/vere/ext/nasm/output/outform.c
@@ -0,0 +1,135 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2011 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outform.c	manages a list of output formats, and associates
+ *		them with their relevant drivers. Also has a
+ *		routine to find the correct driver given a name
+ *		for it
+ */
+
+#include "compiler.h"
+
+
+#define BUILD_DRIVERS_ARRAY
+#include "outform.h"
+#include "outlib.h"
+
+const struct ofmt *ofmt_find(const char *name,
+			     const struct ofmt_alias **ofmt_alias)
+{
+    const struct ofmt * const *ofp;
+    const struct ofmt *of;
+    unsigned int i;
+
+    *ofmt_alias = NULL;
+
+    /* primary targets first */
+    for (ofp = drivers; (of = *ofp); ofp++) {
+        if (!nasm_stricmp(name, of->shortname))
+            return of;
+    }
+
+    /* lets walk thru aliases then */
+    for (i = 0; i < ARRAY_SIZE(ofmt_aliases); i++) {
+        if (ofmt_aliases[i].shortname &&
+            !nasm_stricmp(name, ofmt_aliases[i].shortname)) {
+            *ofmt_alias = &ofmt_aliases[i];
+            return ofmt_aliases[i].ofmt;
+        }
+    }
+
+    return NULL;
+}
+
+const struct dfmt *dfmt_find(const struct ofmt *ofmt, const char *name)
+{
+    const struct dfmt * const *dfp;
+    const struct dfmt *df;
+
+    for (dfp = ofmt->debug_formats; (df = *dfp); dfp++) {
+        if (!nasm_stricmp(name, df->shortname))
+            return df;
+    }
+    return NULL;
+}
+
+void ofmt_list(const struct ofmt *deffmt, FILE * fp)
+{
+    const struct ofmt * const *ofp, *of;
+    unsigned int i;
+
+    /* primary targets first */
+    for (ofp = drivers; (of = *ofp); ofp++) {
+        fprintf(fp, "       %-20s %s%s\n",
+                of->shortname,
+                of->fullname,
+                of == deffmt ? " [default]" : "");
+    }
+
+    /* lets walk through aliases then */
+    for (i = 0; i < ARRAY_SIZE(ofmt_aliases); i++) {
+        if (!ofmt_aliases[i].shortname)
+            continue;
+        fprintf(fp, "       %-20s Legacy alias for \"%s\"\n",
+                ofmt_aliases[i].shortname,
+                ofmt_aliases[i].ofmt->shortname);
+    }
+}
+
+void dfmt_list(FILE *fp)
+{
+    const struct ofmt * const *ofp;
+    const struct ofmt *of;
+    const struct dfmt * const *dfp;
+    const struct dfmt *df;
+    char prefixbuf[32];
+    const char *prefix;
+
+    for (ofp = drivers; (of = *ofp); ofp++) {
+        if (of->debug_formats && of->debug_formats != null_debug_arr) {
+            snprintf(prefixbuf, sizeof prefixbuf, "%s:",
+                     of->shortname);
+            prefix = prefixbuf;
+
+            for (dfp = of->debug_formats; (df = *dfp); dfp++) {
+                if (df != &null_debug_form)
+                    fprintf(fp, "       %-10s %-9s %s%s\n",
+                            prefix,
+                            df->shortname, df->fullname,
+                            df == of->default_dfmt ? " [default]" : "");
+                prefix = "";
+            }
+        }
+    }
+}
diff --git a/vere/ext/nasm/output/outform.h b/vere/ext/nasm/output/outform.h
new file mode 100644
index 0000000..3b84674
--- /dev/null
+++ b/vere/ext/nasm/output/outform.h
@@ -0,0 +1,354 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outform.h    header file for binding output format drivers to the
+ *              remainder of the code in the Netwide Assembler
+ */
+
+/*
+ * This header file allows configuration of which output formats
+ * get compiled into the NASM binary. You can configure by defining
+ * various preprocessor symbols beginning with "OF_", either on the
+ * compiler command line or at the top of this file.
+ *
+ * OF_ONLY                -- only include specified object formats
+ * OF_name                -- ensure that output format 'name' is included
+ * OF_NO_name             -- remove output format 'name'
+ * OF_DOS                 -- ensure that 'obj', 'bin', 'win32' & 'win64' are included.
+ * OF_UNIX                -- ensure that 'aout', 'aoutb', 'coff', 'elf32' & 'elf64' are in.
+ * OF_OTHERS              -- ensure that 'bin', 'as86', 'rdf' 'macho32' & 'macho64' are in.
+ * OF_ALL                 -- ensure that all formats are included.
+ *                           note that this doesn't include 'dbg', which is
+ *                           only really useful if you're doing development
+ *                           work on NASM. Define OF_DBG if you want this.
+ *
+ * OF_DEFAULT=of_name     -- ensure that 'name' is the default format.
+ *
+ * eg: -DOF_UNIX -DOF_ELF32 -DOF_DEFAULT=of_elf32 would be a suitable config
+ * for an average linux system.
+ *
+ * Default config = -DOF_ALL -DOF_DEFAULT=of_bin
+ *
+ * You probably only want to set these options while compiling 'nasm.c'. */
+
+#ifndef NASM_OUTFORM_H
+#define NASM_OUTFORM_H
+
+#include "nasm.h"
+
+/* -------------- USER MODIFIABLE PART ---------------- */
+
+/*
+ * Insert #defines here in accordance with the configuration
+ * instructions above.
+ *
+ * E.g.
+ *
+ * #define OF_ONLY
+ * #define OF_OBJ
+ * #define OF_BIN
+ *
+ * for a 16-bit DOS assembler with no extraneous formats.
+ */
+
+/* ------------ END USER MODIFIABLE PART -------------- */
+
+/* ====configurable info begins here==== */
+/* formats configurable:
+ * bin,obj,elf32,elf64,aout,aoutb,coff,win32,as86,rdf2,macho32,macho64 */
+
+/* process options... */
+
+#ifndef OF_ONLY
+#ifndef OF_ALL
+#define OF_ALL                  /* default is to have all formats */
+#endif
+#endif
+
+#ifdef OF_ALL                   /* set all formats on... */
+#ifndef OF_BIN
+#define OF_BIN
+#endif
+#ifndef OF_OBJ
+#define OF_OBJ
+#endif
+#ifndef OF_ELF32
+#define OF_ELF32
+#endif
+#ifndef OF_ELFX32
+#define OF_ELFX32
+#endif
+#ifndef OF_ELF64
+#define OF_ELF64
+#endif
+#ifndef OF_COFF
+#define OF_COFF
+#endif
+#ifndef OF_AOUT
+#define OF_AOUT
+#endif
+#ifndef OF_AOUTB
+#define OF_AOUTB
+#endif
+#ifndef OF_WIN32
+#define OF_WIN32
+#endif
+#ifndef OF_WIN64
+#define OF_WIN64
+#endif
+#ifndef OF_AS86
+#define OF_AS86
+#endif
+#ifndef OF_IEEE
+#define OF_IEEE
+#endif
+#ifndef OF_MACHO32
+#define OF_MACHO32
+#endif
+#ifndef OF_MACHO64
+#define OF_MACHO64
+#endif
+#ifndef OF_DBG
+#define OF_DBG
+#endif
+#endif                          /* OF_ALL */
+
+/* turn on groups of formats specified.... */
+#ifdef OF_DOS
+#ifndef OF_OBJ
+#define OF_OBJ
+#endif
+#ifndef OF_BIN
+#define OF_BIN
+#endif
+#ifndef OF_COFF
+#define OF_COFF                 /* COFF is used by DJGPP */
+#endif
+#ifndef OF_WIN32
+#define OF_WIN32
+#endif
+#ifndef OF_WIN64
+#define OF_WIN64
+#endif
+#endif
+
+#ifdef OF_UNIX
+#ifndef OF_AOUT
+#define OF_AOUT
+#endif
+#ifndef OF_AOUTB
+#define OF_AOUTB
+#endif
+#ifndef OF_COFF
+#define OF_COFF
+#endif
+#ifndef OF_ELF32
+#define OF_ELF32
+#endif
+#ifndef OF_ELF64
+#define OF_ELF64
+#endif
+#ifndef OF_ELFX32
+#define OF_ELFX32
+#endif
+#endif
+
+#ifdef OF_OTHERS
+#ifndef OF_BIN
+#define OF_BIN
+#endif
+#ifndef OF_AS86
+#define OF_AS86
+#endif
+#ifndef OF_IEEE
+#define OF_IEEE
+#endif
+#ifndef OF_MACHO32
+#define OF_MACHO32
+#endif
+#ifndef OF_MACHO64
+#define OF_MACHO64
+#endif
+#endif
+
+/* finally... override any format specifically specified to be off */
+#ifdef OF_NO_BIN
+#undef OF_BIN
+#endif
+#ifdef OF_NO_OBJ
+#undef OF_OBJ
+#endif
+#ifdef OF_NO_ELF32
+#undef OF_ELF32
+#endif
+#ifdef OF_NO_ELF64
+#undef OF_ELF64
+#endif
+#ifdef OF_NO_ELFX32
+#undef OF_ELFX32
+#endif
+#ifdef OF_NO_AOUT
+#undef OF_AOUT
+#endif
+#ifdef OF_NO_AOUTB
+#undef OF_AOUTB
+#endif
+#ifdef OF_NO_COFF
+#undef OF_COFF
+#endif
+#ifdef OF_NO_WIN32
+#undef OF_WIN32
+#endif
+#ifdef OF_NO_WIN64
+#undef OF_WIN64
+#endif
+#ifdef OF_NO_AS86
+#undef OF_AS86
+#endif
+#ifdef OF_NO_IEEE
+#undef OF_IEEE
+#endif
+#ifdef OF_NO_MACHO32
+#undef OF_MACHO32
+#endif
+#ifdef OF_NO_MACHO64
+#undef OF_MACHO64
+#endif
+#ifdef OF_NO_DBG
+#undef OF_DBG
+#endif
+
+#ifndef OF_DEFAULT
+#define OF_DEFAULT of_bin
+#endif
+
+extern const struct ofmt of_bin;
+extern const struct ofmt of_ith;
+extern const struct ofmt of_srec;
+extern const struct ofmt of_aout;
+extern const struct ofmt of_aoutb;
+extern const struct ofmt of_coff;
+extern const struct ofmt of_elf32;
+extern const struct ofmt of_elfx32;
+extern const struct ofmt of_elf64;
+extern const struct ofmt of_as86;
+extern const struct ofmt of_obj;
+extern const struct ofmt of_win32;
+extern const struct ofmt of_win64;
+extern const struct ofmt of_ieee;
+extern const struct ofmt of_macho32;
+extern const struct ofmt of_macho64;
+extern const struct ofmt of_dbg;
+
+#ifdef BUILD_DRIVERS_ARRAY      /* only if included from outform.c */
+
+/*
+ * pull in the externs for the different formats, then make the
+ * drivers array based on the above defines
+ */
+
+static const struct ofmt * const drivers[] = {
+#ifdef OF_BIN
+    &of_bin,
+    &of_ith,
+    &of_srec,
+#endif
+#ifdef OF_AOUT
+    &of_aout,
+#endif
+#ifdef OF_AOUTB
+    &of_aoutb,
+#endif
+#ifdef OF_COFF
+    &of_coff,
+#endif
+#ifdef OF_ELF32
+    &of_elf32,
+#endif
+#ifdef OF_ELF64
+    &of_elf64,
+#endif
+#ifdef OF_ELFX32
+    &of_elfx32,
+#endif
+#ifdef OF_AS86
+    &of_as86,
+#endif
+#ifdef OF_OBJ
+    &of_obj,
+#endif
+#ifdef OF_WIN32
+    &of_win32,
+#endif
+#ifdef OF_WIN64
+    &of_win64,
+#endif
+#ifdef OF_IEEE
+    &of_ieee,
+#endif
+#ifdef OF_MACHO32
+    &of_macho32,
+#endif
+#ifdef OF_MACHO64
+    &of_macho64,
+#endif
+#ifdef OF_DBG
+    &of_dbg,
+#endif
+
+    NULL
+};
+
+static const struct ofmt_alias ofmt_aliases[] = {
+#ifdef OF_ELF32
+    { "elf",  &of_elf32 },
+#endif
+#ifdef OF_MACHO32
+    { "macho", &of_macho32 },
+#endif
+#ifdef OF_WIN32
+    { "win",   &of_win32 },
+#endif
+    { NULL, NULL }
+};
+
+#endif /* BUILD_DRIVERS_ARRAY */
+
+const struct ofmt *ofmt_find(const char *name, const struct ofmt_alias **ofmt_alias);
+const struct dfmt *dfmt_find(const struct ofmt *, const char *);
+void ofmt_list(const struct ofmt *, FILE *);
+void dfmt_list(FILE *);
+extern const struct dfmt null_debug_form;
+
+#endif /* NASM_OUTFORM_H */
diff --git a/vere/ext/nasm/output/outieee.c b/vere/ext/nasm/output/outieee.c
new file mode 100644
index 0000000..7ba9036
--- /dev/null
+++ b/vere/ext/nasm/output/outieee.c
@@ -0,0 +1,1521 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outieee.c	output routines for the Netwide Assembler to produce
+ *		IEEE-std object files
+ */
+
+/* notes: I have tried to make this correspond to the IEEE version
+ * of the standard, specifically the primary ASCII version.  It should
+ * be trivial to create the binary version given this source (which is
+ * one of MANY things that have to be done to make this correspond to
+ * the hp-microtek version of the standard).
+ *
+ * 16-bit support is assumed to use 24-bit addresses
+ * The linker can sort out segmentation-specific stuff
+ * if it keeps track of externals
+ * in terms of being relative to section bases
+ *
+ * A non-standard variable type, the 'Yn' variable, has been introduced.
+ * Basically it is a reference to extern 'n'- denoting the low limit
+ * (L-variable) of the section that extern 'n' is defined in.  Like the
+ * x variable, there may be no explicit assignment to it, it is derived
+ * from the public definition corresponding to the extern name.  This
+ * is required because the one thing the mufom guys forgot to do well was
+ * take into account segmented architectures.
+ *
+ * I use comment classes for various things and these are undefined by
+ * the standard.
+ *
+ * Debug info should be considered totally non-standard (local labels are
+ * standard but linenum records are not covered by the standard.
+ * Type defs have the standard format but absolute meanings for ordinal
+ * types are not covered by the standard.)
+ *
+ * David Lindauer, LADsoft
+ */
+#include "compiler.h"
+
+#include <time.h>
+#include <ctype.h>              /* For toupper() */
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "ver.h"
+
+#include "outform.h"
+#include "outlib.h"
+
+#ifdef OF_IEEE
+
+#define ARRAY_BOT 0x1
+
+static char ieee_infile[FILENAME_MAX];
+static int ieee_uppercase;
+
+static bool any_segs;
+static int arrindex;
+
+#define HUNKSIZE 1024           /* Size of the data hunk */
+#define EXT_BLKSIZ 512
+#define LDPERLINE 32            /* bytes per line in output */
+
+struct ieeeSection;
+
+struct LineNumber {
+    struct LineNumber *next;
+    struct ieeeSection *segment;
+    int32_t offset;
+    int32_t lineno;
+};
+
+static struct FileName {
+    struct FileName *next;
+    char *name;
+    int32_t index;
+} *fnhead, **fntail;
+
+static struct Array {
+    struct Array *next;
+    unsigned size;
+    int basetype;
+} *arrhead, **arrtail;
+
+static struct ieeePublic {
+    struct ieeePublic *next;
+    char *name;
+    int32_t offset;
+    int32_t segment;               /* only if it's far-absolute */
+    int32_t index;
+    int type;                   /* for debug purposes */
+} *fpubhead, **fpubtail, *last_defined;
+
+static struct ieeeExternal {
+    struct ieeeExternal *next;
+    char *name;
+    int32_t commonsize;
+} *exthead, **exttail;
+
+static int externals;
+
+static struct ExtBack {
+    struct ExtBack *next;
+    int index[EXT_BLKSIZ];
+} *ebhead, **ebtail;
+
+/* NOTE: the first segment MUST be the lineno segment */
+static struct ieeeSection {
+    struct ieeeSection *next;
+    char *name;
+    struct ieeeObjData *data, *datacurr;
+    struct ieeeFixupp *fptr, *flptr;
+    int32_t index;                 /* the NASM segment id */
+    int32_t ieee_index;            /* the IEEE-file segment index */
+    int32_t currentpos;
+    int32_t align;                 /* can be SEG_ABS + absolute addr */
+    int32_t startpos;
+    int32_t use32;                 /* is this segment 32-bit? */
+    int64_t pass_last_seen;
+    struct ieeePublic *pubhead, **pubtail, *lochead, **loctail;
+    enum {
+        CMB_PRIVATE = 0,
+        CMB_PUBLIC = 2,
+        CMB_COMMON = 6
+    } combine;
+} *seghead, **segtail, *ieee_seg_needs_update;
+
+struct ieeeObjData {
+    struct ieeeObjData *next;
+    uint8_t data[HUNKSIZE];
+};
+
+struct ieeeFixupp {
+    struct ieeeFixupp *next;
+    enum {
+        FT_SEG = 0,
+        FT_REL = 1,
+        FT_OFS = 2,
+        FT_EXT = 3,
+        FT_WRT = 4,
+        FT_EXTREL = 5,
+        FT_EXTWRT = 6,
+        FT_EXTSEG = 7
+    } ftype;
+    int16_t size;
+    int32_t id1;
+    int32_t id2;
+    int32_t offset;
+    int32_t addend;
+};
+
+static int32_t ieee_entry_seg, ieee_entry_ofs;
+static int checksum;
+
+extern const struct ofmt of_ieee;
+static const struct dfmt ladsoft_debug_form;
+
+static void ieee_data_new(struct ieeeSection *);
+static void ieee_write_fixup(int32_t, int32_t, struct ieeeSection *,
+                             int, uint64_t, int32_t);
+static void ieee_install_fixup(struct ieeeSection *, struct ieeeFixupp *);
+static int32_t ieee_segment(char *, int *);
+static void ieee_write_file(void);
+static void ieee_write_byte(struct ieeeSection *, int);
+static void ieee_write_word(struct ieeeSection *, int);
+static void ieee_write_dword(struct ieeeSection *, int32_t);
+static void ieee_putascii(char *, ...);
+static void ieee_putcs(int);
+static int32_t ieee_putld(int32_t, int32_t, uint8_t *);
+static int32_t ieee_putlr(struct ieeeFixupp *);
+static void ieee_unqualified_name(char *, char *);
+
+/*
+ * pup init
+ */
+static void ieee_init(void)
+{
+    strlcpy(ieee_infile, inname, sizeof(ieee_infile));
+    any_segs = false;
+    fpubhead = NULL;
+    fpubtail = &fpubhead;
+    exthead = NULL;
+    exttail = &exthead;
+    externals = 1;
+    ebhead = NULL;
+    ebtail = &ebhead;
+    seghead = ieee_seg_needs_update = NULL;
+    segtail = &seghead;
+    ieee_entry_seg = NO_SEG;
+    ieee_uppercase = false;
+    checksum = 0;
+}
+
+/*
+ * Rundown
+ */
+static void ieee_cleanup(void)
+{
+    ieee_write_file();
+    dfmt->cleanup();
+    while (seghead) {
+        struct ieeeSection *segtmp = seghead;
+        seghead = seghead->next;
+        while (segtmp->pubhead) {
+            struct ieeePublic *pubtmp = segtmp->pubhead;
+            segtmp->pubhead = pubtmp->next;
+            nasm_free(pubtmp);
+        }
+        while (segtmp->fptr) {
+            struct ieeeFixupp *fixtmp = segtmp->fptr;
+            segtmp->fptr = fixtmp->next;
+            nasm_free(fixtmp);
+        }
+        while (segtmp->data) {
+            struct ieeeObjData *dattmp = segtmp->data;
+            segtmp->data = dattmp->next;
+            nasm_free(dattmp);
+        }
+        nasm_free(segtmp);
+    }
+    while (fpubhead) {
+        struct ieeePublic *pubtmp = fpubhead;
+        fpubhead = fpubhead->next;
+        nasm_free(pubtmp);
+    }
+    while (exthead) {
+        struct ieeeExternal *exttmp = exthead;
+        exthead = exthead->next;
+        nasm_free(exttmp);
+    }
+    while (ebhead) {
+        struct ExtBack *ebtmp = ebhead;
+        ebhead = ebhead->next;
+        nasm_free(ebtmp);
+    }
+}
+
+/*
+ * callback for labels
+ */
+static void ieee_deflabel(char *name, int32_t segment,
+                          int64_t offset, int is_global, char *special)
+{
+    /*
+     * We have three cases:
+     *
+     * (i) `segment' is a segment-base. If so, set the name field
+     * for the segment structure it refers to, and then
+     * return.
+     *
+     * (ii) `segment' is one of our segments, or a SEG_ABS segment.
+     * Save the label position for later output of a PUBDEF record.
+     *
+     *
+     * (iii) `segment' is not one of our segments. Save the label
+     * position for later output of an EXTDEF.
+     */
+    struct ieeeExternal *ext;
+    struct ExtBack *eb;
+    struct ieeeSection *seg;
+    int i;
+
+    if (special)
+        nasm_nonfatal("unrecognised symbol type `%s'", special);
+    /*
+     * First check for the double-period, signifying something
+     * unusual.
+     */
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+        if (!strcmp(name, "..start")) {
+            ieee_entry_seg = segment;
+            ieee_entry_ofs = offset;
+        }
+        return;
+    }
+
+    /*
+     * Case (i):
+     */
+    if (ieee_seg_needs_update) {
+        ieee_seg_needs_update->name = name;
+        return;
+    }
+    if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
+        return;
+
+    /*
+     * case (ii)
+     */
+    if (segment >= SEG_ABS) {
+        /*
+         * SEG_ABS subcase of (ii).
+         */
+        if (is_global) {
+            struct ieeePublic *pub;
+
+            pub = *fpubtail = nasm_malloc(sizeof(*pub));
+            fpubtail = &pub->next;
+            pub->next = NULL;
+            pub->name = name;
+            pub->offset = offset;
+            pub->segment = segment & ~SEG_ABS;
+        }
+        return;
+    }
+
+    for (seg = seghead; seg && is_global; seg = seg->next)
+        if (seg->index == segment) {
+            struct ieeePublic *pub;
+
+            last_defined = pub = *seg->pubtail = nasm_malloc(sizeof(*pub));
+            seg->pubtail = &pub->next;
+            pub->next = NULL;
+            pub->name = name;
+            pub->offset = offset;
+            pub->index = seg->ieee_index;
+            pub->segment = -1;
+            return;
+        }
+
+    /*
+     * Case (iii).
+     */
+    if (is_global) {
+        ext = *exttail = nasm_malloc(sizeof(*ext));
+        ext->next = NULL;
+        exttail = &ext->next;
+        ext->name = name;
+        if (is_global == 2)
+            ext->commonsize = offset;
+        else
+            ext->commonsize = 0;
+        i = segment / 2;
+        eb = ebhead;
+        if (!eb) {
+            eb = *ebtail = nasm_zalloc(sizeof(*eb));
+            eb->next = NULL;
+            ebtail = &eb->next;
+        }
+        while (i > EXT_BLKSIZ) {
+            if (eb && eb->next)
+                eb = eb->next;
+            else {
+                eb = *ebtail = nasm_zalloc(sizeof(*eb));
+                eb->next = NULL;
+                ebtail = &eb->next;
+            }
+            i -= EXT_BLKSIZ;
+        }
+        eb->index[i] = externals++;
+    }
+
+}
+
+/*
+ * Put data out
+ */
+static void ieee_out(int32_t segto, const void *data,
+		     enum out_type type, uint64_t size,
+                     int32_t segment, int32_t wrt)
+{
+    const uint8_t *ucdata;
+    int32_t ldata;
+    struct ieeeSection *seg;
+
+    /*
+     * If `any_segs' is still false, we must define a default
+     * segment.
+     */
+    if (!any_segs) {
+        int tempint;            /* ignored */
+        if (segto != ieee_segment("__NASMDEFSEG", &tempint))
+            nasm_panic("strange segment conditions in IEEE driver");
+    }
+
+    /*
+     * Find the segment we are targeting.
+     */
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segto)
+            break;
+    if (!seg)
+        nasm_panic("code directed to nonexistent segment?");
+
+    if (type == OUT_RAWDATA) {
+        ucdata = data;
+        while (size--)
+            ieee_write_byte(seg, *ucdata++);
+    } else if (type == OUT_ADDRESS || type == OUT_REL2ADR ||
+               type == OUT_REL4ADR) {
+        if (type == OUT_ADDRESS)
+            size = abs((int)size);
+        else if (segment == NO_SEG)
+            nasm_nonfatal("relative call to absolute address not"
+                          " supported by IEEE format");
+        ldata = *(int64_t *)data;
+        if (type == OUT_REL2ADR)
+            ldata += (size - 2);
+        if (type == OUT_REL4ADR)
+            ldata += (size - 4);
+        ieee_write_fixup(segment, wrt, seg, size, type, ldata);
+        if (size == 2)
+            ieee_write_word(seg, ldata);
+        else
+            ieee_write_dword(seg, ldata);
+    } else if (type == OUT_RESERVE) {
+        while (size--)
+            ieee_write_byte(seg, 0);
+    }
+}
+
+static void ieee_data_new(struct ieeeSection *segto)
+{
+
+    if (!segto->data)
+        segto->data = segto->datacurr =
+            nasm_malloc(sizeof(*(segto->datacurr)));
+    else
+        segto->datacurr = segto->datacurr->next =
+            nasm_malloc(sizeof(*(segto->datacurr)));
+    segto->datacurr->next = NULL;
+}
+
+/*
+ * this routine is unalduterated bloatware.  I usually don't do this
+ * but I might as well see what it is like on a harmless program.
+ * If anyone wants to optimize this is a good canditate!
+ */
+static void ieee_write_fixup(int32_t segment, int32_t wrt,
+                             struct ieeeSection *segto, int size,
+                             uint64_t realtype, int32_t offset)
+{
+    struct ieeeSection *target;
+    struct ieeeFixupp s;
+
+    /* Don't put a fixup for things NASM can calculate */
+    if (wrt == NO_SEG && segment == NO_SEG)
+        return;
+
+    s.ftype = -1;
+    /* if it is a WRT offset */
+    if (wrt != NO_SEG) {
+        s.ftype = FT_WRT;
+        s.addend = offset;
+        if (wrt >= SEG_ABS)
+            s.id1 = -(wrt - SEG_ABS);
+        else {
+            if (wrt % 2 && realtype != OUT_REL2ADR
+                && realtype != OUT_REL4ADR) {
+                wrt--;
+
+                for (target = seghead; target; target = target->next)
+                    if (target->index == wrt)
+                        break;
+                if (target) {
+                    s.id1 = target->ieee_index;
+                    for (target = seghead; target; target = target->next)
+                        if (target->index == segment)
+                            break;
+
+                    if (target)
+                        s.id2 = target->ieee_index;
+                    else {
+                        /*
+                         * Now we assume the segment field is being used
+                         * to hold an extern index
+                         */
+                        int32_t i = segment / 2;
+                        struct ExtBack *eb = ebhead;
+                        while (i > EXT_BLKSIZ) {
+                            if (eb)
+                                eb = eb->next;
+                            else
+                                break;
+                            i -= EXT_BLKSIZ;
+                        }
+                        /* if we have an extern decide the type and make a record
+                         */
+                        if (eb) {
+                            s.ftype = FT_EXTWRT;
+                            s.addend = 0;
+                            s.id2 = eb->index[i];
+                        } else
+                            nasm_nonfatal("source of WRT must be an offset");
+                    }
+
+                } else
+                    nasm_panic("unrecognised WRT value in ieee_write_fixup");
+            } else
+                nasm_nonfatal("target of WRT must be a section");
+        }
+        s.size = size;
+        ieee_install_fixup(segto, &s);
+        return;
+    }
+    /* Pure segment fixup ? */
+    if (segment != NO_SEG) {
+        s.ftype = FT_SEG;
+        s.id1 = 0;
+        if (segment >= SEG_ABS) {
+            /* absolute far segment fixup */
+            s.id1 = -(segment - ~SEG_ABS);
+        } else if (segment % 2) {
+            /* fixup to named segment */
+            /* look it up */
+            for (target = seghead; target; target = target->next)
+                if (target->index == segment - 1)
+                    break;
+            if (target)
+                s.id1 = target->ieee_index;
+            else {
+                /*
+                 * Now we assume the segment field is being used
+                 * to hold an extern index
+                 */
+                int32_t i = segment / 2;
+                struct ExtBack *eb = ebhead;
+                while (i > EXT_BLKSIZ) {
+                    if (eb)
+                        eb = eb->next;
+                    else
+                        break;
+                    i -= EXT_BLKSIZ;
+                }
+                /* if we have an extern decide the type and make a record
+                 */
+                if (eb) {
+                    if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
+                        nasm_panic("Segment of a rel not supported in ieee_write_fixup");
+                    } else {
+                        /* If we want the segment */
+                        s.ftype = FT_EXTSEG;
+                        s.addend = 0;
+                        s.id1 = eb->index[i];
+                    }
+
+                } else
+                    /* If we get here the seg value doesn't make sense */
+                    nasm_panic("unrecognised segment value in ieee_write_fixup");
+            }
+
+        } else {
+            /* Assume we are offsetting directly from a section
+             * So look up the target segment
+             */
+            for (target = seghead; target; target = target->next)
+                if (target->index == segment)
+                    break;
+            if (target) {
+                if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
+                    /* PC rel to a known offset */
+                    s.id1 = target->ieee_index;
+                    s.ftype = FT_REL;
+                    s.size = size;
+                    s.addend = offset;
+                } else {
+                    /* We were offsetting from a seg */
+                    s.id1 = target->ieee_index;
+                    s.ftype = FT_OFS;
+                    s.size = size;
+                    s.addend = offset;
+                }
+            } else {
+                /*
+                 * Now we assume the segment field is being used
+                 * to hold an extern index
+                 */
+                int32_t i = segment / 2;
+                struct ExtBack *eb = ebhead;
+                while (i > EXT_BLKSIZ) {
+                    if (eb)
+                        eb = eb->next;
+                    else
+                        break;
+                    i -= EXT_BLKSIZ;
+                }
+                /* if we have an extern decide the type and make a record
+                 */
+                if (eb) {
+                    if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
+                        s.ftype = FT_EXTREL;
+                        s.addend = 0;
+                        s.id1 = eb->index[i];
+                    } else {
+                        /* else we want the external offset */
+                        s.ftype = FT_EXT;
+                        s.addend = 0;
+                        s.id1 = eb->index[i];
+                    }
+
+                } else
+                    /* If we get here the seg value doesn't make sense */
+                    nasm_panic("unrecognised segment value in ieee_write_fixup");
+            }
+        }
+        if (size != 2 && s.ftype == FT_SEG)
+            nasm_nonfatal("IEEE format can only handle 2-byte"
+                          " segment base references");
+        s.size = size;
+        ieee_install_fixup(segto, &s);
+        return;
+    }
+    /* should never get here */
+}
+static void ieee_install_fixup(struct ieeeSection *seg,
+                               struct ieeeFixupp *fix)
+{
+    struct ieeeFixupp *f;
+    f = nasm_malloc(sizeof(struct ieeeFixupp));
+    memcpy(f, fix, sizeof(struct ieeeFixupp));
+    f->offset = seg->currentpos;
+    seg->currentpos += fix->size;
+    f->next = NULL;
+    if (seg->fptr)
+        seg->flptr = seg->flptr->next = f;
+    else
+        seg->fptr = seg->flptr = f;
+
+}
+
+/*
+ * segment registry
+ */
+static int32_t ieee_segment(char *name, int *bits)
+{
+    /*
+     * We call the label manager here to define a name for the new
+     * segment, and when our _own_ label-definition stub gets
+     * called in return, it should register the new segment name
+     * using the pointer it gets passed. That way we save memory,
+     * by sponging off the label manager.
+     */
+    if (!name) {
+        *bits = 16;
+        if (!any_segs)
+            return 0;
+        return seghead->index;
+    } else {
+        struct ieeeSection *seg;
+        int ieee_idx, attrs;
+	bool rn_error;
+        char *p;
+
+        /*
+         * Look for segment attributes.
+         */
+        attrs = 0;
+        while (*name == '.')
+            name++;             /* hack, but a documented one */
+        p = name;
+        while (*p && !nasm_isspace(*p))
+            p++;
+        if (*p) {
+            *p++ = '\0';
+            while (*p && nasm_isspace(*p))
+                *p++ = '\0';
+        }
+        while (*p) {
+            while (*p && !nasm_isspace(*p))
+                p++;
+            if (*p) {
+                *p++ = '\0';
+                while (*p && nasm_isspace(*p))
+                    *p++ = '\0';
+            }
+
+            attrs++;
+        }
+
+        ieee_idx = 1;
+        for (seg = seghead; seg; seg = seg->next) {
+            ieee_idx++;
+            if (!strcmp(seg->name, name)) {
+                if (attrs > 0 && seg->pass_last_seen == pass_count())
+                    nasm_warn(WARN_OTHER, "segment attributes specified on"
+                              " redeclaration of segment: ignoring");
+                if (seg->use32)
+                    *bits = 32;
+                else
+                    *bits = 16;
+
+                seg->pass_last_seen = pass_count();
+                return seg->index;
+            }
+        }
+
+        *segtail = seg = nasm_malloc(sizeof(*seg));
+        seg->next = NULL;
+        segtail = &seg->next;
+        seg->index = seg_alloc();
+        seg->ieee_index = ieee_idx;
+        any_segs = true;
+        seg->name = NULL;
+        seg->currentpos = 0;
+        seg->align = 1;         /* default */
+        seg->use32 = *bits == 32;       /* default to user spec */
+        seg->combine = CMB_PUBLIC;      /* default */
+        seg->pubhead = NULL;
+        seg->pubtail = &seg->pubhead;
+        seg->data = NULL;
+        seg->fptr = NULL;
+        seg->lochead = NULL;
+        seg->loctail = &seg->lochead;
+
+        /*
+         * Process the segment attributes.
+         */
+        p = name;
+        while (attrs--) {
+            p += strlen(p);
+            while (!*p)
+                p++;
+
+            /*
+             * `p' contains a segment attribute.
+             */
+            if (!nasm_stricmp(p, "private"))
+                seg->combine = CMB_PRIVATE;
+            else if (!nasm_stricmp(p, "public"))
+                seg->combine = CMB_PUBLIC;
+            else if (!nasm_stricmp(p, "common"))
+                seg->combine = CMB_COMMON;
+            else if (!nasm_stricmp(p, "use16"))
+                seg->use32 = false;
+            else if (!nasm_stricmp(p, "use32"))
+                seg->use32 = true;
+            else if (!nasm_strnicmp(p, "align=", 6)) {
+                seg->align = readnum(p + 6, &rn_error);
+                if (seg->align == 0)
+                    seg->align = 1;
+                if (rn_error) {
+                    seg->align = 1;
+                    nasm_nonfatal("segment alignment should be numeric");
+                }
+                switch (seg->align) {
+                case 1:        /* BYTE */
+                case 2:        /* WORD */
+                case 4:        /* DWORD */
+                case 16:       /* PARA */
+                case 256:      /* PAGE */
+                case 8:
+                case 32:
+                case 64:
+                case 128:
+                    break;
+                default:
+                    nasm_nonfatal("invalid alignment value %d", seg->align);
+                    seg->align = 1;
+                    break;
+                }
+            } else if (!nasm_strnicmp(p, "absolute=", 9)) {
+                seg->align = SEG_ABS + readnum(p + 9, &rn_error);
+                if (rn_error)
+                    nasm_nonfatal("argument to `absolute' segment"
+                                  " attribute should be numeric");
+            }
+        }
+
+        ieee_seg_needs_update = seg;
+        if (seg->align >= SEG_ABS)
+            define_label(name, NO_SEG, seg->align - SEG_ABS, false);
+        else
+            define_label(name, seg->index + 1, 0L, false);
+        ieee_seg_needs_update = NULL;
+
+        /*
+         * In commit 98578071b9d71ecaa2344dd9c185237c1765041e
+         * we reworked labels significantly which in turn lead
+         * to the case where seg->name = NULL here and we get
+         * nil dereference in next segments definitions.
+         *
+         * Lets placate this case with explicit name setting
+         * if labels engine didn't set it yet.
+         *
+         * FIXME: Need to revisit this moment if such fix doesn't
+         * break anything but since IEEE 695 format is veeery
+         * old I don't expect there are many users left. In worst
+         * case this should only lead to a memory leak.
+         */
+        if (!seg->name)
+            seg->name = nasm_strdup(name);
+
+        if (seg->use32)
+            *bits = 32;
+        else
+            *bits = 16;
+        return seg->index;
+    }
+}
+
+/*
+ * directives supported
+ */
+static enum directive_result
+ieee_directive(enum directive directive, char *value)
+{
+    (void)value;
+
+    switch (directive) {
+    case D_UPPERCASE:
+        ieee_uppercase = true;
+        return DIRR_OK;
+
+    default:
+	return DIRR_UNKNOWN;
+    }
+}
+
+static void ieee_sectalign(int32_t seg, unsigned int value)
+{
+    struct ieeeSection *s;
+
+    list_for_each(s, seghead) {
+        if (s->index == seg)
+            break;
+    }
+
+    /*
+     * 256 is maximum there, note it may happen
+     * that align is issued on "absolute" segment
+     * it's fine since SEG_ABS > 256 and we never
+     * get escape this test
+     */
+    if (!s || !is_power2(value) || value > 256)
+        return;
+
+    if ((unsigned int)s->align < value)
+        s->align = value;
+}
+
+/*
+ * Return segment data
+ */
+static int32_t ieee_segbase(int32_t segment)
+{
+    struct ieeeSection *seg;
+
+    /*
+     * Find the segment in our list.
+     */
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segment - 1)
+            break;
+
+    if (!seg)
+        return segment;         /* not one of ours - leave it alone */
+
+    if (seg->align >= SEG_ABS)
+        return seg->align;      /* absolute segment */
+
+    return segment;             /* no special treatment */
+}
+
+static void ieee_write_file(void)
+{
+    const struct tm * const thetime = &official_compile_time.local;
+    struct FileName *fn;
+    struct ieeeSection *seg;
+    struct ieeePublic *pub, *loc;
+    struct ieeeExternal *ext;
+    struct ieeeObjData *data;
+    struct ieeeFixupp *fix;
+    struct Array *arr;
+    int i;
+    const bool debuginfo = (dfmt == &ladsoft_debug_form);
+
+    /*
+     * Write the module header
+     */
+    ieee_putascii("MBFNASM,%02X%s.\n", strlen(ieee_infile), ieee_infile);
+
+    /*
+     * Write the NASM boast comment.
+     */
+    ieee_putascii("CO0,%02X%s.\n", nasm_comment_len(), nasm_comment());
+
+    /*
+     * write processor-specific information
+     */
+    ieee_putascii("AD8,4,L.\n");
+
+    /*
+     * date and time
+     */
+    ieee_putascii("DT%04d%02d%02d%02d%02d%02d.\n",
+                  1900 + thetime->tm_year, thetime->tm_mon + 1,
+                  thetime->tm_mday, thetime->tm_hour, thetime->tm_min,
+                  thetime->tm_sec);
+    /*
+     * if debugging, dump file names
+     */
+    for (fn = fnhead; fn && debuginfo; fn = fn->next) {
+        ieee_putascii("C0105,%02X%s.\n", strlen(fn->name), fn->name);
+    }
+
+    ieee_putascii("CO101,07ENDHEAD.\n");
+    /*
+     * the standard doesn't specify when to put checksums,
+     * we'll just do it periodically.
+     */
+    ieee_putcs(false);
+
+    /*
+     * Write the section headers
+     */
+    seg = seghead;
+    if (!debuginfo && seg && !strcmp(seg->name, "??LINE"))
+        seg = seg->next;
+    while (seg) {
+        char buf[256];
+        char attrib;
+        switch (seg->combine) {
+        case CMB_PUBLIC:
+        default:
+            attrib = 'C';
+            break;
+        case CMB_PRIVATE:
+            attrib = 'S';
+            break;
+        case CMB_COMMON:
+            attrib = 'M';
+            break;
+        }
+        ieee_unqualified_name(buf, seg->name);
+        if (seg->align >= SEG_ABS) {
+            ieee_putascii("ST%X,A,%02X%s.\n", seg->ieee_index,
+                          strlen(buf), buf);
+            ieee_putascii("ASL%X,%lX.\n", seg->ieee_index,
+                          (seg->align - SEG_ABS) * 16);
+        } else {
+            ieee_putascii("ST%X,%c,%02X%s.\n", seg->ieee_index, attrib,
+                          strlen(buf), buf);
+            ieee_putascii("SA%X,%lX.\n", seg->ieee_index, seg->align);
+            ieee_putascii("ASS%X,%X.\n", seg->ieee_index,
+                          seg->currentpos);
+        }
+        seg = seg->next;
+    }
+    /*
+     * write the start address if there is one
+     */
+    if (ieee_entry_seg && seghead) {
+        for (seg = seghead; seg; seg = seg->next)
+            if (seg->index == ieee_entry_seg)
+                break;
+        if (!seg)
+            nasm_panic("Start address records are incorrect");
+        else
+            ieee_putascii("ASG,R%X,%lX,+.\n", seg->ieee_index,
+                          ieee_entry_ofs);
+    }
+
+    ieee_putcs(false);
+    /*
+     * Write the publics
+     */
+    i = 1;
+    for (seg = seghead; seg; seg = seg->next) {
+        for (pub = seg->pubhead; pub; pub = pub->next) {
+            char buf[256];
+            ieee_unqualified_name(buf, pub->name);
+            ieee_putascii("NI%X,%02X%s.\n", i, strlen(buf), buf);
+            if (pub->segment == -1)
+                ieee_putascii("ASI%X,R%X,%lX,+.\n", i, pub->index,
+                              pub->offset);
+            else
+                ieee_putascii("ASI%X,%lX,%lX,+.\n", i, pub->segment * 16,
+                              pub->offset);
+            if (debuginfo) {
+                if (pub->type >= 0x100)
+                    ieee_putascii("ATI%X,T%X.\n", i, pub->type - 0x100);
+                else
+                    ieee_putascii("ATI%X,%X.\n", i, pub->type);
+            }
+            i++;
+        }
+    }
+    pub = fpubhead;
+    i = 1;
+    while (pub) {
+        char buf[256];
+        ieee_unqualified_name(buf, pub->name);
+        ieee_putascii("NI%X,%02X%s.\n", i, strlen(buf), buf);
+        if (pub->segment == -1)
+            ieee_putascii("ASI%X,R%X,%lX,+.\n", i, pub->index,
+                          pub->offset);
+        else
+            ieee_putascii("ASI%X,%lX,%lX,+.\n", i, pub->segment * 16,
+                          pub->offset);
+        if (debuginfo) {
+            if (pub->type >= 0x100)
+                ieee_putascii("ATI%X,T%X.\n", i, pub->type - 0x100);
+            else
+                ieee_putascii("ATI%X,%X.\n", i, pub->type);
+        }
+        i++;
+        pub = pub->next;
+    }
+    /*
+     * Write the externals
+     */
+    ext = exthead;
+    i = 1;
+    while (ext) {
+        char buf[256];
+        ieee_unqualified_name(buf, ext->name);
+        ieee_putascii("NX%X,%02X%s.\n", i++, strlen(buf), buf);
+        ext = ext->next;
+    }
+    ieee_putcs(false);
+
+    /*
+     * IEEE doesn't have a standard pass break record
+     * so use the ladsoft variant
+     */
+    ieee_putascii("CO100,06ENDSYM.\n");
+
+    /*
+     * now put types
+     */
+    i = ARRAY_BOT;
+    for (arr = arrhead; arr && debuginfo; arr = arr->next) {
+        ieee_putascii("TY%X,20,%X,%lX.\n", i++, arr->basetype,
+                      arr->size);
+    }
+    /*
+     * now put locals
+     */
+    i = 1;
+    for (seg = seghead; seg && debuginfo; seg = seg->next) {
+        for (loc = seg->lochead; loc; loc = loc->next) {
+            char buf[256];
+            ieee_unqualified_name(buf, loc->name);
+            ieee_putascii("NN%X,%02X%s.\n", i, strlen(buf), buf);
+            if (loc->segment == -1)
+                ieee_putascii("ASN%X,R%X,%lX,+.\n", i, loc->index,
+                              loc->offset);
+            else
+                ieee_putascii("ASN%X,%lX,%lX,+.\n", i, loc->segment * 16,
+                              loc->offset);
+            if (debuginfo) {
+                if (loc->type >= 0x100)
+                    ieee_putascii("ATN%X,T%X.\n", i, loc->type - 0x100);
+                else
+                    ieee_putascii("ATN%X,%X.\n", i, loc->type);
+            }
+            i++;
+        }
+    }
+
+    /*
+     *  put out section data;
+     */
+    seg = seghead;
+    if (!debuginfo && seg && !strcmp(seg->name, "??LINE"))
+        seg = seg->next;
+    while (seg) {
+        if (seg->currentpos) {
+            int32_t size, org = 0;
+            data = seg->data;
+            ieee_putascii("SB%X.\n", seg->ieee_index);
+            fix = seg->fptr;
+            while (fix) {
+                size = HUNKSIZE - (org % HUNKSIZE);
+                size =
+                    size + org >
+                    seg->currentpos ? seg->currentpos - org : size;
+                size = fix->offset - org > size ? size : fix->offset - org;
+                org = ieee_putld(org, org + size, data->data);
+                if (org % HUNKSIZE == 0)
+                    data = data->next;
+                if (org == fix->offset) {
+                    org += ieee_putlr(fix);
+                    fix = fix->next;
+                }
+            }
+            while (org < seg->currentpos && data) {
+                size =
+                    seg->currentpos - org >
+                    HUNKSIZE ? HUNKSIZE : seg->currentpos - org;
+                org = ieee_putld(org, org + size, data->data);
+                data = data->next;
+            }
+            ieee_putcs(false);
+
+        }
+        seg = seg->next;
+    }
+    /*
+     * module end record
+     */
+    ieee_putascii("ME.\n");
+}
+
+static void ieee_write_byte(struct ieeeSection *seg, int data)
+{
+    int temp;
+    if (!(temp = seg->currentpos++ % HUNKSIZE))
+        ieee_data_new(seg);
+    seg->datacurr->data[temp] = data;
+}
+
+static void ieee_write_word(struct ieeeSection *seg, int data)
+{
+    ieee_write_byte(seg, data & 0xFF);
+    ieee_write_byte(seg, (data >> 8) & 0xFF);
+}
+
+static void ieee_write_dword(struct ieeeSection *seg, int32_t data)
+{
+    ieee_write_byte(seg, data & 0xFF);
+    ieee_write_byte(seg, (data >> 8) & 0xFF);
+    ieee_write_byte(seg, (data >> 16) & 0xFF);
+    ieee_write_byte(seg, (data >> 24) & 0xFF);
+}
+static void printf_func(1, 2) ieee_putascii(char *format, ...)
+{
+    char buffer[256];
+    size_t i, l;
+    va_list ap;
+
+    va_start(ap, format);
+    l = vsnprintf(buffer, sizeof(buffer), format, ap);
+    nasm_assert(l < sizeof(buffer));
+    for (i = 0; i < l; i++)
+        if ((uint8_t)buffer[i] > 31)
+            checksum += buffer[i];
+    va_end(ap);
+    fputs(buffer, ofile);
+}
+
+/*
+ * put out a checksum record */
+static void ieee_putcs(int toclear)
+{
+    if (toclear) {
+        ieee_putascii("CS.\n");
+    } else {
+        checksum += 'C';
+        checksum += 'S';
+        ieee_putascii("CS%02X.\n", checksum & 127);
+    }
+    checksum = 0;
+}
+
+static int32_t ieee_putld(int32_t start, int32_t end, uint8_t *buf)
+{
+    int32_t val;
+    if (start == end)
+        return (start);
+    val = start % HUNKSIZE;
+    /* fill up multiple lines */
+    while (end - start >= LDPERLINE) {
+        int i;
+        ieee_putascii("LD");
+        for (i = 0; i < LDPERLINE; i++) {
+            ieee_putascii("%02X", buf[val++]);
+            start++;
+        }
+        ieee_putascii(".\n");
+    }
+    /* if no partial lines */
+    if (start == end)
+        return (start);
+    /* make a partial line */
+    ieee_putascii("LD");
+    while (start < end) {
+        ieee_putascii("%02X", buf[val++]);
+        start++;
+    }
+    ieee_putascii(".\n");
+    return (start);
+}
+static int32_t ieee_putlr(struct ieeeFixupp *p)
+{
+/*
+ * To deal with the vagaries of segmentation the LADsoft linker
+ * defines two types of segments: absolute and virtual.  Note that
+ * 'absolute' in this context is a different thing from the IEEE
+ * definition of an absolute segment type, which is also supported. If a
+ * segment is linked in virtual mode the low limit (L-var) is
+ * subtracted from each R,X, and P variable which appears in an
+ * expression, so that we can have relative offsets.  Meanwhile
+ * in the ABSOLUTE mode this subtraction is not done and
+ * so we can use absolute offsets from 0.  In the LADsoft linker
+ * this configuration is not done in the assemblker source but in
+ * a source the linker reads.  Generally this type of thing only
+ * becomes an issue if real mode code is used.  A pure 32-bit linker could
+ * get away without defining the virtual mode...
+ */
+    char buf[40];
+    int32_t size = p->size;
+    switch (p->ftype) {
+    case FT_SEG:
+        if (p->id1 < 0)
+            sprintf(buf, "%"PRIX32"", -p->id1);
+        else
+            sprintf(buf, "L%"PRIX32",10,/", p->id1);
+        break;
+    case FT_OFS:
+        sprintf(buf, "R%"PRIX32",%"PRIX32",+", p->id1, p->addend);
+        break;
+    case FT_REL:
+        sprintf(buf, "R%"PRIX32",%"PRIX32",+,P,-,%X,-", p->id1, p->addend, p->size);
+        break;
+
+    case FT_WRT:
+        if (p->id2 < 0)
+            sprintf(buf, "R%"PRIX32",%"PRIX32",+,L%"PRIX32",+,%"PRIX32",-", p->id2, p->addend,
+                    p->id2, -p->id1 * 16);
+        else
+            sprintf(buf, "R%"PRIX32",%"PRIX32",+,L%"PRIX32",+,L%"PRIX32",-", p->id2, p->addend,
+                    p->id2, p->id1);
+        break;
+    case FT_EXT:
+        sprintf(buf, "X%"PRIX32"", p->id1);
+        break;
+    case FT_EXTREL:
+        sprintf(buf, "X%"PRIX32",P,-,%"PRIX32",-", p->id1, size);
+        break;
+    case FT_EXTSEG:
+        /* We needed a non-ieee hack here.
+         * We introduce the Y variable, which is the low
+         * limit of the native segment the extern resides in
+         */
+        sprintf(buf, "Y%"PRIX32",10,/", p->id1);
+        break;
+    case FT_EXTWRT:
+        if (p->id2 < 0)
+            sprintf(buf, "X%"PRIX32",Y%"PRIX32",+,%"PRIX32",-", p->id2, p->id2,
+                    -p->id1 * 16);
+        else
+            sprintf(buf, "X%"PRIX32",Y%"PRIX32",+,L%"PRIX32",-", p->id2, p->id2, p->id1);
+        break;
+    }
+    ieee_putascii("LR(%s,%"PRIX32").\n", buf, size);
+
+    return (size);
+}
+
+/* Dump all segment data (text and fixups )*/
+
+static void ieee_unqualified_name(char *dest, char *source)
+{
+    if (ieee_uppercase) {
+        while (*source)
+            *dest++ = toupper(*source++);
+        *dest = 0;
+    } else
+        strcpy(dest, source);
+}
+static void dbgls_init(void)
+{
+    int tempint;
+
+    fnhead = NULL;
+    fntail = &fnhead;
+    arrindex = ARRAY_BOT;
+    arrhead = NULL;
+    arrtail = &arrhead;
+    ieee_segment("??LINE", &tempint);
+    any_segs = false;
+}
+static void dbgls_cleanup(void)
+{
+    struct ieeeSection *segtmp;
+    while (fnhead) {
+        struct FileName *fntemp = fnhead;
+        fnhead = fnhead->next;
+        nasm_free(fntemp->name);
+        nasm_free(fntemp);
+    }
+    for (segtmp = seghead; segtmp; segtmp = segtmp->next) {
+        while (segtmp->lochead) {
+            struct ieeePublic *loctmp = segtmp->lochead;
+            segtmp->lochead = loctmp->next;
+            nasm_free(loctmp->name);
+            nasm_free(loctmp);
+        }
+    }
+    while (arrhead) {
+        struct Array *arrtmp = arrhead;
+        arrhead = arrhead->next;
+        nasm_free(arrtmp);
+    }
+}
+
+/*
+ * because this routine is not bracketed in
+ * the main program, this routine will be called even if there
+ * is no request for debug info
+ * so, we have to make sure the ??LINE segment is available
+ * as the first segment when this debug format is selected
+ */
+static void dbgls_linnum(const char *lnfname, int32_t lineno, int32_t segto)
+{
+    struct FileName *fn;
+    struct ieeeSection *seg;
+    int i = 0;
+    if (segto == NO_SEG)
+        return;
+
+    /*
+     * If `any_segs' is still false, we must define a default
+     * segment.
+     */
+    if (!any_segs) {
+        int tempint;            /* ignored */
+        if (segto != ieee_segment("__NASMDEFSEG", &tempint))
+            nasm_panic("strange segment conditions in IEEE driver");
+    }
+
+    /*
+     * Find the segment we are targeting.
+     */
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segto)
+            break;
+    if (!seg)
+        nasm_panic("lineno directed to nonexistent segment?");
+
+    for (fn = fnhead; fn; fn = fn->next) {
+        if (!nasm_stricmp(lnfname, fn->name))
+            break;
+        i++;
+    }
+    if (!fn) {
+        fn = nasm_malloc(sizeof(*fn));
+        fn->name = nasm_malloc(strlen(lnfname) + 1);
+        fn->index = i;
+        strcpy(fn->name, lnfname);
+        fn->next = NULL;
+        *fntail = fn;
+        fntail = &fn->next;
+    }
+    ieee_write_byte(seghead, fn->index);
+    ieee_write_word(seghead, lineno);
+    ieee_write_fixup(segto, NO_SEG, seghead, 4, OUT_ADDRESS,
+                     seg->currentpos);
+
+}
+static void dbgls_deflabel(char *name, int32_t segment,
+                           int64_t offset, int is_global, char *special)
+{
+    struct ieeeSection *seg;
+
+    /* Keep compiler from warning about special */
+    (void)special;
+
+    /*
+     * Note: ..[^@] special symbols are filtered in labels.c
+     */
+
+    /*
+     * If it's a special-retry from pass two, discard it.
+     */
+    if (is_global == 3)
+        return;
+
+    /*
+     * Case (i):
+     */
+    if (ieee_seg_needs_update)
+        return;
+    if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
+        return;
+
+    if (segment >= SEG_ABS || segment == NO_SEG) {
+        return;
+    }
+
+    /*
+     * If `any_segs' is still false, we might need to define a
+     * default segment, if they're trying to declare a label in
+     * `first_seg'.  But the label should exist due to a prior
+     * call to ieee_deflabel so we can skip that.
+     */
+
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segment) {
+            struct ieeePublic *loc;
+            /*
+             * Case (ii). Maybe MODPUB someday?
+             */
+            if (!is_global) {
+                last_defined = loc = nasm_malloc(sizeof(*loc));
+                *seg->loctail = loc;
+                seg->loctail = &loc->next;
+                loc->next = NULL;
+                loc->name = nasm_strdup(name);
+                loc->offset = offset;
+                loc->segment = -1;
+                loc->index = seg->ieee_index;
+            }
+        }
+}
+static void dbgls_typevalue(int32_t type)
+{
+    int elem = TYM_ELEMENTS(type);
+    type = TYM_TYPE(type);
+
+    if (!last_defined)
+        return;
+
+    switch (type) {
+    case TY_BYTE:
+        last_defined->type = 1; /* uint8_t */
+        break;
+    case TY_WORD:
+        last_defined->type = 3; /* unsigned word */
+        break;
+    case TY_DWORD:
+        last_defined->type = 5; /* unsigned dword */
+        break;
+    case TY_FLOAT:
+        last_defined->type = 9; /* float */
+        break;
+    case TY_QWORD:
+        last_defined->type = 10;        /* qword */
+        break;
+    case TY_TBYTE:
+        last_defined->type = 11;        /* TBYTE */
+        break;
+    default:
+        last_defined->type = 0x10;      /* near label */
+        break;
+    }
+
+    if (elem > 1) {
+        struct Array *arrtmp = nasm_malloc(sizeof(*arrtmp));
+        int vtype = last_defined->type;
+        arrtmp->size = elem;
+        arrtmp->basetype = vtype;
+        arrtmp->next = NULL;
+        last_defined->type = arrindex++ + 0x100;
+        *arrtail = arrtmp;
+        arrtail = &(arrtmp->next);
+    }
+    last_defined = NULL;
+}
+static void dbgls_output(int output_type, void *param)
+{
+    (void)output_type;
+    (void)param;
+}
+static const struct dfmt ladsoft_debug_form = {
+    "LADsoft Debug Records",
+    "ladsoft",
+    dbgls_init,
+    dbgls_linnum,
+    dbgls_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    dbgls_typevalue,
+    dbgls_output,
+    dbgls_cleanup,
+    NULL                        /* pragma list */
+};
+static const struct dfmt * const ladsoft_debug_arr[3] = {
+    &ladsoft_debug_form,
+    &null_debug_form,
+    NULL
+};
+const struct ofmt of_ieee = {
+    "IEEE-695 (LADsoft variant) object file format",
+    "ieee",
+    ".o",
+    OFMT_TEXT,
+    32,
+    ladsoft_debug_arr,
+    &ladsoft_debug_form,
+    NULL,
+    ieee_init,
+    null_reset,
+    nasm_do_legacy_output,
+    ieee_out,
+    ieee_deflabel,
+    ieee_segment,
+    NULL,
+    ieee_sectalign,
+    ieee_segbase,
+    ieee_directive,
+    ieee_cleanup,
+    NULL                        /* pragma list */
+};
+
+#endif                          /* OF_IEEE */
diff --git a/vere/ext/nasm/output/outlib.c b/vere/ext/nasm/output/outlib.c
new file mode 100644
index 0000000..54c8753
--- /dev/null
+++ b/vere/ext/nasm/output/outlib.c
@@ -0,0 +1,324 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outlib.c
+ *
+ * Common routines for the output backends.
+ */
+
+#include "outlib.h"
+#include "raa.h"
+
+uint64_t realsize(enum out_type type, uint64_t size)
+{
+    switch (type) {
+    case OUT_REL1ADR:
+	return 1;
+    case OUT_REL2ADR:
+	return 2;
+    case OUT_REL4ADR:
+	return 4;
+    case OUT_REL8ADR:
+	return 8;
+    default:
+	return size;
+    }
+}
+
+/* Common section/symbol handling */
+
+struct ol_sect *_ol_sect_list;
+uint64_t _ol_nsects;             /* True sections, not external symbols */
+static struct ol_sect **ol_sect_tail = &_ol_sect_list;
+static struct hash_table ol_secthash;
+static struct RAA *ol_sect_index_tbl;
+
+struct ol_sym *_ol_sym_list;
+uint64_t _ol_nsyms;
+static struct ol_sym **ol_sym_tail = &_ol_sym_list;
+static struct hash_table ol_symhash;
+
+void ol_init(void)
+{
+}
+
+static void ol_free_symbols(void)
+{
+    struct ol_sym *s, *stmp;
+
+    hash_free(&ol_symhash);
+
+    list_for_each_safe(s, stmp, _ol_sym_list) {
+        nasm_free((char *)s->name);
+        nasm_free(s);
+    }
+
+    _ol_nsyms = 0;
+    _ol_sym_list = NULL;
+    ol_sym_tail = &_ol_sym_list;
+}
+
+static void ol_free_sections(void)
+{
+    struct ol_sect *s, *stmp;
+
+    hash_free(&ol_secthash);
+    raa_free(ol_sect_index_tbl);
+    ol_sect_index_tbl = NULL;
+
+    list_for_each_safe(s, stmp, _ol_sect_list) {
+        saa_free(s->data);
+        saa_free(s->reloc);
+        nasm_free((char *)s->name);
+        nasm_free(s);
+    }
+
+    _ol_nsects = 0;
+    _ol_sect_list = NULL;
+    ol_sect_tail = &_ol_sect_list;
+}
+
+void ol_cleanup(void)
+{
+    ol_free_symbols();
+    ol_free_sections();
+}
+
+/*
+ * Allocate a section index and add a section, subsection, or external
+ * symbol to the section-by-index table. If the index provided is zero,
+ * allocate a new index via seg_alloc().
+ */
+static uint32_t ol_seg_alloc(void *s, uint32_t ix)
+{
+    if (!ix)
+        ix = seg_alloc();
+    ol_sect_index_tbl = raa_write_ptr(ol_sect_index_tbl, ix >> 1, s);
+    return ix;
+}
+
+/*
+ * Find a section or create a new section structure if it does not exist
+ * and allocate it an index value via seg_alloc().
+ */
+struct ol_sect *_ol_get_sect(const char *name, size_t ssize, size_t rsize)
+{
+    struct ol_sect *s, **sp;
+    struct hash_insert hi;
+
+    sp = (struct ol_sect **)hash_find(&ol_secthash, name, &hi);
+    if (sp)
+        return *sp;
+
+    s             = nasm_zalloc(ssize);
+    s->syml.tail  = &s->syml.head;
+    s->name       = nasm_strdup(name);
+    s->data       = saa_init(1);
+    s->reloc      = saa_init(rsize);
+    *ol_sect_tail = s;
+    ol_sect_tail  = &s->next;
+    _ol_nsects++;
+    s->index     = s->subindex = ol_seg_alloc(s, 0);
+
+    hash_add(&hi, s->name, s);
+    return s;
+}
+
+/* Find a section by name without creating one */
+struct ol_sect *_ol_sect_by_name(const char *name)
+{
+    struct ol_sect **sp;
+
+    sp = (struct ol_sect **)hash_find(&ol_secthash, name, NULL);
+    return sp ? *sp : NULL;
+}
+
+/* Find a section or external symbol by index; NULL if not valid */
+struct ol_sect *_ol_sect_by_index(int32_t index)
+{
+    uint32_t ix = index;
+
+    if (unlikely(ix >= SEG_ABS))
+        return NULL;
+
+    return raa_read_ptr(ol_sect_index_tbl, ix >> 1);
+}
+
+/*
+ * Start a new subsection for the given section. At the moment, once a
+ * subsection has been created, it is not possible to revert to an
+ * earlier subsection. ol_sect_by_index() will return the main section
+ * structure. Returns the new section index.  This is used to prevent
+ * the front end from optimizing across subsection boundaries.
+ */
+int32_t _ol_new_subsection(struct ol_sect *sect)
+{
+    if (unlikely(!sect))
+        return NO_SEG;
+
+    return sect->subindex = ol_seg_alloc(sect, 0);
+}
+
+/*
+ * Insert a symbol into a list; need to use upcasting using container_of()
+ * to walk the list later.
+ */
+static void ol_add_sym_to(struct ol_symlist *syml, struct ol_symhead *head,
+                          uint64_t offset)
+{
+    syml->tree.key = offset;
+    head->tree     = rb_insert(head->tree, &syml->tree);
+    *head->tail    = syml;
+    head->tail     = &syml->next;
+    head->n++;
+}
+
+/*
+ * Create a location structure from seg:offs
+ */
+void ol_mkloc(struct ol_loc *loc, int64_t offs, int32_t seg)
+{
+    nasm_zero(*loc);
+    loc->offs = offs;
+
+    if (unlikely((uint32_t)seg >= SEG_ABS)) {
+        if (likely(seg == NO_SEG)) {
+            loc->seg.t     = OS_NOSEG;
+        } else {
+            loc->seg.t     = OS_ABS;
+            loc->seg.index = seg - SEG_ABS;
+        }
+    } else {
+        loc->seg.index  = seg & ~1;
+        loc->seg.t      = OS_SECT | (seg & 1);
+        loc->seg.s.sect = _ol_sect_by_index(loc->seg.index);
+    }
+}
+
+/*
+ * Create a new symbol. If this symbol is OS_OFFS, add it to the relevant
+ * section, too. If the symbol already exists, return NULL; this is
+ * different from ol_get_section() as a single section may be invoked
+ * many times. On the contrary, the front end will prevent a single symbol
+ * from being defined more than once.
+ *
+ * If flags has OF_GLOBAL set, add it to the global symbol hash for
+ * the containing section if applicable.
+ *
+ * If flags has OF_IMPSEC set, allocate a segment index for it via
+ * seg_alloc() unless v->index is already set, and add it to the
+ * section by index list.
+ */
+struct ol_sym *_ol_new_sym(const char *name, const struct ol_loc *v,
+                           uint32_t flags, size_t size)
+{
+    struct hash_insert hi;
+    struct ol_sym *sym;
+
+    if (hash_find(&ol_symhash, name, &hi))
+        return NULL;            /* Symbol already exists */
+
+    flags     |= OF_SYMBOL;
+
+    sym        = nasm_zalloc(size);
+    sym->name  = nasm_strdup(name);
+    sym->v     = *v;
+
+    if (sym->v.seg.t & OS_SECT) {
+        struct ol_sect *sect = sym->v.seg.s.sect;
+
+        if (!sect || (sect->flags & OF_SYMBOL))
+            /* Must be an external or common reference */
+            flags |= OF_IMPSEC;
+
+        if (flags & OF_IMPSEC) {
+            /* Metasection */
+            if (!sym->v.seg.s.sym) {
+                sym->v.seg.s.sym = sym;
+                sym->v.seg.index = ol_seg_alloc(sym, sym->v.seg.index);
+            }
+        } else if (sym->v.seg.t == OS_OFFS) {
+            struct ol_sect * const sect = sym->v.seg.s.sect;
+            const uint64_t offs = sym->v.offs;
+
+            ol_add_sym_to(&sym->syml, &sect->syml, offs);
+            if (flags & OF_GLOBAL)
+                ol_add_sym_to(&sym->symg, &sect->symg, offs);
+        }
+    }
+    sym->flags = flags;
+
+    *ol_sym_tail = sym;
+    ol_sym_tail  = &sym->next;
+    _ol_nsyms++;
+
+    hash_add(&hi, sym->name, sym);
+    return sym;
+}
+
+/* Find a symbol in the global namespace */
+struct ol_sym *_ol_sym_by_name(const char *name)
+{
+    struct ol_sym **symp;
+
+    symp = (struct ol_sym **)hash_find(&ol_symhash, name, NULL);
+    return symp ? *symp : NULL;
+}
+
+/*
+ * Find a symbol by address in a specific section. If no symbol is defined
+ * at that exact address, return the immediately previously defined one.
+ * If global is set, then only return global symbols.
+ */
+struct ol_sym *_ol_sym_by_address(struct ol_sect *sect, int64_t addr,
+                                  bool global)
+{
+    struct ol_symhead *head;
+    size_t t_offs;
+    struct rbtree *t;
+
+    if (global) {
+        head = &sect->symg;
+        t_offs = offsetof(struct ol_sym, symg.tree);
+    } else {
+        head = &sect->syml;
+        t_offs = offsetof(struct ol_sym, syml.tree);
+    }
+
+    t = rb_search(head->tree, addr);
+    if (!t)
+        return NULL;
+
+    return (struct ol_sym *)((char *)t - t_offs);
+}
diff --git a/vere/ext/nasm/output/outlib.h b/vere/ext/nasm/output/outlib.h
new file mode 100644
index 0000000..7f6a789
--- /dev/null
+++ b/vere/ext/nasm/output/outlib.h
@@ -0,0 +1,313 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASM_OUTLIB_H
+#define NASM_OUTLIB_H
+
+#include "compiler.h"
+#include "nasm.h"
+#include "error.h"
+#include "hashtbl.h"
+#include "saa.h"
+#include "rbtree.h"
+
+uint64_t realsize(enum out_type type, uint64_t size);
+
+/* Do-nothing versions of some output routines */
+enum directive_result
+null_directive(enum directive directive, char *value);
+void null_sectalign(int32_t seg, unsigned int value);
+void null_reset(void);
+int32_t null_segbase(int32_t seg);
+
+/* Do-nothing versions of all the debug routines */
+void null_debug_init(void);
+void null_debug_linenum(const char *filename, int32_t linenumber,
+			int32_t segto);
+void null_debug_deflabel(char *name, int32_t segment, int64_t offset,
+                         int is_global, char *special);
+void null_debug_directive(const char *directive, const char *params);
+void null_debug_typevalue(int32_t type);
+void null_debug_output(int type, void *param);
+void null_debug_cleanup(void);
+extern const struct dfmt * const null_debug_arr[2];
+
+/* Wrapper for unported backends */
+void nasm_do_legacy_output(const struct out_data *data);
+
+/*
+ * Common routines for tasks that really should migrate into the core.
+ * This provides a common interface for maintaining sections and symbols,
+ * and provide quick lookups as well as declared-order sequential walks.
+ *
+ * These structures are intended to be embedded at the *top* of a
+ * backend-specific structure containing additional information.
+ *
+ * The tokens O_Section, O_Symbol and O_Reloc are intended to be
+ * defined as macros by the backend before including this file!
+ */
+
+struct ol_sect;
+struct ol_sym;
+
+#ifndef O_Section
+typedef struct ol_sect O_Section;
+#endif
+#ifndef O_Symbol
+typedef struct ol_sym O_Symbol;
+#endif
+#ifndef O_Reloc
+typedef void * O_Reloc;
+#endif
+
+/* Common section structure */
+
+/*
+ * Common flags for sections and symbols; low values reserved for
+ * backend.  Note that both ol_sect and ol_sym begin with a flags
+ * field, so if a section pointer points to an external symbol instead
+ * they can be trivially resolved.
+ */
+#define OF_SYMBOL 0x80000000
+#define OF_GLOBAL 0x40000000
+#define OF_IMPSEC 0x20000000
+#define OF_COMMON 0x10000000
+
+struct ol_sym;
+
+struct ol_symlist {
+    struct ol_symlist *next;
+    struct rbtree tree;
+};
+struct ol_symhead {
+    struct ol_symlist *head, **tail;
+    struct rbtree *tree;
+    uint64_t n;
+};
+
+struct ol_sect {
+    uint32_t flags;             /* Section/symbol flags */
+    struct ol_sect *next;       /* Next section in declared order */
+    const char *name;           /* Name of section */
+    struct ol_symhead syml;     /* All symbols in this section */
+    struct ol_symhead symg;     /* Global symbols in this section */
+    struct SAA *data;           /* Contents of section */
+    struct SAA *reloc;          /* Section relocations */
+    uint32_t index;             /* Primary section index */
+    uint32_t subindex;          /* Current subsection index */
+};
+
+/* Segment reference */
+enum ol_seg_type {
+    OS_NOSEG  = 0,                /* Plain number (no segment) */
+    OS_SEGREF = 1,                /* It is a segment reference */
+    OS_ABS    = 1,                /* Absolute segment reference */
+    OS_SECT   = 2,                /* It is a real section */
+    OS_OFFS   = OS_SECT,          /* Offset reference in section */
+    OS_SEG    = OS_SECT|OS_SEGREF /* Section reference */
+};
+
+union ol_segval {
+    struct ol_sect *sect;   /* Section structure */
+    struct ol_sym  *sym;    /* External symbol structure */
+};
+
+struct ol_seg {
+    union ol_segval  s;
+    enum ol_seg_type t;
+
+    /*
+     * For a section:          subsection index
+     * For a metasymbol:       virtual segment index
+     * For an absolute symbol: absolute value
+     */
+    uint32_t index;
+};
+
+/* seg:offs representing the full location value and type */
+struct ol_loc {
+    int64_t offs;
+    struct ol_seg seg;
+};
+
+/* Common symbol structure */
+struct ol_sym {
+    uint32_t flags;             /* Section/symbol flags */
+    uint32_t size;              /* Size value (for backend) */
+    struct ol_sym *next;       	/* Next symbol in declared order */
+    const char *name;           /* Symbol name */
+    struct ol_symlist syml;     /* Section-local symbol list */
+    struct ol_symlist symg;     /* Section-local global symbol list */
+    struct ol_loc p;            /* Symbol position ("where") */
+    struct ol_loc v;            /* Symbol value ("what") */
+};
+
+/*
+ * Operations
+ */
+void ol_init(void);
+void ol_cleanup(void);
+
+/* Convert offs:seg to a location structure */
+extern void
+ol_mkloc(struct ol_loc *loc, int64_t offs, int32_t seg);
+
+/* Get the section or external symbol from a struct ol_seg */
+static inline O_Section *seg_sect(struct ol_seg *seg)
+{
+    return (O_Section *)seg->s.sect;
+}
+static inline O_Symbol *seg_xsym(struct ol_seg *seg)
+{
+    return (O_Symbol *)seg->s.sym;
+}
+
+/*
+ * Return a pointer to the symbol structure if and only if a section is
+ * really a symbol of some kind (extern, common...)
+ */
+static inline struct ol_sym *_seg_extsym(struct ol_sect *sect)
+{
+    return (sect->flags & OF_SYMBOL) ? (struct ol_sym *)sect : NULL;
+}
+static inline O_Symbol *seg_extsym(O_Section *sect)
+{
+    return (O_Symbol *)_seg_extsym((struct ol_sect *)sect);
+}
+
+/*
+ * Find a section or create a new section structure if it does not exist
+ * and allocate it an index value via seg_alloc().
+ */
+extern struct ol_sect *
+_ol_get_sect(const char *name, size_t ssize, size_t rsize);
+static inline O_Section *ol_get_sect(const char *name)
+{
+    return (O_Section *)_ol_get_sect(name, sizeof(O_Section), sizeof(O_Reloc));
+}
+
+/* Find a section by name without creating one */
+extern struct ol_sect *_ol_sect_by_name(const char *);
+static inline O_Section *ol_sect_by_name(const char *name)
+{
+    return (O_Section *)_ol_sect_by_name(name);
+}
+
+/* Find a section or external symbol by index; NULL if not valid */
+extern struct ol_sect *_ol_sect_by_index(int32_t index);
+static inline O_Section *ol_sect_by_index(int32_t index)
+{
+    return (O_Section *)_ol_sect_by_index(index);
+}
+
+/* Global list of sections (not including external symbols) */
+extern struct ol_sect *_ol_sect_list;
+static inline O_Section *ol_sect_list(void)
+{
+    return (O_Section *)_ol_sect_list;
+}
+
+/* Count of sections (not including external symbols) */
+extern uint64_t _ol_nsects;
+static inline uint64_t ol_nsects(void)
+{
+    return _ol_nsects;
+}
+
+/*
+ * Start a new subsection for the given section. At the moment, once a
+ * subsection has been created, it is not possible to revert to an
+ * earlier subsection. ol_sect_by_index() will return the main section
+ * structure. Returns the new section index.  This is used to prevent
+ * the front end from optimizing across subsection boundaries.
+ */
+extern int32_t _ol_new_subsection(struct ol_sect *sect);
+static inline int32_t ol_new_subsection(O_Section *sect)
+{
+    return _ol_new_subsection((struct ol_sect *)sect);
+}
+
+/*
+ * Create a new symbol. If this symbol is OS_OFFS, add it to the relevant
+ * section, too. If the symbol already exists, return NULL; this is
+ * different from ol_get_section() as a single section may be invoked
+ * many times. On the contrary, the front end will prevent a single symbol
+ * from being defined more than once.
+ *
+ * If flags has OF_GLOBAL set, add it to the global symbol hash for the
+ * containing section. If flags has OF_IMPSEC set, allocate a segment
+ * index for it via seg_alloc() and add it to the section by index list.
+ */
+extern struct ol_sym *_ol_new_sym(const char *name, const struct ol_loc *v,
+                                  uint32_t flags, size_t size);
+static inline O_Symbol *ol_new_sym(const char *name, const struct ol_loc *v,
+                                   uint32_t flags)
+{
+    return (O_Symbol *)_ol_new_sym(name, v, flags, sizeof(O_Symbol));
+}
+
+/* Find a symbol by name in the global namespace */
+extern struct ol_sym *_ol_sym_by_name(const char *name);
+static inline O_Symbol *ol_sym_by_name(const char *name)
+{
+    return (O_Symbol *)_ol_sym_by_name(name);
+}
+
+/*
+ * Find a symbol by address in a specific section. If no symbol is defined
+ * at that exact address, return the immediately previously defined one.
+ * If global is set, then only return global symbols.
+ */
+extern struct ol_sym *_ol_sym_by_address(struct ol_sect *sect, int64_t addr,
+                                         bool global);
+static inline O_Symbol *ol_sym_by_address(O_Section *sect, int64_t addr,
+                                          bool global)
+{
+    return (O_Symbol *)_ol_sym_by_address((struct ol_sect *)sect, addr, global);
+}
+
+/* Global list of symbols */
+extern struct ol_sym *_ol_sym_list;
+static inline O_Symbol *ol_sym_list(void)
+{
+    return (O_Symbol *)_ol_sym_list;
+}
+
+/* Global count of symbols */
+extern uint64_t _ol_nsyms;
+static inline uint64_t ol_nsyms(void)
+{
+    return _ol_nsyms;
+}
+
+#endif /* NASM_OUTLIB_H */
diff --git a/vere/ext/nasm/output/outmacho.c b/vere/ext/nasm/output/outmacho.c
new file mode 100644
index 0000000..1e776f5
--- /dev/null
+++ b/vere/ext/nasm/output/outmacho.c
@@ -0,0 +1,2411 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outmacho.c	output routines for the Netwide Assembler to produce
+ *		NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X object files
+ */
+
+#include "compiler.h"
+
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "ilog2.h"
+#include "labels.h"
+#include "error.h"
+#include "saa.h"
+#include "raa.h"
+#include "rbtree.h"
+#include "hashtbl.h"
+#include "outform.h"
+#include "outlib.h"
+#include "ver.h"
+#include "dwarf.h"
+#include "macho.h"
+
+#if defined(OF_MACHO) || defined(OF_MACHO64)
+
+/* Mach-O in-file header structure sizes */
+#define MACHO_HEADER_SIZE		28
+#define MACHO_SEGCMD_SIZE		56
+#define MACHO_SECTCMD_SIZE		68
+#define MACHO_SYMCMD_SIZE		24
+#define MACHO_NLIST_SIZE		12
+#define MACHO_RELINFO_SIZE		8
+
+#define MACHO_HEADER64_SIZE		32
+#define MACHO_SEGCMD64_SIZE		72
+#define MACHO_SECTCMD64_SIZE		80
+#define MACHO_NLIST64_SIZE		16
+
+/* Mach-O relocations numbers */
+
+#define VM_PROT_DEFAULT	(VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
+#define VM_PROT_ALL	(VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
+
+/* Our internal relocation types */
+enum reltype {
+    RL_ABS,			/* Absolute relocation */
+    RL_REL,			/* Relative relocation */
+    RL_TLV,			/* Thread local */
+    RL_BRANCH,			/* Relative direct branch */
+    RL_SUB,			/* X86_64_RELOC_SUBTRACT */
+    RL_GOT,			/* X86_64_RELOC_GOT */
+    RL_GOTLOAD			/* X86_64_RELOC_GOT_LOAD */
+};
+#define RL_MAX_32	RL_TLV
+#define RL_MAX_64	RL_GOTLOAD
+
+struct macho_fmt {
+    uint32_t ptrsize;		/* Pointer size in bytes */
+    uint32_t mh_magic;		/* Which magic number to use */
+    uint32_t cpu_type;		/* Which CPU type */
+    uint32_t lc_segment;	/* Which segment load command */
+    uint32_t header_size;	/* Header size */
+    uint32_t segcmd_size;	/* Segment command size */
+    uint32_t sectcmd_size;	/* Section command size */
+    uint32_t nlist_size;	/* Nlist (symbol) size */
+    enum reltype maxreltype;	/* Maximum entry in enum reltype permitted */
+    uint32_t reloc_abs;		/* Absolute relocation type */
+    uint32_t reloc_rel;		/* Relative relocation type */
+    uint32_t reloc_tlv;		/* Thread local relocation type */
+    bool forcesym;		/* Always use "external" (symbol-relative) relocations */
+};
+
+static struct macho_fmt fmt;
+
+static void fwriteptr(uint64_t data, FILE * fp)
+{
+    fwriteaddr(data, fmt.ptrsize, fp);
+}
+
+struct section {
+    /* nasm internal data */
+    struct section *next;
+    struct SAA *data;
+    int32_t index;		/* Main section index */
+    int32_t subsection;		/* Current subsection index */
+    int32_t fileindex;
+    struct reloc *relocs;
+    struct rbtree *syms[2]; /* All/global symbols symbols in section */
+    int align;
+    bool by_name;	    /* This section was specified by full MachO name */
+    char namestr[34];	    /* segment,section as a C string */
+
+    /* data that goes into the file */
+    char sectname[16];     /* what this section is called */
+    char segname[16];      /* segment this section will be in */
+    uint64_t addr;         /* in-memory address (subject to alignment) */
+    uint64_t size;         /* in-memory and -file size  */
+    uint64_t offset;	   /* in-file offset */
+    uint32_t pad;          /* padding bytes before section */
+    uint32_t nreloc;       /* relocation entry count */
+    uint32_t flags;        /* type and attributes (masked) */
+    uint32_t extreloc;     /* external relocations */
+};
+
+#define S_NASM_TYPE_MASK	 0x800004ff	/* we consider these bits "section type" */
+
+/* fake section for absolute symbols, *not* part of the section linked list */
+static struct section absolute_sect;
+
+struct reloc {
+    /* nasm internal data */
+    struct reloc *next;
+
+    /* data that goes into the file */
+    int32_t addr;		/* op's offset in section */
+    uint32_t snum:24,		/* contains symbol index if
+				 ** ext otherwise in-file
+				 ** section number */
+	pcrel:1,                /* relative relocation */
+	length:2,               /* 0=byte, 1=word, 2=int32_t, 3=int64_t */
+	ext:1,                  /* external symbol referenced */
+	type:4;                 /* reloc type */
+};
+
+struct symbol {
+    /* nasm internal data */
+    struct rbtree symv[2];	/* All/global symbol rbtrees; "key" contains the
+				   symbol offset. */
+    struct symbol *next;	/* next symbol in the list */
+    char *name;			/* name of this symbol */
+    int32_t initial_snum;	/* symbol number used above in reloc */
+    int32_t snum;		/* true snum for reloc */
+
+    /* data that goes into the file */
+    uint32_t strx;              /* string table index */
+    uint8_t type;		/* symbol type */
+    uint8_t sect;		/* NO_SECT or section number */
+    uint16_t desc;		/* for stab debugging, 0 for us */
+};
+
+#define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
+
+static struct section *sects, **sectstail, **sectstab;
+static struct symbol *syms, **symstail;
+static uint32_t nsyms;
+
+/* These variables are set by macho_layout_symbols() to organize
+   the symbol table and string table in order the dynamic linker
+   expects.  They are then used in macho_write() to put out the
+   symbols and strings in that order.
+
+   The order of the symbol table is:
+     local symbols
+     defined external symbols (sorted by name)
+     undefined external symbols (sorted by name)
+
+   The order of the string table is:
+     strings for external symbols
+     strings for local symbols
+ */
+static uint32_t ilocalsym = 0;
+static uint32_t iextdefsym = 0;
+static uint32_t iundefsym = 0;
+static uint32_t nlocalsym;
+static uint32_t nextdefsym;
+static uint32_t nundefsym;
+static struct symbol **extdefsyms = NULL;
+static struct symbol **undefsyms = NULL;
+
+static struct RAA *extsyms;
+static struct SAA *strs;
+static uint32_t strslen;
+
+/* Global file information. This should be cleaned up into either
+   a structure or as function arguments.  */
+static uint32_t head_ncmds = 0;
+static uint32_t head_sizeofcmds = 0;
+static uint32_t head_flags = 0;
+static uint64_t seg_filesize = 0;
+static uint64_t seg_vmsize = 0;
+static uint32_t seg_nsects = 0;
+static uint64_t rel_padcnt = 0;
+
+/*
+ * Functions for handling fixed-length zero-padded string
+ * fields, that may or may not be null-terminated.
+ */
+
+/* Copy a string into a zero-padded fixed-length field */
+#define xstrncpy(xdst, xsrc) strncpy(xdst, xsrc, sizeof(xdst))
+
+/* Compare a fixed-length field with a string */
+#define xstrncmp(xdst, xsrc) strncmp(xdst, xsrc, sizeof(xdst))
+
+#define alignint32_t(x)							\
+    ALIGN(x, sizeof(int32_t))	/* align x to int32_t boundary */
+
+#define alignint64_t(x)							\
+    ALIGN(x, sizeof(int64_t))	/* align x to int64_t boundary */
+
+#define alignptr(x) \
+    ALIGN(x, fmt.ptrsize)	/* align x to output format width */
+
+static struct hash_table section_by_name;
+static struct RAA *section_by_index;
+
+static struct section * never_null
+find_or_add_section(const char *segname, const char *sectname)
+{
+    struct hash_insert hi;
+    void **sp;
+    struct section *s;
+    char sect[34];
+
+    snprintf(sect, sizeof sect, "%-16s,%-16s", segname, sectname);
+
+    sp = hash_find(&section_by_name, sect, &hi);
+    if (sp)
+	return (struct section *)(*sp);
+
+    s = nasm_zalloc(sizeof *s);
+    xstrncpy(s->segname, segname);
+    xstrncpy(s->sectname, sectname);
+    xstrncpy(s->namestr, sect);
+    hash_add(&hi, s->namestr, s);
+
+    s->index = s->subsection = seg_alloc();
+    section_by_index = raa_write_ptr(section_by_index, s->index >> 1, s);
+
+    return s;
+}
+
+static inline bool is_new_section(const struct section *s)
+{
+    return !s->data;
+}
+
+static struct section *get_section_by_name(const char *segname,
+                                           const char *sectname)
+{
+    char sect[34];
+    void **sp;
+
+    snprintf(sect, sizeof sect, "%-16s,%-16s", segname, sectname);
+
+    sp = hash_find(&section_by_name, sect, NULL);
+    return sp ? (struct section *)(*sp) : NULL;
+}
+
+static struct section *get_section_by_index(int32_t index)
+{
+    if (index < 0 || index >= SEG_ABS || (index & 1))
+	return NULL;
+
+    return raa_read_ptr(section_by_index, index >> 1);
+}
+
+struct dir_list {
+    struct dir_list *next;
+    struct dir_list *last;
+    const char *dir_name;
+    uint32_t dir;
+};
+
+struct file_list {
+    struct file_list *next;
+    struct file_list *last;
+    const char *file_name;
+    uint32_t file;
+    struct dir_list *dir;
+};
+
+struct dw_sect_list {
+    struct SAA *psaa;
+    int32_t section;
+    uint32_t line;
+    uint64_t offset;
+    uint32_t file;
+    struct dw_sect_list *next;
+    struct dw_sect_list *last;
+};
+
+struct section_info {
+    uint64_t size;
+    int32_t secto;
+};
+
+#define DW_LN_BASE (-5)
+#define DW_LN_RANGE 14
+#define DW_OPCODE_BASE 13
+#define DW_MAX_LN (DW_LN_BASE + DW_LN_RANGE)
+#define DW_MAX_SP_OPCODE 256
+
+static struct file_list *dw_head_file = 0, *dw_cur_file = 0, **dw_last_file_next = NULL;
+static struct dir_list *dw_head_dir = 0, **dw_last_dir_next = NULL;
+static struct dw_sect_list  *dw_head_sect = 0, *dw_cur_sect = 0, *dw_last_sect = 0;
+static uint32_t  cur_line = 0, dw_num_files = 0, dw_num_dirs = 0, dw_num_sects = 0;
+static bool  dbg_immcall = false;
+static const char *module_name = NULL;
+
+/*
+ * Special section numbers which are used to define Mach-O special
+ * symbols, which can be used with WRT to provide PIC relocation
+ * types.
+ */
+static int32_t macho_tlvp_sect;
+static int32_t macho_gotpcrel_sect;
+
+static void macho_init(void)
+{
+    module_name = inname;
+    sects = NULL;
+    sectstail = &sects;
+
+    /* Fake section for absolute symbols */
+    absolute_sect.index = NO_SEG;
+
+    syms = NULL;
+    symstail = &syms;
+    nsyms = 0;
+    nlocalsym = 0;
+    nextdefsym = 0;
+    nundefsym = 0;
+
+    extsyms = raa_init();
+    strs = saa_init(1L);
+
+    section_by_index = raa_init();
+
+    /* string table starts with a zero byte so index 0 is an empty string */
+    saa_wbytes(strs, zero_buffer, 1);
+    strslen = 1;
+
+    /* add special symbol for TLVP */
+    macho_tlvp_sect = seg_alloc() + 1;
+    backend_label("..tlvp", macho_tlvp_sect, 0L);
+}
+
+static void sect_write(struct section *sect,
+                       const uint8_t *data, uint32_t len)
+{
+    saa_wbytes(sect->data, data, len);
+    sect->size += len;
+}
+
+/*
+ * Find a suitable global symbol for a ..gotpcrel or ..tlvp reference
+ */
+static struct symbol *macho_find_sym(struct section *s, uint64_t offset,
+				     bool global, bool exact)
+{
+    struct rbtree *srb;
+
+    srb = rb_search(s->syms[global], offset);
+
+    if (!srb || (exact && srb->key != offset)) {
+        nasm_error(ERR_NONFATAL, "unable to find a suitable%s%s symbol"
+		   " for this reference",
+		   global ? " global" : "",
+		   s == &absolute_sect ? " absolute " : "");
+        return NULL;
+    }
+
+    return container_of(srb - global, struct symbol, symv);
+}
+
+static int64_t add_reloc(struct section *sect, int32_t section,
+			 int64_t offset,
+			 enum reltype reltype, int bytes)
+{
+    struct reloc *r;
+    struct section *s;
+    int32_t fi;
+    int64_t adjust;
+
+    /* Double check this is a valid relocation type for this platform */
+    nasm_assert(reltype <= fmt.maxreltype);
+
+    /* the current end of the section will be the symbol's address for
+     ** now, might have to be fixed by macho_fixup_relocs() later on. make
+     ** sure we don't make the symbol scattered by setting the highest
+     ** bit by accident */
+    r = nasm_malloc(sizeof(struct reloc));
+    r->addr = sect->size & ~R_SCATTERED;
+    r->ext = 1;
+    adjust = 0;
+
+    /* match byte count 1, 2, 4, 8 to length codes 0, 1, 2, 3 respectively */
+    r->length = ilog2_32(bytes);
+
+    /* set default relocation values */
+    r->type = fmt.reloc_abs;
+    r->pcrel = 0;
+    r->snum = R_ABS;
+
+    s = get_section_by_index(section);
+    fi = s ? s->fileindex : NO_SECT;
+
+    /* absolute relocation */
+    switch (reltype) {
+    case RL_ABS:
+	if (section == NO_SEG) {
+	    /* absolute (can this even happen?) */
+	    r->ext = 0;
+	} else if (fi == NO_SECT) {
+	    /* external */
+	    r->snum = raa_read(extsyms, section);
+	} else {
+	    /* local */
+	    r->ext = 0;
+	    r->snum = fi;
+	}
+	break;
+
+    case RL_REL:
+    case RL_BRANCH:
+	r->type = fmt.reloc_rel;
+	r->pcrel = 1;
+	if (section == NO_SEG) {
+	    /* may optionally be converted below by fmt.forcesym */
+	    r->ext = 0;
+	} else if (fi == NO_SECT) {
+	    /* external */
+	    sect->extreloc = 1;
+	    r->snum = raa_read(extsyms, section);
+	    if (reltype == RL_BRANCH)
+		r->type = X86_64_RELOC_BRANCH;
+	} else {
+	    /* local */
+	    r->ext = 0;
+	    r->snum = fi;
+	    if (reltype == RL_BRANCH)
+		r->type = X86_64_RELOC_BRANCH;
+	}
+	break;
+
+    case RL_SUB: /* obsolete */
+	nasm_warn(WARN_OTHER, "relcation with subtraction"
+		   "becomes to be obsolete");
+	r->ext = 0;
+	r->type = X86_64_RELOC_SUBTRACTOR;
+	break;
+
+    case RL_GOT:
+	r->type = X86_64_RELOC_GOT;
+	goto needsym;
+
+    case RL_GOTLOAD:
+	r->type = X86_64_RELOC_GOT_LOAD;
+	goto needsym;
+
+    case RL_TLV:
+	r->type = fmt.reloc_tlv;
+	goto needsym;
+
+    needsym:
+	r->pcrel = (fmt.ptrsize == 8 ? 1 : 0);
+	if (section == NO_SEG) {
+	    nasm_error(ERR_NONFATAL, "Unsupported use of use of WRT");
+	    goto bail;
+	} else if (fi == NO_SECT) {
+	    /* external */
+	    r->snum = raa_read(extsyms, section);
+	} else {
+	    /* internal - GOTPCREL doesn't need to be in global */
+	    struct symbol *sym = macho_find_sym(s, offset,
+						false, /* reltype != RL_TLV */
+						true);
+	    if (!sym) {
+		nasm_error(ERR_NONFATAL, "Symbol for WRT not found");
+		goto bail;
+	    }
+
+	    adjust -= sym->symv[0].key;
+	    r->snum = sym->initial_snum;
+	}
+	break;
+    }
+
+    /*
+     * For 64-bit Mach-O, force a symbol reference if at all possible
+     * Allow for r->snum == R_ABS by searching absolute_sect
+     */
+    if (!r->ext && fmt.forcesym) {
+	struct symbol *sym = macho_find_sym(s ? s : &absolute_sect,
+					    offset, false, false);
+	if (sym) {
+	    adjust -= sym->symv[0].key;
+	    r->snum = sym->initial_snum;
+	    r->ext = 1;
+	}
+    }
+
+    if (r->pcrel)
+	adjust += ((r->ext && fmt.ptrsize == 8) ? bytes : -(int64_t)sect->size);
+
+    /* NeXT as puts relocs in reversed order (address-wise) into the
+     ** files, so we do the same, doesn't seem to make much of a
+     ** difference either way */
+    r->next = sect->relocs;
+    sect->relocs = r;
+    if (r->ext)
+	sect->extreloc = 1;
+    ++sect->nreloc;
+
+    return adjust;
+
+ bail:
+    nasm_free(r);
+    return 0;
+}
+
+static void macho_output(int32_t secto, const void *data,
+			 enum out_type type, uint64_t size,
+                         int32_t section, int32_t wrt)
+{
+    struct section *s;
+    int64_t addr, offset;
+    uint8_t mydata[16], *p;
+    bool is_bss;
+    enum reltype reltype;
+
+    s = get_section_by_index(secto);
+    if (!s) {
+        nasm_warn(WARN_OTHER, "attempt to assemble code in"
+              " section %d: defaulting to `.text'", secto);
+        s = get_section_by_name("__TEXT", "__text");
+
+        /* should never happen */
+        if (!s)
+            nasm_panic("text section not found");
+    }
+
+    /* debug code generation only for sections tagged with
+     * instruction attribute */
+    if (s->flags & S_ATTR_SOME_INSTRUCTIONS)
+    {
+        struct section_info sinfo;
+        sinfo.size = s->size;
+        sinfo.secto = secto;
+        dfmt->debug_output(0, &sinfo);
+    }
+
+    is_bss = (s->flags & SECTION_TYPE) == S_ZEROFILL;
+
+    if (is_bss && type != OUT_RESERVE) {
+        nasm_warn(WARN_OTHER, "attempt to initialize memory in "
+              "BSS section: ignored");
+        /* FIXME */
+        nasm_warn(WARN_OTHER, "section size may be negative"
+            "with address symbols");
+        s->size += realsize(type, size);
+        return;
+    }
+
+    memset(mydata, 0, sizeof(mydata));
+
+    switch (type) {
+    case OUT_RESERVE:
+        if (!is_bss) {
+            nasm_warn(WARN_ZEROING, "uninitialized space declared in"
+		       " %s,%s section: zeroing", s->segname, s->sectname);
+
+            sect_write(s, NULL, size);
+        } else
+            s->size += size;
+
+        break;
+
+    case OUT_RAWDATA:
+        sect_write(s, data, size);
+        break;
+
+    case OUT_ADDRESS:
+    {
+	int asize = abs((int)size);
+
+        addr = *(int64_t *)data;
+        if (section != NO_SEG) {
+            if (section % 2) {
+                nasm_error(ERR_NONFATAL, "Mach-O format does not support"
+			   " section base references");
+            } else if (wrt == NO_SEG) {
+		if (fmt.ptrsize == 8 && asize != 8) {
+		    nasm_error(ERR_NONFATAL,
+			       "Mach-O 64-bit format does not support"
+			       " 32-bit absolute addresses");
+		} else {
+		    addr += add_reloc(s, section, addr, RL_ABS, asize);
+		}
+	    } else if (wrt == macho_tlvp_sect && fmt.ptrsize != 8 &&
+		       asize == (int) fmt.ptrsize) {
+		addr += add_reloc(s, section, addr, RL_TLV, asize);
+	    } else {
+		nasm_error(ERR_NONFATAL, "Mach-O format does not support"
+			   " this use of WRT");
+	    }
+	}
+
+        p = mydata;
+	WRITEADDR(p, addr, asize);
+        sect_write(s, mydata, asize);
+        break;
+    }
+
+    case OUT_REL1ADR:
+    case OUT_REL2ADR:
+
+        p = mydata;
+	offset = *(int64_t *)data;
+        addr = offset - size;
+
+        if (section != NO_SEG && section % 2) {
+            nasm_error(ERR_NONFATAL, "Mach-O format does not support"
+		       " section base references");
+	} else if (fmt.ptrsize == 8) {
+	    nasm_error(ERR_NONFATAL, "Unsupported non-32-bit"
+		       " Macho-O relocation [2]");
+	} else if (wrt != NO_SEG) {
+	    nasm_error(ERR_NONFATAL, "Mach-O format does not support"
+		       " this use of WRT");
+	    wrt = NO_SEG;	/* we can at least _try_ to continue */
+	} else {
+	    addr += add_reloc(s, section, addr+size, RL_REL,
+                              type == OUT_REL1ADR ? 1 : 2);
+	}
+
+        WRITESHORT(p, addr);
+        sect_write(s, mydata, type == OUT_REL1ADR ? 1 : 2);
+        break;
+
+    case OUT_REL4ADR:
+    case OUT_REL8ADR:
+
+        p = mydata;
+	offset = *(int64_t *)data;
+        addr = offset - size;
+	reltype = RL_REL;
+
+        if (section != NO_SEG && section % 2) {
+            nasm_error(ERR_NONFATAL, "Mach-O format does not support"
+		       " section base references");
+        } else if (wrt == NO_SEG) {
+	    if (fmt.ptrsize == 8 &&
+		(s->flags & S_ATTR_SOME_INSTRUCTIONS)) {
+		uint8_t opcode[2];
+
+		opcode[0] = opcode[1] = 0;
+
+		/* HACK: Retrieve instruction opcode */
+		if (likely(s->data->datalen >= 2)) {
+		    saa_fread(s->data, s->data->datalen-2, opcode, 2);
+		} else if (s->data->datalen == 1) {
+		    saa_fread(s->data, 0, opcode+1, 1);
+		}
+
+		if ((opcode[0] != 0x0f && (opcode[1] & 0xfe) == 0xe8) ||
+		    (opcode[0] == 0x0f && (opcode[1] & 0xf0) == 0x80)) {
+		    /* Direct call, jmp, or jcc */
+		    reltype = RL_BRANCH;
+		}
+	    }
+	} else if (wrt == macho_gotpcrel_sect) {
+	    reltype = RL_GOT;
+
+	    if ((s->flags & S_ATTR_SOME_INSTRUCTIONS) &&
+		s->data->datalen >= 3) {
+		uint8_t gotload[3];
+
+		/* HACK: Retrieve instruction opcode */
+		saa_fread(s->data, s->data->datalen-3, gotload, 3);
+		if ((gotload[0] & 0xf8) == 0x48 &&
+		    gotload[1] == 0x8b &&
+		    (gotload[2] & 0307) == 0005) {
+		    /* movq <reg>,[rel sym wrt ..gotpcrel] */
+		    reltype = RL_GOTLOAD;
+		}
+	    }
+	} else if (wrt == macho_tlvp_sect && fmt.ptrsize == 8) {
+	    reltype = RL_TLV;
+	} else {
+	    nasm_error(ERR_NONFATAL, "Mach-O format does not support"
+		       " this use of WRT");
+	    /* continue with RL_REL */
+	}
+
+	addr += add_reloc(s, section, offset, reltype,
+                          type == OUT_REL4ADR ? 4 : 8);
+        WRITELONG(p, addr);
+        sect_write(s, mydata, type == OUT_REL4ADR ? 4 : 8);
+        break;
+
+    default:
+        nasm_error(ERR_NONFATAL, "Unrepresentable relocation in Mach-O");
+        break;
+    }
+}
+
+#define S_CODE  (S_REGULAR | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS)
+#define NO_TYPE S_NASM_TYPE_MASK
+
+/* Translation table from traditional Unix section names to Mach-O */
+static const struct macho_known_section {
+    const char      *nasmsect;
+    const char      *segname;
+    const char      *sectname;
+    const uint32_t  flags;
+} known_sections[] = {
+    { ".text",          "__TEXT",   "__text",           S_CODE          },
+    { ".data",          "__DATA",   "__data",           S_REGULAR       },
+    { ".rodata",        "__DATA",   "__const",          S_REGULAR       },
+    { ".bss",           "__DATA",   "__bss",            S_ZEROFILL      },
+    { ".debug_abbrev",  "__DWARF",  "__debug_abbrev",   S_ATTR_DEBUG    },
+    { ".debug_info",    "__DWARF",  "__debug_info",     S_ATTR_DEBUG    },
+    { ".debug_line",    "__DWARF",  "__debug_line",     S_ATTR_DEBUG    },
+    { ".debug_str",     "__DWARF",  "__debug_str",      S_ATTR_DEBUG    },
+};
+
+/* Section type or attribute directives */
+static const struct macho_known_section_attr {
+    const char      *name;
+    uint32_t        flags;
+} sect_attribs[] = {
+    { "data",               S_REGULAR                               },
+    { "code",               S_CODE                                  },
+    { "mixed",              S_REGULAR | S_ATTR_SOME_INSTRUCTIONS    },
+    { "bss",                S_ZEROFILL                              },
+    { "zerofill",           S_ZEROFILL                              },
+    { "no_dead_strip",      NO_TYPE | S_ATTR_NO_DEAD_STRIP          },
+    { "live_support",       NO_TYPE | S_ATTR_LIVE_SUPPORT           },
+    { "strip_static_syms",  NO_TYPE | S_ATTR_STRIP_STATIC_SYMS      },
+    { "debug",              NO_TYPE | S_ATTR_DEBUG                  },
+    { NULL, 0 }
+};
+
+static const struct macho_known_section *
+lookup_known_section(const char *name, bool by_sectname)
+{
+    size_t i;
+
+    if (name && name[0]) {
+            for (i = 0; i < ARRAY_SIZE(known_sections); i++) {
+                const char *p = by_sectname ?
+                    known_sections[i].sectname :
+                    known_sections[i].nasmsect;
+                if (!strcmp(name, p))
+                    return &known_sections[i];
+            }
+    }
+
+    return NULL;
+}
+
+static int32_t macho_section(char *name, int *bits)
+{
+    const struct macho_known_section *known_section;
+    const struct macho_known_section_attr *sa;
+    char *sectionAttributes;
+    struct section *s;
+    const char *section, *segment;
+    uint32_t flags;
+    char *currentAttribute;
+    char *comma;
+
+    bool new_seg;
+
+    /* Default to the appropriate number of bits. */
+    if (!name) {
+        *bits = fmt.ptrsize << 3;
+        name = ".text";
+        sectionAttributes = NULL;
+    } else {
+        sectionAttributes = name;
+        name = nasm_strsep(&sectionAttributes, " \t");
+    }
+
+    section = segment = NULL;
+    flags = 0;
+
+    comma = strchr(name, ',');
+    if (comma) {
+	int len;
+
+	*comma = '\0';
+	segment = name;
+	section = comma+1;
+
+	len = strlen(segment);
+	if (len == 0) {
+	    nasm_error(ERR_NONFATAL, "empty segment name\n");
+	} else if (len > 16) {
+	    nasm_error(ERR_NONFATAL, "segment name %s too long\n", segment);
+	}
+
+	len = strlen(section);
+	if (len == 0) {
+	    nasm_error(ERR_NONFATAL, "empty section name\n");
+	} else if (len > 16) {
+	    nasm_error(ERR_NONFATAL, "section name %s too long\n", section);
+	}
+
+        known_section = lookup_known_section(section, true);
+        if (known_section)
+            flags = known_section->flags;
+        else
+            flags = S_REGULAR;
+    } else {
+        known_section = lookup_known_section(name, false);
+        if (!known_section) {
+            nasm_error(ERR_NONFATAL, "unknown section name %s\n", name);
+            return NO_SEG;
+        }
+
+        segment = known_section->segname;
+        section = known_section->sectname;
+        flags = known_section->flags;
+    }
+
+    /* try to find section with that name, or create it */
+    s = find_or_add_section(segment, section);
+    new_seg = is_new_section(s);
+
+    /* initialize it if it is a brand new section */
+    if (new_seg) {
+	*sectstail = s;
+	sectstail = &s->next;
+
+	s->data = saa_init(1L);
+	s->fileindex = ++seg_nsects;
+	s->align = -1;
+	s->pad = -1;
+	s->offset = -1;
+	s->by_name = false;
+
+	s->size = 0;
+	s->nreloc = 0;
+	s->flags = flags;
+    }
+
+    if (comma)
+	*comma = ',';		/* Restore comma */
+
+    s->by_name = s->by_name || comma; /* Was specified by name */
+
+    flags = NO_TYPE;
+
+    while (sectionAttributes &&
+	   (currentAttribute = nasm_strsep(&sectionAttributes, " \t"))) {
+	if (!*currentAttribute)
+	    continue;
+
+	if (!nasm_strnicmp("align=", currentAttribute, 6)) {
+	    char *end;
+	    int newAlignment, value;
+
+	    value = strtoul(currentAttribute + 6, (char**)&end, 0);
+	    newAlignment = alignlog2_32(value);
+
+	    if (0 != *end) {
+		nasm_error(ERR_NONFATAL,
+			   "unknown or missing alignment value \"%s\" "
+			   "specified for section \"%s\"",
+			   currentAttribute + 6,
+			   name);
+	    } else if (0 > newAlignment) {
+		nasm_error(ERR_NONFATAL,
+			   "alignment of %d (for section \"%s\") is not "
+			   "a power of two",
+			   value,
+			   name);
+	    }
+
+	    if (s->align < newAlignment)
+		s->align = newAlignment;
+	} else {
+	    for (sa = sect_attribs; sa->name; sa++) {
+		if (!nasm_stricmp(sa->name, currentAttribute)) {
+		    if ((sa->flags & S_NASM_TYPE_MASK) != NO_TYPE) {
+			flags = (flags & ~S_NASM_TYPE_MASK)
+			    | (sa->flags & S_NASM_TYPE_MASK);
+		    }
+		    flags |= sa->flags & ~S_NASM_TYPE_MASK;
+		    break;
+		}
+	    }
+
+	    if (!sa->name) {
+		nasm_error(ERR_NONFATAL,
+			   "unknown section attribute %s for section %s",
+			   currentAttribute, name);
+	    }
+	}
+    }
+
+    if ((flags & S_NASM_TYPE_MASK) != NO_TYPE) {
+	if (!new_seg && ((s->flags ^ flags) & S_NASM_TYPE_MASK)) {
+	    nasm_error(ERR_NONFATAL,
+		       "inconsistent section attributes for section %s\n",
+		       name);
+	} else {
+	    s->flags = (s->flags & ~S_NASM_TYPE_MASK) | flags;
+	}
+    } else {
+	s->flags |= flags & ~S_NASM_TYPE_MASK;
+    }
+
+    return s->subsection;
+}
+
+static int32_t macho_herelabel(const char *name, enum label_type type,
+			       int32_t section, int32_t *subsection,
+			       bool *copyoffset)
+{
+    struct section *s;
+    int32_t subsec;
+    (void)name;
+
+    if (!(head_flags & MH_SUBSECTIONS_VIA_SYMBOLS))
+	return section;
+
+    /* No subsection only for local labels */
+    if (type == LBL_LOCAL)
+	return section;
+
+    s = get_section_by_index(section);
+    if (!s)
+	return section;
+
+    subsec = *subsection;
+    if (subsec == NO_SEG) {
+	/* Allocate a new subsection index */
+	subsec = *subsection = seg_alloc();
+	section_by_index = raa_write_ptr(section_by_index, subsec >> 1, s);
+    }
+
+    s->subsection = subsec;
+    *copyoffset = true;		/* Maintain previous offset */
+    return subsec;
+}
+
+static void macho_symdef(char *name, int32_t section, int64_t offset,
+                         int is_global, char *special)
+{
+    struct symbol *sym;
+    struct section *s;
+    bool special_used = false;
+
+#if defined(DEBUG) && DEBUG>2
+    nasm_error(ERR_DEBUG,
+            " macho_symdef: %s, pass=%"PRId64" type %s, sec=%"PRIx32", off=%"PRIx64", is_global=%d, %s\n",
+	       name, pass_count(), pass_types[pass_type()],
+	       section, offset, is_global, special);
+#endif
+
+    if (is_global == 3) {
+        if (special) {
+            int n = strcspn(special, " \t");
+
+            if (!nasm_strnicmp(special, "private_extern", n)) {
+                for (sym = syms; sym != NULL; sym = sym->next) {
+                    if (!strcmp(name, sym->name)) {
+                        if (sym->type & N_PEXT)
+                            return; /* nothing to be done */
+                        else
+                            break;
+                    }
+                }
+            }
+        }
+        nasm_error(ERR_NONFATAL, "The Mach-O format does not "
+              "(yet) support forward reference fixups.");
+        return;
+    }
+
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+	/*
+	 * This is a NASM special symbol. We never allow it into
+	 * the Macho-O symbol table, even if it's a valid one. If it
+	 * _isn't_ a valid one, we should barf immediately.
+	 */
+	if (strcmp(name, "..gotpcrel") && strcmp(name, "..tlvp"))
+            nasm_error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
+	return;
+    }
+
+    sym = *symstail = nasm_zalloc(sizeof(struct symbol));
+    sym->next = NULL;
+    symstail = &sym->next;
+
+    sym->name = name;
+    sym->strx = strslen;
+    sym->type = 0;
+    sym->desc = 0;
+    sym->symv[0].key = offset;
+    sym->symv[1].key = offset;
+    sym->initial_snum = -1;
+
+    /* external and common symbols get N_EXT */
+    if (is_global != 0) {
+        sym->type |= N_EXT;
+    }
+    if (is_global == 1) {
+        /* check special to see if the global symbol shall be marked as private external: N_PEXT */
+        if (special) {
+            int n = strcspn(special, " \t");
+
+            if (!nasm_strnicmp(special, "private_extern", n))
+                sym->type |= N_PEXT;
+            else
+                nasm_error(ERR_NONFATAL, "unrecognised symbol type `%.*s'", n, special);
+        }
+        special_used = true;
+    }
+
+    /* track the initially allocated symbol number for use in future fix-ups */
+    sym->initial_snum = nsyms;
+
+    if (section == NO_SEG) {
+        /* symbols in no section get absolute */
+        sym->type |= N_ABS;
+        sym->sect = NO_SECT;
+
+	s = &absolute_sect;
+    } else {
+	s = get_section_by_index(section);
+
+        sym->type |= N_SECT;
+
+        /* get the in-file index of the section the symbol was defined in */
+        sym->sect = s ? s->fileindex : NO_SECT;
+
+        if (!s) {
+            /* remember symbol number of references to external
+             ** symbols, this works because every external symbol gets
+             ** its own section number allocated internally by nasm and
+             ** can so be used as a key */
+	    extsyms = raa_write(extsyms, section, nsyms);
+
+            switch (is_global) {
+            case 1:
+            case 2:
+                /* there isn't actually a difference between global
+                 ** and common symbols, both even have their size in
+                 ** sym->symv[0].key */
+                sym->type = N_EXT;
+                break;
+
+            default:
+                /* give an error on unfound section if it's not an
+                 ** external or common symbol (assemble_file() does a
+                 ** seg_alloc() on every call for them) */
+                nasm_panic("in-file index for section %d not found, is_global = %d", section, is_global);
+		break;
+            }
+	}
+    }
+
+    if (s) {
+	s->syms[0] = rb_insert(s->syms[0], &sym->symv[0]);
+	if (is_global)
+	    s->syms[1] = rb_insert(s->syms[1], &sym->symv[1]);
+    }
+
+    ++nsyms;
+
+    if (special && !special_used)
+        nasm_error(ERR_NONFATAL, "no special symbol features supported here");
+}
+
+static void macho_sectalign(int32_t seg, unsigned int value)
+{
+    struct section *s;
+    int align;
+
+    nasm_assert(!(seg & 1));
+
+    s = get_section_by_index(seg);
+
+    if (!s || !is_power2(value))
+        return;
+
+    align = alignlog2_32(value);
+    if (s->align < align)
+        s->align = align;
+}
+
+extern macros_t macho_stdmac[];
+
+/* Comparison function for qsort symbol layout.  */
+static int layout_compare (const struct symbol **s1,
+			   const struct symbol **s2)
+{
+    return (strcmp ((*s1)->name, (*s2)->name));
+}
+
+/* The native assembler does a few things in a similar function
+
+	* Remove temporary labels
+	* Sort symbols according to local, external, undefined (by name)
+	* Order the string table
+
+   We do not remove temporary labels right now.
+
+   numsyms is the total number of symbols we have. strtabsize is the
+   number entries in the string table.  */
+
+static void macho_layout_symbols (uint32_t *numsyms,
+				  uint32_t *strtabsize)
+{
+    struct symbol *sym, **symp;
+    uint32_t i,j;
+
+    *numsyms = 0;
+    *strtabsize = sizeof (char);
+
+    symp = &syms;
+
+    while ((sym = *symp)) {
+	/* Undefined symbols are now external.  */
+	if (sym->type == N_UNDF)
+	    sym->type |= N_EXT;
+
+	if ((sym->type & N_EXT) == 0) {
+	    sym->snum = *numsyms;
+	    *numsyms = *numsyms + 1;
+	    nlocalsym++;
+	}
+	else {
+	    if ((sym->type & N_TYPE) != N_UNDF) {
+		nextdefsym++;
+	    } else {
+		nundefsym++;
+	    }
+
+	    /* If we handle debug info we'll want
+	       to check for it here instead of just
+	       adding the symbol to the string table.  */
+	    sym->strx = *strtabsize;
+	    saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
+	    *strtabsize += strlen(sym->name) + 1;
+	}
+	symp = &(sym->next);
+    }
+
+    /* Next, sort the symbols.  Most of this code is a direct translation from
+       the Apple cctools symbol layout. We need to keep compatibility with that.  */
+    /* Set the indexes for symbol groups into the symbol table */
+    ilocalsym = 0;
+    iextdefsym = nlocalsym;
+    iundefsym = nlocalsym + nextdefsym;
+
+    /* allocate arrays for sorting externals by name */
+    extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
+    undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
+
+    i = 0;
+    j = 0;
+
+    symp = &syms;
+
+    while ((sym = *symp)) {
+
+	if((sym->type & N_EXT) == 0) {
+	    sym->strx = *strtabsize;
+	    saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
+	    *strtabsize += strlen(sym->name) + 1;
+	}
+	else {
+	    if ((sym->type & N_TYPE) != N_UNDF) {
+		extdefsyms[i++] = sym;
+	    } else {
+		undefsyms[j++] = sym;
+	    }
+	}
+	symp = &(sym->next);
+    }
+
+    qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
+	  (int (*)(const void *, const void *))layout_compare);
+    qsort(undefsyms, nundefsym, sizeof(struct symbol *),
+	  (int (*)(const void *, const void *))layout_compare);
+
+    for(i = 0; i < nextdefsym; i++) {
+	extdefsyms[i]->snum = *numsyms;
+	*numsyms += 1;
+    }
+    for(j = 0; j < nundefsym; j++) {
+	undefsyms[j]->snum = *numsyms;
+	*numsyms += 1;
+    }
+}
+
+/* Calculate some values we'll need for writing later.  */
+
+static void macho_calculate_sizes (void)
+{
+    struct section *s;
+    int fi;
+
+    /* count sections and calculate in-memory and in-file offsets */
+    for (s = sects; s != NULL; s = s->next) {
+        uint64_t newaddr;
+
+        /* recalculate segment address based on alignment and vm size */
+        s->addr = seg_vmsize;
+
+        /* we need section alignment to calculate final section address */
+        if (s->align == -1)
+            s->align = DEFAULT_SECTION_ALIGNMENT;
+
+        newaddr = ALIGN(s->addr, UINT64_C(1) << s->align);
+        s->addr = newaddr;
+
+        seg_vmsize = newaddr + s->size;
+
+        /* zerofill sections aren't actually written to the file */
+        if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
+	    /*
+	     * LLVM/Xcode as always aligns the section data to 4
+	     * bytes; there is a comment in the LLVM source code that
+	     * perhaps aligning to pointer size would be better.
+	     */
+	    s->pad = ALIGN(seg_filesize, 4) - seg_filesize;
+	    s->offset = seg_filesize + s->pad;
+            seg_filesize += s->size + s->pad;
+
+            /* filesize and vmsize needs to be aligned */
+            seg_vmsize += s->pad;
+	}
+    }
+
+    /* calculate size of all headers, load commands and sections to
+    ** get a pointer to the start of all the raw data */
+    if (seg_nsects > 0) {
+        ++head_ncmds;
+        head_sizeofcmds += fmt.segcmd_size  + seg_nsects * fmt.sectcmd_size;
+    }
+
+    if (nsyms > 0) {
+	++head_ncmds;
+	head_sizeofcmds += MACHO_SYMCMD_SIZE;
+    }
+
+    if (seg_nsects > MAX_SECT) {
+	nasm_fatal("MachO output is limited to %d sections\n",
+		   MAX_SECT);
+    }
+
+    /* Create a table of sections by file index to avoid linear search */
+    sectstab = nasm_malloc((seg_nsects + 1) * sizeof(*sectstab));
+    sectstab[NO_SECT] = &absolute_sect;
+    for (s = sects, fi = 1; s != NULL; s = s->next, fi++)
+	sectstab[fi] = s;
+}
+
+/* Write out the header information for the file.  */
+
+static void macho_write_header (void)
+{
+    fwriteint32_t(fmt.mh_magic, ofile);	/* magic */
+    fwriteint32_t(fmt.cpu_type, ofile);	/* CPU type */
+    fwriteint32_t(CPU_SUBTYPE_I386_ALL, ofile);	/* CPU subtype */
+    fwriteint32_t(MH_OBJECT, ofile);	/* Mach-O file type */
+    fwriteint32_t(head_ncmds, ofile);	/* number of load commands */
+    fwriteint32_t(head_sizeofcmds, ofile);	/* size of load commands */
+    fwriteint32_t(head_flags, ofile);		/* flags, if any */
+    fwritezero(fmt.header_size - 7*4, ofile);	/* reserved fields */
+}
+
+/* Write out the segment load command at offset.  */
+
+static uint32_t macho_write_segment (uint64_t offset)
+{
+    uint64_t rel_base = alignptr(offset + seg_filesize);
+    uint32_t s_reloff = 0;
+    struct section *s;
+
+    fwriteint32_t(fmt.lc_segment, ofile);        /* cmd == LC_SEGMENT_64 */
+
+    /* size of load command including section load commands */
+    fwriteint32_t(fmt.segcmd_size + seg_nsects * fmt.sectcmd_size,
+		  ofile);
+
+    /* in an MH_OBJECT file all sections are in one unnamed (name
+    ** all zeros) segment */
+    fwritezero(16, ofile);
+    fwriteptr(0, ofile);		     /* in-memory offset */
+    fwriteptr(seg_vmsize, ofile);	     /* in-memory size */
+    fwriteptr(offset, ofile);	             /* in-file offset to data */
+    fwriteptr(seg_filesize, ofile);	     /* in-file size */
+    fwriteint32_t(VM_PROT_DEFAULT, ofile);   /* maximum vm protection */
+    fwriteint32_t(VM_PROT_DEFAULT, ofile);   /* initial vm protection */
+    fwriteint32_t(seg_nsects, ofile);        /* number of sections */
+    fwriteint32_t(0, ofile);		     /* no flags */
+
+    /* emit section headers */
+    for (s = sects; s != NULL; s = s->next) {
+	if (s->nreloc) {
+	    nasm_assert((s->flags & SECTION_TYPE) != S_ZEROFILL);
+	    s->flags |= S_ATTR_LOC_RELOC;
+	    if (s->extreloc)
+		s->flags |= S_ATTR_EXT_RELOC;
+	} else if (!xstrncmp(s->segname, "__DATA") &&
+		   !xstrncmp(s->sectname, "__const") &&
+		   !s->by_name &&
+		   !get_section_by_name("__TEXT", "__const")) {
+	    /*
+	     * The MachO equivalent to .rodata can be either
+	     * __DATA,__const or __TEXT,__const; the latter only if
+	     * there are no relocations.  However, when mixed it is
+	     * better to specify the segments explicitly.
+	     */
+	    xstrncpy(s->segname, "__TEXT");
+	}
+
+        nasm_write(s->sectname, sizeof(s->sectname), ofile);
+        nasm_write(s->segname, sizeof(s->segname), ofile);
+        fwriteptr(s->addr, ofile);
+        fwriteptr(s->size, ofile);
+
+        /* dummy data for zerofill sections or proper values */
+        if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
+	    nasm_assert(s->pad != (uint32_t)-1);
+	    offset += s->pad;
+            fwriteint32_t(offset, ofile);
+	    offset += s->size;
+            /* Write out section alignment, as a power of two.
+            e.g. 32-bit word alignment would be 2 (2^2 = 4).  */
+            fwriteint32_t(s->align, ofile);
+            /* To be compatible with cctools as we emit
+            a zero reloff if we have no relocations.  */
+            fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, ofile);
+            fwriteint32_t(s->nreloc, ofile);
+
+            s_reloff += s->nreloc * MACHO_RELINFO_SIZE;
+        } else {
+            fwriteint32_t(0, ofile);
+            fwriteint32_t(s->align, ofile);
+            fwriteint32_t(0, ofile);
+            fwriteint32_t(0, ofile);
+        }
+
+        fwriteint32_t(s->flags, ofile);      /* flags */
+        fwriteint32_t(0, ofile);	     /* reserved */
+        fwriteptr(0, ofile);		     /* reserved */
+    }
+
+    rel_padcnt = rel_base - offset;
+    offset = rel_base + s_reloff;
+
+    return offset;
+}
+
+/* For a given chain of relocs r, write out the entire relocation
+   chain to the object file.  */
+
+static void macho_write_relocs (struct reloc *r)
+{
+    while (r) {
+	uint32_t word2;
+
+	fwriteint32_t(r->addr, ofile); /* reloc offset */
+
+	word2 = r->snum;
+	word2 |= r->pcrel << 24;
+	word2 |= r->length << 25;
+	word2 |= r->ext << 27;
+	word2 |= r->type << 28;
+	fwriteint32_t(word2, ofile); /* reloc data */
+	r = r->next;
+    }
+}
+
+/* Write out the section data.  */
+static void macho_write_section (void)
+{
+    struct section *s;
+    struct reloc *r;
+    uint8_t *p;
+    int32_t len;
+    int64_t l;
+    union offset {
+	uint64_t val;
+	uint8_t buf[8];
+    } blk;
+
+    for (s = sects; s != NULL; s = s->next) {
+	if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
+	    continue;
+
+	/* Like a.out Mach-O references things in the data or bss
+	 * sections by addresses which are actually relative to the
+	 * start of the _text_ section, in the _file_. See outaout.c
+	 * for more information. */
+	saa_rewind(s->data);
+	for (r = s->relocs; r != NULL; r = r->next) {
+	    len = (uint32_t)1 << r->length;
+	    if (len > 4)	/* Can this ever be an issue?! */
+		len = 8;
+	    blk.val = 0;
+	    saa_fread(s->data, r->addr, blk.buf, len);
+
+	    /* get offset based on relocation type */
+#ifdef WORDS_LITTLEENDIAN
+	    l = blk.val;
+#else
+	    l  = blk.buf[0];
+	    l += ((int64_t)blk.buf[1]) << 8;
+	    l += ((int64_t)blk.buf[2]) << 16;
+	    l += ((int64_t)blk.buf[3]) << 24;
+	    l += ((int64_t)blk.buf[4]) << 32;
+	    l += ((int64_t)blk.buf[5]) << 40;
+	    l += ((int64_t)blk.buf[6]) << 48;
+	    l += ((int64_t)blk.buf[7]) << 56;
+#endif
+
+	    /* If the relocation is internal add to the current section
+	       offset. Otherwise the only value we need is the symbol
+	       offset which we already have. The linker takes care
+	       of the rest of the address.  */
+	    if (!r->ext) {
+		/* generate final address by section address and offset */
+		nasm_assert(r->snum <= seg_nsects);
+		l += sectstab[r->snum]->addr;
+		if (r->pcrel)
+		    l -= s->addr;
+	    } else if (r->pcrel && r->type == GENERIC_RELOC_VANILLA) {
+		l -= s->addr;
+	    }
+
+	    /* write new offset back */
+	    p = blk.buf;
+	    WRITEDLONG(p, l);
+	    saa_fwrite(s->data, r->addr, blk.buf, len);
+	}
+
+	/* dump the section data to file */
+	fwritezero(s->pad, ofile);
+	saa_fpwrite(s->data, ofile);
+    }
+
+    /* pad last section up to reloc entries on pointer boundary */
+    fwritezero(rel_padcnt, ofile);
+
+    /* emit relocation entries */
+    for (s = sects; s != NULL; s = s->next)
+	macho_write_relocs (s->relocs);
+}
+
+/* Write out the symbol table. We should already have sorted this
+   before now.  */
+static void macho_write_symtab (void)
+{
+    struct symbol *sym;
+    uint64_t i;
+
+    /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
+
+    for (sym = syms; sym != NULL; sym = sym->next) {
+	if ((sym->type & N_EXT) == 0) {
+	    fwriteint32_t(sym->strx, ofile);		/* string table entry number */
+	    nasm_write(&sym->type, 1, ofile);		/* symbol type */
+	    nasm_write(&sym->sect, 1, ofile);		/* section */
+	    fwriteint16_t(sym->desc, ofile);		/* description */
+
+	    /* Fix up the symbol value now that we know the final section
+	       sizes.  */
+	    if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
+		nasm_assert(sym->sect <= seg_nsects);
+		sym->symv[0].key += sectstab[sym->sect]->addr;
+	    }
+
+	    fwriteptr(sym->symv[0].key, ofile);	/* value (i.e. offset) */
+	}
+    }
+
+    for (i = 0; i < nextdefsym; i++) {
+	sym = extdefsyms[i];
+	fwriteint32_t(sym->strx, ofile);
+	nasm_write(&sym->type, 1, ofile);	/* symbol type */
+	nasm_write(&sym->sect, 1, ofile);	/* section */
+	fwriteint16_t(sym->desc, ofile);	/* description */
+
+	/* Fix up the symbol value now that we know the final section
+	   sizes.  */
+	if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
+	    nasm_assert(sym->sect <= seg_nsects);
+	    sym->symv[0].key += sectstab[sym->sect]->addr;
+	}
+
+	fwriteptr(sym->symv[0].key, ofile); /* value (i.e. offset) */
+    }
+
+     for (i = 0; i < nundefsym; i++) {
+	 sym = undefsyms[i];
+	 fwriteint32_t(sym->strx, ofile);
+	 nasm_write(&sym->type, 1, ofile);	/* symbol type */
+	 nasm_write(&sym->sect, 1, ofile);	/* section */
+	 fwriteint16_t(sym->desc, ofile);	/* description */
+
+	/* Fix up the symbol value now that we know the final section
+	   sizes.  */
+	 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
+	    nasm_assert(sym->sect <= seg_nsects);
+	    sym->symv[0].key += sectstab[sym->sect]->addr;
+	 }
+
+	 fwriteptr(sym->symv[0].key, ofile); /* value (i.e. offset) */
+     }
+
+}
+
+/* Fixup the snum in the relocation entries, we should be
+   doing this only for externally referenced symbols. */
+static void macho_fixup_relocs (struct reloc *r)
+{
+    struct symbol *sym;
+
+    while (r != NULL) {
+	if (r->ext) {
+	    for (sym = syms; sym != NULL; sym = sym->next) {
+		if (sym->initial_snum == r->snum) {
+		    r->snum = sym->snum;
+		    break;
+		}
+	    }
+	}
+	r = r->next;
+    }
+}
+
+/* Write out the object file.  */
+
+static void macho_write (void)
+{
+    uint64_t offset = 0;
+
+    /* mach-o object file structure:
+    **
+    ** mach header
+    **  uint32_t magic
+    **  int   cpu type
+    **  int   cpu subtype
+    **  uint32_t mach file type
+    **  uint32_t number of load commands
+    **  uint32_t size of all load commands
+    **   (includes section struct size of segment command)
+    **  uint32_t flags
+    **
+    ** segment command
+    **  uint32_t command type == LC_SEGMENT[_64]
+    **  uint32_t size of load command
+    **   (including section load commands)
+    **  char[16] segment name
+    **  pointer  in-memory offset
+    **  pointer  in-memory size
+    **  pointer  in-file offset to data area
+    **  pointer  in-file size
+    **   (in-memory size excluding zerofill sections)
+    **  int   maximum vm protection
+    **  int   initial vm protection
+    **  uint32_t number of sections
+    **  uint32_t flags
+    **
+    ** section commands
+    **   char[16] section name
+    **   char[16] segment name
+    **   pointer  in-memory offset
+    **   pointer  in-memory size
+    **   uint32_t in-file offset
+    **   uint32_t alignment
+    **    (irrelevant in MH_OBJECT)
+    **   uint32_t in-file offset of relocation entries
+    **   uint32_t number of relocations
+    **   uint32_t flags
+    **   uint32_t reserved
+    **   uint32_t reserved
+    **
+    ** symbol table command
+    **  uint32_t command type == LC_SYMTAB
+    **  uint32_t size of load command
+    **  uint32_t symbol table offset
+    **  uint32_t number of symbol table entries
+    **  uint32_t string table offset
+    **  uint32_t string table size
+    **
+    ** raw section data
+    **
+    ** padding to pointer boundary
+    **
+    ** relocation data (struct reloc)
+    ** int32_t offset
+    **  uint data (symbolnum, pcrel, length, extern, type)
+    **
+    ** symbol table data (struct nlist)
+    **  int32_t  string table entry number
+    **  uint8_t type
+    **   (extern, absolute, defined in section)
+    **  uint8_t section
+    **   (0 for global symbols, section number of definition (>= 1, <=
+    **   254) for local symbols, size of variable for common symbols
+    **   [type == extern])
+    **  int16_t description
+    **   (for stab debugging format)
+    **  pointer value (i.e. file offset) of symbol or stab offset
+    **
+    ** string table data
+    **  list of null-terminated strings
+    */
+
+    /* Emit the Mach-O header.  */
+    macho_write_header();
+
+    offset = fmt.header_size + head_sizeofcmds;
+
+    /* emit the segment load command */
+    if (seg_nsects > 0)
+	offset = macho_write_segment (offset);
+    else
+        nasm_warn(WARN_OTHER, "no sections?");
+
+    if (nsyms > 0) {
+        /* write out symbol command */
+        fwriteint32_t(LC_SYMTAB, ofile); /* cmd == LC_SYMTAB */
+        fwriteint32_t(MACHO_SYMCMD_SIZE, ofile); /* size of load command */
+        fwriteint32_t(offset, ofile);    /* symbol table offset */
+        fwriteint32_t(nsyms, ofile);     /* number of symbol
+                                         ** table entries */
+        offset += nsyms * fmt.nlist_size;
+        fwriteint32_t(offset, ofile);    /* string table offset */
+        fwriteint32_t(strslen, ofile);   /* string table size */
+    }
+
+    /* emit section data */
+    if (seg_nsects > 0)
+	macho_write_section ();
+
+    /* emit symbol table if we have symbols */
+    if (nsyms > 0)
+	macho_write_symtab ();
+
+    /* we don't need to pad here, we are already aligned */
+
+    /* emit string table */
+    saa_fpwrite(strs, ofile);
+}
+/* We do quite a bit here, starting with finalizing all of the data
+   for the object file, writing, and then freeing all of the data from
+   the file.  */
+
+static void macho_cleanup(void)
+{
+    struct section *s;
+    struct reloc *r;
+    struct symbol *sym;
+
+    dfmt->cleanup();
+
+    /* Sort all symbols.  */
+    macho_layout_symbols (&nsyms, &strslen);
+
+    /* Fixup relocation entries */
+    for (s = sects; s != NULL; s = s->next) {
+	macho_fixup_relocs (s->relocs);
+    }
+
+    /* First calculate and finalize needed values.  */
+    macho_calculate_sizes();
+    macho_write();
+
+    /* free up everything */
+    while (sects->next) {
+        s = sects;
+        sects = sects->next;
+
+        saa_free(s->data);
+        while (s->relocs != NULL) {
+            r = s->relocs;
+            s->relocs = s->relocs->next;
+            nasm_free(r);
+        }
+
+        nasm_free(s);
+    }
+
+    saa_free(strs);
+
+    raa_free(extsyms);
+
+    while (syms) {
+       sym = syms;
+       syms = syms->next;
+       nasm_free (sym);
+    }
+
+    nasm_free(extdefsyms);
+    nasm_free(undefsyms);
+    nasm_free(sectstab);
+    raa_free(section_by_index);
+    hash_free(&section_by_name);
+}
+
+static bool macho_set_section_attribute_by_symbol(const char *label, uint32_t flags)
+{
+    struct section *s;
+    int32_t nasm_seg;
+    int64_t offset;
+
+    if (lookup_label(label, &nasm_seg, &offset) == LBL_none) {
+	nasm_error(ERR_NONFATAL, "unknown symbol `%s' in no_dead_strip", label);
+	return false;
+    }
+
+    s = get_section_by_index(nasm_seg);
+    if (!s) {
+	nasm_error(ERR_NONFATAL, "symbol `%s' is external or absolute", label);
+	return false;
+    }
+
+    s->flags |= flags;
+    return true;
+}
+
+/*
+ * Mark a symbol for no dead stripping
+ */
+static enum directive_result macho_no_dead_strip(const char *labels)
+{
+    char *s, *p, *ep;
+    char ec;
+    enum directive_result rv = DIRR_ERROR;
+
+    p = s = nasm_strdup(labels);
+    while (*p) {
+	ep = nasm_skip_identifier(p);
+	if (!ep) {
+	    nasm_error(ERR_NONFATAL, "invalid symbol in NO_DEAD_STRIP");
+	    goto err;
+	}
+	ec = *ep;
+	if (ec && ec != ',' && !nasm_isspace(ec)) {
+	    nasm_error(ERR_NONFATAL, "cannot parse contents after symbol");
+	    goto err;
+	}
+	*ep = '\0';
+	if (!pass_first()) {
+	    if (!macho_set_section_attribute_by_symbol(p, S_ATTR_NO_DEAD_STRIP))
+		rv = DIRR_ERROR;
+	}
+	*ep = ec;
+	p = nasm_skip_spaces(ep);
+	if (*p == ',')
+	    p = nasm_skip_spaces(++p);
+    }
+
+    rv = DIRR_OK;
+
+err:
+    nasm_free(s);
+    return rv;
+}
+
+/*
+ * Mach-O pragmas
+ */
+static enum directive_result
+macho_pragma(const struct pragma *pragma)
+{
+    switch (pragma->opcode) {
+    case D_SUBSECTIONS_VIA_SYMBOLS:
+	if (*pragma->tail)
+	    return DIRR_BADPARAM;
+
+	if (!pass_first())
+	    head_flags |= MH_SUBSECTIONS_VIA_SYMBOLS;
+
+        /* Jmp-match optimization conflicts */
+        optimizing.flag |= OPTIM_DISABLE_JMP_MATCH;
+
+	return DIRR_OK;
+
+    case D_NO_DEAD_STRIP:
+	return macho_no_dead_strip(pragma->tail);
+
+    default:
+	return DIRR_UNKNOWN;	/* Not a Mach-O directive */
+    }
+}
+
+static const struct pragma_facility macho_pragma_list[] = {
+    { "macho", macho_pragma },
+    { NULL, macho_pragma }	/* Implements macho32/macho64 namespaces */
+};
+
+static void macho_dbg_generate(void)
+{
+    uint8_t *p_buf = NULL, *p_buf_base = NULL;
+    size_t saa_len = 0, high_addr = 0, total_len = 0;
+    struct section *p_section = NULL;
+    /* calculated at debug_str and referenced at debug_info */
+    uint32_t producer_str_offset = 0, module_str_offset = 0, dir_str_offset = 0;
+
+    /* debug section defines */
+    {
+        int bits = 0;
+        macho_section(".debug_abbrev", &bits);
+        macho_section(".debug_info", &bits);
+        macho_section(".debug_line", &bits);
+        macho_section(".debug_str", &bits);
+    }
+
+    /* dw section walk to find high_addr and total_len */
+    {
+        struct dw_sect_list *p_sect;
+
+        list_for_each(p_sect, dw_head_sect) {
+            uint64_t offset = get_section_by_index(p_sect->section)->size;
+            struct SAA *p_linep = p_sect->psaa;
+
+            saa_write8(p_linep, 2); /* std op 2 */
+            saa_write8(p_linep, offset - p_sect->offset);
+            saa_write8(p_linep, DW_LNS_extended_op);
+            saa_write8(p_linep, 1); /* operand length */
+            saa_write8(p_linep, DW_LNE_end_sequence);
+
+            total_len += p_linep->datalen;
+            high_addr += offset;
+        }
+    }
+
+    /* debug line */
+    {
+        struct dw_sect_list *p_sect;
+        size_t linep_off, buf_size;
+        struct SAA *p_lines = saa_init(1L);
+        struct dir_list *p_dir;
+        struct file_list *p_file;
+
+        p_section = get_section_by_name("__DWARF", "__debug_line");
+        nasm_assert(p_section != NULL);
+
+        saa_write8(p_lines, 1); /* minimum instruction length */
+        saa_write8(p_lines, 1); /* initial value of "is_stmt" */
+        saa_write8(p_lines, DW_LN_BASE); /* line base */
+        saa_write8(p_lines, DW_LN_RANGE); /* line range */
+        saa_write8(p_lines, DW_OPCODE_BASE); /* opcode base */
+        saa_write8(p_lines, 0); /* std opcode 1 length */
+        saa_write8(p_lines, 1); /* std opcode 2 length */
+        saa_write8(p_lines, 1); /* std opcode 3 length */
+        saa_write8(p_lines, 1); /* std opcode 4 length */
+        saa_write8(p_lines, 1); /* std opcode 5 length */
+        saa_write8(p_lines, 0); /* std opcode 6 length */
+        saa_write8(p_lines, 0); /* std opcode 7 length */
+        saa_write8(p_lines, 0); /* std opcode 8 length */
+        saa_write8(p_lines, 1); /* std opcode 9 length */
+        saa_write8(p_lines, 0); /* std opcode 10 length */
+        saa_write8(p_lines, 0); /* std opcode 11 length */
+        saa_write8(p_lines, 1); /* std opcode 12 length */
+        list_for_each(p_dir, dw_head_dir) {
+            saa_wcstring(p_lines, p_dir->dir_name);
+        }
+        saa_write8(p_lines, 0); /* end of table */
+
+        list_for_each(p_file, dw_head_file) {
+            saa_wcstring(p_lines, p_file->file_name);
+            saa_write8(p_lines, p_file->dir->dir); /* directory id */
+            saa_write8(p_lines, 0); /* time */
+            saa_write8(p_lines, 0); /* size */
+        }
+        saa_write8(p_lines, 0); /* end of table */
+
+        linep_off = p_lines->datalen;
+        /* 10 bytes for initial & prolong length, and dwarf version info */
+        buf_size = saa_len = linep_off + total_len + 10;
+        p_buf_base = p_buf = nasm_malloc(buf_size);
+
+        WRITELONG(p_buf, saa_len - 4); /* initial length; size excluding itself */
+        WRITESHORT(p_buf, 2); /* dwarf version */
+        WRITELONG(p_buf, linep_off); /* prolong length */
+
+        saa_rnbytes(p_lines, p_buf, linep_off);
+        p_buf += linep_off;
+        saa_free(p_lines);
+
+        list_for_each(p_sect, dw_head_sect) {
+            struct SAA *p_linep = p_sect->psaa;
+
+            saa_len = p_linep->datalen;
+            saa_rnbytes(p_linep, p_buf, saa_len);
+            p_buf += saa_len;
+
+            saa_free(p_linep);
+        }
+
+        macho_output(p_section->index, p_buf_base, OUT_RAWDATA, buf_size, NO_SEG, 0);
+
+        nasm_free(p_buf_base);
+    }
+
+    /* string section */
+    {
+        struct SAA *p_str = saa_init(1L);
+        char *cur_path = nasm_realpath(module_name);
+        char *cur_file = nasm_basename(cur_path);
+        char *cur_dir = nasm_dirname(cur_path);
+
+        p_section = get_section_by_name("__DWARF", "__debug_str");
+        nasm_assert(p_section != NULL);
+
+        producer_str_offset = 0;
+        module_str_offset = dir_str_offset = saa_wcstring(p_str, nasm_signature());
+        dir_str_offset += saa_wcstring(p_str, cur_file);
+        saa_wcstring(p_str, cur_dir);
+
+        saa_len = p_str->datalen;
+        p_buf = nasm_malloc(saa_len);
+        saa_rnbytes(p_str, p_buf, saa_len);
+        macho_output(p_section->index, p_buf, OUT_RAWDATA, saa_len, NO_SEG, 0);
+
+        nasm_free(cur_path);
+        nasm_free(cur_file);
+        nasm_free(cur_dir);
+        saa_free(p_str);
+        nasm_free(p_buf);
+    }
+
+    /* debug info */
+    {
+        struct SAA *p_info = saa_init(1L);
+
+        p_section = get_section_by_name("__DWARF", "__debug_info");
+        nasm_assert(p_section != NULL);
+
+        /* size will be overwritten once determined, so skip in p_info layout */
+        saa_write16(p_info, 2); /* dwarf version */
+        saa_write32(p_info, 0); /* offset info abbrev */
+        saa_write8(p_info, (ofmt == &of_macho64) ? 8 : 4);   /* pointer size  */
+
+        saa_write8(p_info, 1);   /* abbrev entry number  */
+
+        saa_write32(p_info, producer_str_offset); /* offset from string table for DW_AT_producer  */
+        saa_write16(p_info, DW_LANG_Mips_Assembler); /* DW_AT_language  */
+        saa_write32(p_info, module_str_offset); /* offset from string table for DW_AT_name  */
+        saa_write32(p_info, dir_str_offset); /* offset from string table for DW_AT_comp_dir */
+        saa_write32(p_info, 0); /* DW_AT_stmt_list  */
+
+        if (ofmt == &of_macho64) {
+            saa_write64(p_info, 0); /* DW_AT_low_pc */
+            saa_write64(p_info, high_addr); /* DW_AT_high_pc */
+        } else  {
+            saa_write32(p_info, 0); /* DW_AT_low_pc */
+            saa_write32(p_info, high_addr); /* DW_AT_high_pc */
+        }
+
+        saa_write8(p_info, 2);   /* abbrev entry number */
+
+        if (ofmt == &of_macho64) {
+            saa_write64(p_info, 0); /* DW_AT_low_pc */
+            saa_write64(p_info, 0); /* DW_AT_frame_base */
+        } else  {
+            saa_write32(p_info, 0); /* DW_AT_low_pc */
+            saa_write32(p_info, 0); /* DW_AT_frame_base */
+        }
+        saa_write8(p_info, DW_END_default);
+
+        saa_len = p_info->datalen;
+        p_buf_base = p_buf = nasm_malloc(saa_len + 4); /* 4B for size info */
+
+        WRITELONG(p_buf, saa_len);
+        saa_rnbytes(p_info, p_buf, saa_len);
+        macho_output(p_section->index, p_buf_base, OUT_RAWDATA, saa_len + 4, NO_SEG, 0);
+
+        saa_free(p_info);
+        nasm_free(p_buf_base);
+    }
+
+    /* abbrev section */
+    {
+        struct SAA *p_abbrev = saa_init(1L);
+
+        p_section = get_section_by_name("__DWARF", "__debug_abbrev");
+        nasm_assert(p_section != NULL);
+
+        saa_write8(p_abbrev, 1); /* entry number */
+
+        saa_write8(p_abbrev, DW_TAG_compile_unit);
+        saa_write8(p_abbrev, DW_CHILDREN_yes);
+
+        saa_write8(p_abbrev, DW_AT_producer);
+        saa_write8(p_abbrev, DW_FORM_strp);
+
+        saa_write8(p_abbrev, DW_AT_language);
+        saa_write8(p_abbrev, DW_FORM_data2);
+
+        saa_write8(p_abbrev, DW_AT_name);
+        saa_write8(p_abbrev, DW_FORM_strp);
+
+        saa_write8(p_abbrev, DW_AT_comp_dir);
+        saa_write8(p_abbrev, DW_FORM_strp);
+
+        saa_write8(p_abbrev, DW_AT_stmt_list);
+        saa_write8(p_abbrev, DW_FORM_data4);
+
+        saa_write8(p_abbrev, DW_AT_low_pc);
+        saa_write8(p_abbrev, DW_FORM_addr);
+
+        saa_write8(p_abbrev, DW_AT_high_pc);
+        saa_write8(p_abbrev, DW_FORM_addr);
+
+        saa_write16(p_abbrev, DW_END_default);
+
+        saa_write8(p_abbrev, 2); /* entry number */
+
+        saa_write8(p_abbrev, DW_TAG_subprogram);
+        saa_write8(p_abbrev, DW_CHILDREN_no);
+
+        saa_write8(p_abbrev, DW_AT_low_pc);
+        saa_write8(p_abbrev, DW_FORM_addr);
+
+        saa_write8(p_abbrev, DW_AT_frame_base);
+        saa_write8(p_abbrev, DW_FORM_addr);
+
+        saa_write16(p_abbrev, DW_END_default);
+
+	saa_write8(p_abbrev, 0); /* Terminal zero entry */
+
+        saa_len = p_abbrev->datalen;
+
+        p_buf = nasm_malloc(saa_len);
+
+        saa_rnbytes(p_abbrev, p_buf, saa_len);
+        macho_output(p_section->index, p_buf, OUT_RAWDATA, saa_len, NO_SEG, 0);
+
+        saa_free(p_abbrev);
+        nasm_free(p_buf);
+    }
+}
+
+static void new_file_list (const char *file_name, const char *dir_name)
+{
+    struct dir_list *dir_list;
+    bool need_new_dir_list = true;
+
+    nasm_new(dw_cur_file);
+    dw_cur_file->file = ++dw_num_files;
+    dw_cur_file->file_name = file_name;
+    if(!dw_head_file) {
+        dw_head_file = dw_cur_file;
+    } else {
+        *dw_last_file_next = dw_cur_file;
+    }
+    dw_last_file_next = &(dw_cur_file->next);
+
+    if(dw_head_dir) {
+        list_for_each(dir_list, dw_head_dir) {
+            if(!(strcmp(dir_name, dir_list->dir_name))) {
+                dw_cur_file->dir = dir_list;
+                need_new_dir_list = false;
+                break;
+            }
+        }
+    }
+
+    if(need_new_dir_list)
+    {
+        nasm_new(dir_list);
+        dir_list->dir = dw_num_dirs++;
+        dir_list->dir_name = dir_name;
+        if(!dw_head_dir) {
+            dw_head_dir = dir_list;
+        } else {
+            *dw_last_dir_next = dir_list;
+        }
+        dw_last_dir_next = &(dir_list->next);
+        dw_cur_file->dir = dir_list;
+    }
+}
+
+static void macho_dbg_init(void)
+{
+}
+
+static void macho_dbg_linenum(const char *file_name, int32_t line_num, int32_t segto)
+{
+    bool need_new_list = true;
+    const char *cur_file = nasm_basename(file_name);
+    const char *cur_dir  = nasm_dirname(file_name);
+    (void)segto;
+
+    if(!dw_cur_file || strcmp(cur_file, dw_cur_file->file_name) ||
+        strcmp(cur_dir, dw_cur_file->dir->dir_name)) {
+        if(dw_head_file) {
+            struct file_list *match;
+
+            list_for_each(match, dw_head_file) {
+                if(!(strcmp(cur_file, match->file_name)) &&
+                    !(strcmp(cur_dir, match->dir->dir_name))) {
+                    dw_cur_file = match;
+                    dw_cur_file->dir = match->dir;
+                    need_new_list = false;
+                    break;
+                }
+            }
+        }
+
+        if (need_new_list)
+            new_file_list(cur_file, cur_dir);
+    }
+
+    if (!need_new_list) {
+            nasm_free((void *)cur_file);
+            nasm_free((void *)cur_dir);
+    }
+
+    dbg_immcall = true;
+    cur_line = line_num;
+}
+
+static void macho_dbg_output(int type, void *param)
+{
+    struct section_info *sinfo_param = (struct section_info *)param;
+    int32_t secto = sinfo_param->secto;
+    bool need_new_sect = false;
+    struct SAA *p_linep = NULL;
+    (void)type;
+
+    if(!(dw_cur_sect && (dw_cur_sect->section == secto))) {
+        need_new_sect = true;
+        if(dw_head_sect) {
+            struct dw_sect_list *match = dw_head_sect;
+            uint32_t idx = 0;
+
+            for(; idx < dw_num_sects; idx++) {
+                if(match->section == secto) {
+                    dw_cur_sect = match;
+                    need_new_sect = false;
+                    break;
+                }
+                match = match->next;
+            }
+        }
+    }
+
+    if(need_new_sect) {
+        nasm_new(dw_cur_sect);
+        dw_num_sects ++;
+        p_linep = dw_cur_sect->psaa = saa_init(1L);
+        dw_cur_sect->line = dw_cur_sect->file = 1;
+        dw_cur_sect->offset = 0;
+        dw_cur_sect->next = NULL;
+        dw_cur_sect->section = secto;
+
+        saa_write8(p_linep, DW_LNS_extended_op);
+        saa_write8(p_linep, (ofmt == &of_macho64) ? 9 : 5);
+        saa_write8(p_linep, DW_LNE_set_address);
+        if (ofmt == &of_macho64) {
+            saa_write64(p_linep, 0);
+        } else {
+            saa_write32(p_linep, 0);
+        }
+
+        if(!dw_head_sect) {
+            dw_head_sect = dw_last_sect = dw_cur_sect;
+        } else {
+            dw_last_sect->next = dw_cur_sect;
+            dw_last_sect = dw_cur_sect;
+        }
+    }
+
+    if(dbg_immcall == true) {
+        int32_t line_delta = cur_line - dw_cur_sect->line;
+        int32_t offset_delta = sinfo_param->size - dw_cur_sect->offset;
+        uint32_t cur_file = dw_cur_file->file;
+        p_linep = dw_cur_sect->psaa;
+
+        if(cur_file != dw_cur_sect->file) {
+            saa_write8(p_linep, DW_LNS_set_file);
+            saa_write8(p_linep, cur_file);
+            dw_cur_sect->file = cur_file;
+        }
+
+        if(line_delta) {
+            int special_opcode = (line_delta - DW_LN_BASE) + (DW_LN_RANGE * offset_delta) +
+                                             DW_OPCODE_BASE;
+
+            if((line_delta >= DW_LN_BASE) && (line_delta < DW_MAX_LN) &&
+                (special_opcode < DW_MAX_SP_OPCODE)) {
+                saa_write8(p_linep, special_opcode);
+            } else {
+                saa_write8(p_linep, DW_LNS_advance_line);
+                saa_wleb128s(p_linep, line_delta);
+                if(offset_delta) {
+                    saa_write8(p_linep, DW_LNS_advance_pc);
+                    saa_wleb128u(p_linep, offset_delta);
+                }
+                saa_write8(p_linep, DW_LNS_copy);
+            }
+
+            dw_cur_sect->line = cur_line;
+            dw_cur_sect->offset = sinfo_param->size;
+        }
+
+        dbg_immcall = false;
+    }
+}
+
+static void macho_dbg_cleanup(void)
+{
+    /* dwarf sectors generation */
+    macho_dbg_generate();
+
+    {
+        struct dw_sect_list *p_sect = dw_head_sect;
+        struct file_list *p_file = dw_head_file;
+        uint32_t idx = 0;
+
+        for(; idx < dw_num_sects; idx++) {
+            struct dw_sect_list *next = p_sect->next;
+            nasm_free(p_sect);
+            p_sect = next;
+        }
+
+        for(idx = 0; idx < dw_num_files; idx++) {
+            struct file_list *next = p_file->next;
+            nasm_free(p_file);
+            p_file = next;
+        }
+    }
+}
+
+#ifdef OF_MACHO32
+static const struct macho_fmt macho32_fmt = {
+    4,
+    MH_MAGIC,
+    CPU_TYPE_I386,
+    LC_SEGMENT,
+    MACHO_HEADER_SIZE,
+    MACHO_SEGCMD_SIZE,
+    MACHO_SECTCMD_SIZE,
+    MACHO_NLIST_SIZE,
+    RL_MAX_32,
+    GENERIC_RELOC_VANILLA,
+    GENERIC_RELOC_VANILLA,
+    GENERIC_RELOC_TLV,
+    false			/* Allow segment-relative relocations */
+};
+
+static void macho32_init(void)
+{
+    fmt = macho32_fmt;
+    macho_init();
+
+    macho_gotpcrel_sect = NO_SEG;
+}
+
+static const struct dfmt macho32_df_dwarf = {
+    "Mach-O i386 dwarf for Darwin/MacOS",
+    "dwarf",
+    macho_dbg_init,
+    macho_dbg_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    null_debug_typevalue,
+    macho_dbg_output,
+    macho_dbg_cleanup,
+    NULL /*pragma list*/
+};
+
+static const struct dfmt * const macho32_df_arr[2] =
+ { &macho32_df_dwarf, NULL };
+
+const struct ofmt of_macho32 = {
+    "Mach-O i386 (Mach, including MacOS X and variants)",
+    "macho32",
+    ".o",
+    0,
+    32,
+    macho32_df_arr,
+    &macho32_df_dwarf,
+    macho_stdmac,
+    macho32_init,
+    null_reset,
+    nasm_do_legacy_output,
+    macho_output,
+    macho_symdef,
+    macho_section,
+    macho_herelabel,
+    macho_sectalign,
+    null_segbase,
+    null_directive,
+    macho_cleanup,
+    macho_pragma_list
+};
+#endif
+
+#ifdef OF_MACHO64
+static const struct macho_fmt macho64_fmt = {
+    8,
+    MH_MAGIC_64,
+    CPU_TYPE_X86_64,
+    LC_SEGMENT_64,
+    MACHO_HEADER64_SIZE,
+    MACHO_SEGCMD64_SIZE,
+    MACHO_SECTCMD64_SIZE,
+    MACHO_NLIST64_SIZE,
+    RL_MAX_64,
+    X86_64_RELOC_UNSIGNED,
+    X86_64_RELOC_SIGNED,
+    X86_64_RELOC_TLV,
+    true			/* Force symbol-relative relocations */
+};
+
+static void macho64_init(void)
+{
+    fmt = macho64_fmt;
+    macho_init();
+
+    /* add special symbol for ..gotpcrel */
+    macho_gotpcrel_sect = seg_alloc() + 1;
+    backend_label("..gotpcrel", macho_gotpcrel_sect, 0L);
+}
+
+static const struct dfmt macho64_df_dwarf = {
+    "Mach-O x86-64 dwarf for Darwin/MacOS",
+    "dwarf",
+    macho_dbg_init,
+    macho_dbg_linenum,
+    null_debug_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    null_debug_typevalue,
+    macho_dbg_output,
+    macho_dbg_cleanup,
+    NULL /*pragma list*/
+};
+
+static const struct dfmt * const macho64_df_arr[2] =
+ { &macho64_df_dwarf, NULL };
+
+const struct ofmt of_macho64 = {
+    "Mach-O x86-64 (Mach, including MacOS X and variants)",
+    "macho64",
+    ".o",
+    0,
+    64,
+    macho64_df_arr,
+    &macho64_df_dwarf,
+    macho_stdmac,
+    macho64_init,
+    null_reset,
+    nasm_do_legacy_output,
+    macho_output,
+    macho_symdef,
+    macho_section,
+    macho_herelabel,
+    macho_sectalign,
+    null_segbase,
+    null_directive,
+    macho_cleanup,
+    macho_pragma_list,
+};
+#endif
+
+#endif
+
+/*
+ * Local Variables:
+ * mode:c
+ * c-basic-offset:4
+ * End:
+ *
+ * end of file */
diff --git a/vere/ext/nasm/output/outmacho.mac b/vere/ext/nasm/output/outmacho.mac
new file mode 100644
index 0000000..001bb3a
--- /dev/null
+++ b/vere/ext/nasm/output/outmacho.mac
@@ -0,0 +1,49 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: macho macho32 macho64
+%define __?SECT?__ [section .text]
+%macro __?NASM_CDecl?__ 1
+%endmacro
+
+; This directive sets the MH_SUBSECTIONS_VIA_SYMBOLS header flag
+%imacro subsections_via_symbols 0.nolist
+    %pragma __?OUTPUT_FORMAT?__ %?
+%endmacro
+
+%imacro no_dead_strip 1-*.nolist
+    %rep %0
+        %pragma __?OUTPUT_FORMAT?__ %? %1
+        %rotate 1
+    %endrep
+%endmacro
diff --git a/vere/ext/nasm/output/outobj.c b/vere/ext/nasm/output/outobj.c
new file mode 100644
index 0000000..281839d
--- /dev/null
+++ b/vere/ext/nasm/output/outobj.c
@@ -0,0 +1,2701 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outobj.c	output routines for the Netwide Assembler to produce
+ *		.OBJ object files
+ */
+
+#include "compiler.h"
+
+#include <ctype.h>              /* For toupper() */
+#include "nctype.h"
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "stdscan.h"
+#include "eval.h"
+#include "ver.h"
+
+#include "outform.h"
+#include "outlib.h"
+
+#ifdef OF_OBJ
+
+/*
+ * outobj.c is divided into two sections.  The first section is low level
+ * routines for creating obj records;  It has nearly zero NASM specific
+ * code.  The second section is high level routines for processing calls and
+ * data structures from the rest of NASM into obj format.
+ *
+ * It should be easy (though not zero work) to lift the first section out for
+ * use as an obj file writer for some other assembler or compiler.
+ */
+
+/*
+ * These routines are built around the ObjRecord data structure.  An ObjRecord
+ * holds an object file record that may be under construction or complete.
+ *
+ * A major function of these routines is to support continuation of an obj
+ * record into the next record when the maximum record size is exceeded.  The
+ * high level code does not need to worry about where the record breaks occur.
+ * It does need to do some minor extra steps to make the automatic continuation
+ * work.  Those steps may be skipped for records where the high level knows no
+ * continuation could be required.
+ *
+ * 1) An ObjRecord is allocated and cleared by obj_new, or an existing ObjRecord
+ *    is cleared by obj_clear.
+ *
+ * 2) The caller should fill in .type.
+ *
+ * 3) If the record is continuable and there is processing that must be done at
+ *    the start of each record then the caller should fill in .ori with the
+ *    address of the record initializer routine.
+ *
+ * 4) If the record is continuable and it should be saved (rather than emitted
+ *    immediately) as each record is done, the caller should set .up to be a
+ *    pointer to a location in which the caller keeps the master pointer to the
+ *    ObjRecord.  When the record is continued, the obj_bump routine will then
+ *    allocate a new ObjRecord structure and update the master pointer.
+ *
+ * 5) If the .ori field was used then the caller should fill in the .parm with
+ *    any data required by the initializer.
+ *
+ * 6) The caller uses the routines: obj_byte, obj_word, obj_rword, obj_dword,
+ *    obj_x, obj_index, obj_value and obj_name to fill in the various kinds of
+ *    data required for this record.
+ *
+ * 7) If the record is continuable, the caller should call obj_commit at each
+ *    point where breaking the record is permitted.
+ *
+ * 8) To write out the record, the caller should call obj_emit2.  If the
+ *    caller has called obj_commit for all data written then he can get slightly
+ *    faster code by calling obj_emit instead of obj_emit2.
+ *
+ * Most of these routines return an ObjRecord pointer.  This will be the input
+ * pointer most of the time and will be the new location if the ObjRecord
+ * moved as a result of the call.  The caller may ignore the return value in
+ * three cases:  It is a "Never Reallocates" routine;  or  The caller knows
+ * continuation is not possible;  or  The caller uses the master pointer for the
+ * next operation.
+ */
+
+#define RECORD_MAX (1024-3)     /* maximal size of any record except type+reclen */
+#define OBJ_PARMS  3            /* maximum .parm used by any .ori routine */
+
+#define FIX_08_LOW      0x8000  /* location type for various fixup subrecords */
+#define FIX_16_OFFSET   0x8400
+#define FIX_16_SELECTOR 0x8800
+#define FIX_32_POINTER  0x8C00
+#define FIX_08_HIGH     0x9000
+#define FIX_32_OFFSET   0xA400
+#define FIX_48_POINTER  0xAC00
+
+enum RecordID {                 /* record ID codes */
+
+    THEADR = 0x80,              /* module header */
+    COMENT = 0x88,              /* comment record */
+
+    LINNUM = 0x94,              /* line number record */
+    LNAMES = 0x96,              /* list of names */
+
+    SEGDEF = 0x98,              /* segment definition */
+    GRPDEF = 0x9A,              /* group definition */
+    EXTDEF = 0x8C,              /* external definition */
+    PUBDEF = 0x90,              /* public definition */
+    COMDEF = 0xB0,              /* common definition */
+
+    LEDATA = 0xA0,              /* logical enumerated data */
+    FIXUPP = 0x9C,              /* fixups (relocations) */
+    FIXU32 = 0x9D,              /* 32-bit fixups (relocations) */
+
+    MODEND = 0x8A,              /* module end */
+    MODE32 = 0x8B               /* module end for 32-bit objects */
+};
+
+enum ComentID {                 /* ID codes for comment records */
+    dTRANSL   = 0x0000,         /* translator comment */
+    dOMFEXT   = 0xC0A0,         /* "OMF extension" */
+    dEXTENDED = 0xC0A1,         /* translator-specific extensions */
+    dLINKPASS = 0x40A2,         /* link pass 2 marker */
+    dTYPEDEF  = 0xC0E3,         /* define a type */
+    dSYM      = 0xC0E6,         /* symbol debug record */
+    dFILNAME  = 0xC0E8,         /* file name record */
+    dDEPFILE  = 0xC0E9,         /* dependency file */
+    dCOMPDEF  = 0xC0EA          /* compiler type info */
+};
+
+typedef struct ObjRecord ObjRecord;
+typedef void ORI(ObjRecord * orp);
+
+struct ObjRecord {
+    ORI *ori;                   /* Initialization routine           */
+    int used;                   /* Current data size                */
+    int committed;              /* Data size at last boundary       */
+    int x_size;                 /* (see obj_x)                      */
+    unsigned int type;          /* Record type                      */
+    ObjRecord *child;           /* Associated record below this one */
+    ObjRecord **up;             /* Master pointer to this ObjRecord */
+    ObjRecord *back;            /* Previous part of this record     */
+    uint32_t parm[OBJ_PARMS];      /* Parameters for ori routine       */
+    uint8_t buf[RECORD_MAX + 3];
+};
+
+static void obj_fwrite(ObjRecord * orp);
+static void ori_ledata(ObjRecord * orp);
+static void ori_pubdef(ObjRecord * orp);
+static void ori_null(ObjRecord * orp);
+static ObjRecord *obj_commit(ObjRecord * orp);
+
+static bool obj_uppercase;       /* Flag: all names in uppercase */
+static bool obj_use32;           /* Flag: at least one segment is 32-bit */
+static bool obj_nodepend;        /* Flag: don't emit file dependencies */
+
+/*
+ * Clear an ObjRecord structure.  (Never reallocates).
+ * To simplify reuse of ObjRecord's, .type, .ori and .parm are not cleared.
+ */
+static ObjRecord *obj_clear(ObjRecord * orp)
+{
+    orp->used = 0;
+    orp->committed = 0;
+    orp->x_size = 0;
+    orp->child = NULL;
+    orp->up = NULL;
+    orp->back = NULL;
+    return (orp);
+}
+
+/*
+ * Emit an ObjRecord structure.  (Never reallocates).
+ * The record is written out proceeded (recursively) by its previous part (if
+ * any) and followed (recursively) by its child (if any).
+ * The previous part and the child are freed.  The main ObjRecord is cleared,
+ * not freed.
+ */
+static ObjRecord *obj_emit(ObjRecord * orp)
+{
+    if (orp->back) {
+        obj_emit(orp->back);
+        nasm_free(orp->back);
+    }
+
+    if (orp->committed)
+        obj_fwrite(orp);
+
+    if (orp->child) {
+        obj_emit(orp->child);
+        nasm_free(orp->child);
+    }
+
+    return (obj_clear(orp));
+}
+
+/*
+ * Commit and Emit a record.  (Never reallocates).
+ */
+static ObjRecord *obj_emit2(ObjRecord * orp)
+{
+    obj_commit(orp);
+    return (obj_emit(orp));
+}
+
+/*
+ * Allocate and clear a new ObjRecord;  Also sets .ori to ori_null
+ */
+static ObjRecord *obj_new(void)
+{
+    ObjRecord *orp;
+
+    orp = obj_clear(nasm_malloc(sizeof(ObjRecord)));
+    orp->ori = ori_null;
+    return (orp);
+}
+
+/*
+ * Advance to the next record because the existing one is full or its x_size
+ * is incompatible.
+ * Any uncommitted data is moved into the next record.
+ */
+static ObjRecord *obj_bump(ObjRecord * orp)
+{
+    ObjRecord *nxt;
+    int used = orp->used;
+    int committed = orp->committed;
+
+    if (orp->up) {
+        *orp->up = nxt = obj_new();
+        nxt->ori = orp->ori;
+        nxt->type = orp->type;
+        nxt->up = orp->up;
+        nxt->back = orp;
+        memcpy(nxt->parm, orp->parm, sizeof(orp->parm));
+    } else
+        nxt = obj_emit(orp);
+
+    used -= committed;
+    if (used) {
+        nxt->committed = 1;
+        nxt->ori(nxt);
+        nxt->committed = nxt->used;
+        memcpy(nxt->buf + nxt->committed, orp->buf + committed, used);
+        nxt->used = nxt->committed + used;
+    }
+
+    return (nxt);
+}
+
+/*
+ * Advance to the next record if necessary to allow the next field to fit.
+ */
+static ObjRecord *obj_check(ObjRecord * orp, int size)
+{
+    if (orp->used + size > RECORD_MAX)
+        orp = obj_bump(orp);
+
+    if (!orp->committed) {
+        orp->committed = 1;
+        orp->ori(orp);
+        orp->committed = orp->used;
+    }
+
+    return (orp);
+}
+
+/*
+ * All data written so far is committed to the current record (won't be moved to
+ * the next record in case of continuation).
+ */
+static ObjRecord *obj_commit(ObjRecord * orp)
+{
+    orp->committed = orp->used;
+    return (orp);
+}
+
+/*
+ * Write a byte
+ */
+static ObjRecord *obj_byte(ObjRecord * orp, uint8_t val)
+{
+    orp = obj_check(orp, 1);
+    orp->buf[orp->used] = val;
+    orp->used++;
+    return (orp);
+}
+
+/*
+ * Write a word
+ */
+static ObjRecord *obj_word(ObjRecord * orp, unsigned int val)
+{
+    orp = obj_check(orp, 2);
+    orp->buf[orp->used] = val;
+    orp->buf[orp->used + 1] = val >> 8;
+    orp->used += 2;
+    return (orp);
+}
+
+/*
+ * Write a reversed word
+ */
+static ObjRecord *obj_rword(ObjRecord * orp, unsigned int val)
+{
+    orp = obj_check(orp, 2);
+    orp->buf[orp->used] = val >> 8;
+    orp->buf[orp->used + 1] = val;
+    orp->used += 2;
+    return (orp);
+}
+
+/*
+ * Write a dword
+ */
+static ObjRecord *obj_dword(ObjRecord * orp, uint32_t val)
+{
+    orp = obj_check(orp, 4);
+    orp->buf[orp->used] = val;
+    orp->buf[orp->used + 1] = val >> 8;
+    orp->buf[orp->used + 2] = val >> 16;
+    orp->buf[orp->used + 3] = val >> 24;
+    orp->used += 4;
+    return (orp);
+}
+
+/*
+ * All fields of "size x" in one obj record must be the same size (either 16
+ * bits or 32 bits).  There is a one bit flag in each record which specifies
+ * which.
+ * This routine is used to force the current record to have the desired
+ * x_size.  x_size is normally automatic (using obj_x), so that this
+ * routine should be used outside obj_x, only to provide compatibility with
+ * linkers that have bugs in their processing of the size bit.
+ */
+
+static ObjRecord *obj_force(ObjRecord * orp, int x)
+{
+    if (orp->x_size == (x ^ 48))
+        orp = obj_bump(orp);
+    orp->x_size = x;
+    return (orp);
+}
+
+/*
+ * This routine writes a field of size x.  The caller does not need to worry at
+ * all about whether 16-bits or 32-bits are required.
+ */
+static ObjRecord *obj_x(ObjRecord * orp, uint32_t val)
+{
+    if (orp->type & 1)
+        orp->x_size = 32;
+    if (val > 0xFFFF)
+        orp = obj_force(orp, 32);
+    if (orp->x_size == 32) {
+	ObjRecord *nxt = obj_dword(orp, val);
+	nxt->x_size = 32;	/* x_size is cleared when a record overflows */
+	return nxt;
+    }
+    orp->x_size = 16;
+    return (obj_word(orp, val));
+}
+
+/*
+ * Writes an index
+ */
+static ObjRecord *obj_index(ObjRecord * orp, unsigned int val)
+{
+    if (val < 128)
+        return (obj_byte(orp, val));
+    return (obj_word(orp, (val >> 8) | (val << 8) | 0x80));
+}
+
+/*
+ * Writes a variable length value
+ */
+static ObjRecord *obj_value(ObjRecord * orp, uint32_t val)
+{
+    if (val <= 128)
+        return (obj_byte(orp, val));
+    if (val <= 0xFFFF) {
+        orp = obj_byte(orp, 129);
+        return (obj_word(orp, val));
+    }
+    if (val <= 0xFFFFFF)
+        return (obj_dword(orp, (val << 8) + 132));
+    orp = obj_byte(orp, 136);
+    return (obj_dword(orp, val));
+}
+
+/*
+ * Writes a counted string
+ */
+static ObjRecord *obj_name(ObjRecord * orp, const char *name)
+{
+    int len = strlen(name);
+    uint8_t *ptr;
+
+    if (len > UINT8_MAX) {
+        nasm_warn(WARN_OTHER, "truncating object name `%.64s...' to %u bytes",
+                  name, UINT8_MAX);
+        len = UINT8_MAX;
+    }
+
+    orp = obj_check(orp, len + 1);
+    ptr = orp->buf + orp->used;
+    *ptr++ = len;
+    orp->used += len + 1;
+    if (obj_uppercase)
+        while (--len >= 0) {
+            *ptr++ = toupper(*name);
+            name++;
+    } else
+        memcpy(ptr, name, len);
+    return (orp);
+}
+
+/*
+ * Initializer for an LEDATA record.
+ * parm[0] = offset
+ * parm[1] = segment index
+ * During the use of a LEDATA ObjRecord, parm[0] is constantly updated to
+ * represent the offset that would be required if the record were split at the
+ * last commit point.
+ * parm[2] is a copy of parm[0] as it was when the current record was initted.
+ */
+static void ori_ledata(ObjRecord * orp)
+{
+    obj_index(orp, orp->parm[1]);
+    orp->parm[2] = orp->parm[0];
+    obj_x(orp, orp->parm[0]);
+}
+
+/*
+ * Initializer for a PUBDEF record.
+ * parm[0] = group index
+ * parm[1] = segment index
+ * parm[2] = frame (only used when both indexes are zero)
+ */
+static void ori_pubdef(ObjRecord * orp)
+{
+    obj_index(orp, orp->parm[0]);
+    obj_index(orp, orp->parm[1]);
+    if (!(orp->parm[0] | orp->parm[1]))
+        obj_word(orp, orp->parm[2]);
+}
+
+/*
+ * Initializer for a LINNUM record.
+ * parm[0] = group index
+ * parm[1] = segment index
+ */
+static void ori_linnum(ObjRecord * orp)
+{
+    obj_index(orp, orp->parm[0]);
+    obj_index(orp, orp->parm[1]);
+}
+
+/*
+ * Initializer for a local vars record.
+ */
+static void ori_local(ObjRecord * orp)
+{
+    obj_rword(orp, dSYM);
+}
+
+/*
+ * Null initializer for records that continue without any header info
+ */
+static void ori_null(ObjRecord * orp)
+{
+    (void)orp;                  /* Do nothing */
+}
+
+/*
+ * This concludes the low level section of outobj.c
+ */
+
+static char obj_infile[FILENAME_MAX];
+
+static int32_t first_seg;
+static bool any_segs;
+static int passtwo;
+static int arrindex;
+
+#define GROUP_MAX 256           /* we won't _realistically_ have more
+                                 * than this many segs in a group */
+#define EXT_BLKSIZ 256          /* block size for externals list */
+
+struct Segment;                 /* need to know these structs exist */
+struct Group;
+
+struct LineNumber {
+    struct LineNumber *next;
+    struct Segment *segment;
+    int32_t offset;
+    int32_t lineno;
+};
+
+static struct FileName {
+    struct FileName *next;
+    char *name;
+    struct LineNumber *lnhead, **lntail;
+    int index;
+} *fnhead, **fntail;
+
+static struct Array {
+    struct Array *next;
+    unsigned size;
+    int basetype;
+} *arrhead, **arrtail;
+
+#define ARRAYBOT 31             /* magic number  for first array index */
+
+static struct Public {
+    struct Public *next;
+    char *name;
+    int32_t offset;
+    int32_t segment;               /* only if it's far-absolute */
+    int type;                   /* only for local debug syms */
+} *fpubhead, **fpubtail, *last_defined;
+
+static struct External {
+    struct External *next;
+    char *name;
+    int32_t commonsize;
+    int32_t commonelem;            /* element size if FAR, else zero */
+    int index;                  /* OBJ-file external index */
+    enum {
+        DEFWRT_NONE,            /* no unusual default-WRT */
+        DEFWRT_STRING,          /* a string we don't yet understand */
+        DEFWRT_SEGMENT,         /* a segment */
+        DEFWRT_GROUP            /* a group */
+    } defwrt_type;
+    union {
+        char *string;
+        struct Segment *seg;
+        struct Group *grp;
+    } defwrt_ptr;
+    struct External *next_dws;  /* next with DEFWRT_STRING */
+} *exthead, **exttail, *dws;
+
+static int externals;
+
+static struct ExtBack {
+    struct ExtBack *next;
+    struct External *exts[EXT_BLKSIZ];
+} *ebhead, **ebtail;
+
+static struct Segment {
+    struct Segment *next;
+    char *name;
+    int32_t index;                 /* the NASM segment id */
+    int32_t obj_index;             /* the OBJ-file segment index */
+    struct Group *grp;          /* the group it beint32_ts to */
+    uint32_t currentpos;
+    int32_t align;                 /* can be SEG_ABS + absolute addr */
+    int64_t pass_last_seen;
+    struct Public *pubhead, **pubtail, *lochead, **loctail;
+    char *segclass, *overlay;   /* `class' is a C++ keyword :-) */
+    ObjRecord *orp;
+    enum {
+        CMB_PRIVATE = 0,
+        CMB_PUBLIC = 2,
+        CMB_STACK = 5,
+        CMB_COMMON = 6
+    } combine;
+    bool use32;                 /* is this segment 32-bit? */
+} *seghead, **segtail, *obj_seg_needs_update;
+
+static struct Group {
+    struct Group *next;
+    char *name;
+    int32_t index;                 /* NASM segment id */
+    int32_t obj_index;             /* OBJ-file group index */
+    int32_t nentries;              /* number of elements... */
+    int32_t nindices;              /* ...and number of index elts... */
+    union {
+        int32_t index;
+        char *name;
+    } segs[GROUP_MAX];          /* ...in this */
+} *grphead, **grptail, *obj_grp_needs_update;
+
+static struct ImpDef {
+    struct ImpDef *next;
+    char *extname;
+    char *libname;
+    unsigned int impindex;
+    char *impname;
+} *imphead, **imptail;
+
+static struct ExpDef {
+    struct ExpDef *next;
+    char *intname;
+    char *extname;
+    unsigned int ordinal;
+    int flags;
+} *exphead, **exptail;
+
+#define EXPDEF_FLAG_ORDINAL  0x80
+#define EXPDEF_FLAG_RESIDENT 0x40
+#define EXPDEF_FLAG_NODATA   0x20
+#define EXPDEF_MASK_PARMCNT  0x1F
+
+static int32_t obj_entry_seg, obj_entry_ofs;
+
+const struct ofmt of_obj;
+static const struct dfmt borland_debug_form;
+
+/* The current segment */
+static struct Segment *current_seg;
+
+static int32_t obj_segment(char *, int *);
+static void obj_write_file(void);
+static enum directive_result obj_directive(enum directive, char *);
+
+static void obj_init(void)
+{
+    strlcpy(obj_infile, inname, sizeof(obj_infile));
+    first_seg = seg_alloc();
+    any_segs = false;
+    fpubhead = NULL;
+    fpubtail = &fpubhead;
+    exthead = NULL;
+    exttail = &exthead;
+    imphead = NULL;
+    imptail = &imphead;
+    exphead = NULL;
+    exptail = &exphead;
+    dws = NULL;
+    externals = 0;
+    ebhead = NULL;
+    ebtail = &ebhead;
+    seghead = obj_seg_needs_update = NULL;
+    segtail = &seghead;
+    grphead = obj_grp_needs_update = NULL;
+    grptail = &grphead;
+    obj_entry_seg = NO_SEG;
+    obj_uppercase = false;
+    obj_use32 = false;
+    passtwo = 0;
+    current_seg = NULL;
+}
+
+static void obj_cleanup(void)
+{
+    obj_write_file();
+    dfmt->cleanup();
+    while (seghead) {
+        struct Segment *segtmp = seghead;
+        seghead = seghead->next;
+        while (segtmp->pubhead) {
+            struct Public *pubtmp = segtmp->pubhead;
+            segtmp->pubhead = pubtmp->next;
+            nasm_free(pubtmp->name);
+            nasm_free(pubtmp);
+        }
+        nasm_free(segtmp->segclass);
+        nasm_free(segtmp->overlay);
+        nasm_free(segtmp);
+    }
+    while (fpubhead) {
+        struct Public *pubtmp = fpubhead;
+        fpubhead = fpubhead->next;
+        nasm_free(pubtmp->name);
+        nasm_free(pubtmp);
+    }
+    while (exthead) {
+        struct External *exttmp = exthead;
+        exthead = exthead->next;
+        nasm_free(exttmp);
+    }
+    while (imphead) {
+        struct ImpDef *imptmp = imphead;
+        imphead = imphead->next;
+        nasm_free(imptmp->extname);
+        nasm_free(imptmp->libname);
+        nasm_free(imptmp->impname);     /* nasm_free won't mind if it's NULL */
+        nasm_free(imptmp);
+    }
+    while (exphead) {
+        struct ExpDef *exptmp = exphead;
+        exphead = exphead->next;
+        nasm_free(exptmp->extname);
+        nasm_free(exptmp->intname);
+        nasm_free(exptmp);
+    }
+    while (ebhead) {
+        struct ExtBack *ebtmp = ebhead;
+        ebhead = ebhead->next;
+        nasm_free(ebtmp);
+    }
+    while (grphead) {
+        struct Group *grptmp = grphead;
+        grphead = grphead->next;
+        nasm_free(grptmp);
+    }
+}
+
+static void obj_ext_set_defwrt(struct External *ext, char *id)
+{
+    struct Segment *seg;
+    struct Group *grp;
+
+    for (seg = seghead; seg; seg = seg->next)
+        if (!strcmp(seg->name, id)) {
+            ext->defwrt_type = DEFWRT_SEGMENT;
+            ext->defwrt_ptr.seg = seg;
+            nasm_free(id);
+            return;
+        }
+
+    for (grp = grphead; grp; grp = grp->next)
+        if (!strcmp(grp->name, id)) {
+            ext->defwrt_type = DEFWRT_GROUP;
+            ext->defwrt_ptr.grp = grp;
+            nasm_free(id);
+            return;
+        }
+
+    ext->defwrt_type = DEFWRT_STRING;
+    ext->defwrt_ptr.string = id;
+    ext->next_dws = dws;
+    dws = ext;
+}
+
+static void obj_deflabel(char *name, int32_t segment,
+                         int64_t offset, int is_global, char *special)
+{
+    /*
+     * We have three cases:
+     *
+     * (i) `segment' is a segment-base. If so, set the name field
+     * for the segment or group structure it refers to, and then
+     * return.
+     *
+     * (ii) `segment' is one of our segments, or a SEG_ABS segment.
+     * Save the label position for later output of a PUBDEF record.
+     * (Or a MODPUB, if we work out how.)
+     *
+     * (iii) `segment' is not one of our segments. Save the label
+     * position for later output of an EXTDEF, and also store a
+     * back-reference so that we can map later references to this
+     * segment number to the external index.
+     */
+    struct External *ext;
+    struct ExtBack *eb;
+    struct Segment *seg;
+    int i;
+    bool used_special = false;   /* have we used the special text? */
+
+    if (debug_level(2))
+        nasm_debug(" obj_deflabel: %s, seg=%"PRIx32", off=%"PRIx64", is_global=%d, %s\n",
+                   name, segment, offset, is_global, special);
+
+    /*
+     * If it's a special-retry from pass two, discard it.
+     */
+    if (is_global == 3)
+        return;
+
+    /*
+     * First check for the double-period, signifying something
+     * unusual.
+     */
+    if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+        if (!strcmp(name, "..start")) {
+            obj_entry_seg = segment;
+            obj_entry_ofs = offset;
+            return;
+        }
+        nasm_nonfatal("unrecognised special symbol `%s'", name);
+    }
+
+    /*
+     * Case (i):
+     */
+    if (obj_seg_needs_update) {
+        obj_seg_needs_update->name = name;
+        return;
+    } else if (obj_grp_needs_update) {
+        obj_grp_needs_update->name = name;
+        return;
+    }
+    if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
+        return;
+
+    if (segment >= SEG_ABS || segment == NO_SEG) {
+        /*
+         * SEG_ABS subcase of (ii).
+         */
+        if (is_global) {
+            struct Public *pub;
+
+            pub = *fpubtail = nasm_malloc(sizeof(*pub));
+            fpubtail = &pub->next;
+            pub->next = NULL;
+            pub->name = nasm_strdup(name);
+            pub->offset = offset;
+            pub->segment = (segment == NO_SEG ? 0 : segment & ~SEG_ABS);
+        }
+        if (special)
+            nasm_nonfatal("OBJ supports no special symbol features"
+                          " for this symbol type");
+        return;
+    }
+
+    /*
+     * If `any_segs' is still false, we might need to define a
+     * default segment, if they're trying to declare a label in
+     * `first_seg'.
+     */
+    if (!any_segs && segment == first_seg) {
+        int tempint = 0;
+        if (segment != obj_segment("__NASMDEFSEG", &tempint))
+            nasm_panic("strange segment conditions in OBJ driver");
+    }
+
+    for (seg = seghead; seg && is_global; seg = seg->next)
+        if (seg->index == segment) {
+            struct Public *loc = nasm_malloc(sizeof(*loc));
+            /*
+             * Case (ii). Maybe MODPUB someday?
+             */
+            *seg->pubtail = loc;
+            seg->pubtail = &loc->next;
+            loc->next = NULL;
+            loc->name = nasm_strdup(name);
+            loc->offset = offset;
+
+            if (special)
+                nasm_nonfatal("OBJ supports no special symbol features"
+                              " for this symbol type");
+            return;
+        }
+
+    /*
+     * Case (iii).
+     */
+    if (is_global) {
+        ext = *exttail = nasm_malloc(sizeof(*ext));
+        ext->next = NULL;
+        exttail = &ext->next;
+        ext->name = name;
+        /* Place by default all externs into the current segment */
+        ext->defwrt_type = DEFWRT_NONE;
+
+/* 28-Apr-2002 - John Coffman
+  The following code was introduced on 12-Aug-2000, and breaks fixups
+  on code passed thru the MSC 5.1 linker (3.66) and MSC 6.00A linker
+  (5.10).  It was introduced after FIXUP32 was added, and may be needed
+  for 32-bit segments.  The following will get 16-bit segments working
+  again, and maybe someone can correct the 'if' condition which is
+  actually needed.
+*/
+#if 0
+        if (current_seg) {
+#else
+        if (current_seg && current_seg->use32) {
+            if (current_seg->grp) {
+                ext->defwrt_type = DEFWRT_GROUP;
+                ext->defwrt_ptr.grp = current_seg->grp;
+            } else {
+                ext->defwrt_type = DEFWRT_SEGMENT;
+                ext->defwrt_ptr.seg = current_seg;
+            }
+        }
+#endif
+
+        if (is_global == 2) {
+            ext->commonsize = offset;
+            ext->commonelem = 1;        /* default FAR */
+        } else
+            ext->commonsize = 0;
+    } else
+        return;
+
+    /*
+     * Now process the special text, if any, to find default-WRT
+     * specifications and common-variable element-size and near/far
+     * specifications.
+     */
+    while (special && *special) {
+        used_special = true;
+
+        /*
+         * We might have a default-WRT specification.
+         */
+        if (!nasm_strnicmp(special, "wrt", 3)) {
+            char *p;
+            int len;
+            special += 3;
+            special += strspn(special, " \t");
+            p = nasm_strndup(special, len = strcspn(special, ":"));
+            obj_ext_set_defwrt(ext, p);
+            special += len;
+            if (*special && *special != ':')
+                nasm_nonfatal("`:' expected in special symbol"
+                              " text for `%s'", ext->name);
+            else if (*special == ':')
+                special++;
+        }
+
+        /*
+         * The NEAR or FAR keywords specify nearness or
+         * farness. FAR gives default element size 1.
+         */
+        if (!nasm_strnicmp(special, "far", 3)) {
+            if (ext->commonsize)
+                ext->commonelem = 1;
+            else
+                nasm_nonfatal("`%s': `far' keyword may only be applied"
+                              " to common variables\n", ext->name);
+            special += 3;
+            special += strspn(special, " \t");
+        } else if (!nasm_strnicmp(special, "near", 4)) {
+            if (ext->commonsize)
+                ext->commonelem = 0;
+            else
+                nasm_nonfatal("`%s': `far' keyword may only be applied"
+                              " to common variables\n", ext->name);
+            special += 4;
+            special += strspn(special, " \t");
+        }
+
+        /*
+         * If it's a common, and anything else remains on the line
+         * before a further colon, evaluate it as an expression and
+         * use that as the element size. Forward references aren't
+         * allowed.
+         */
+        if (*special == ':')
+            special++;
+        else if (*special) {
+            if (ext->commonsize) {
+                expr *e;
+                struct tokenval tokval;
+
+                stdscan_reset();
+                stdscan_set(special);
+                tokval.t_type = TOKEN_INVALID;
+                e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
+                if (e) {
+                    if (!is_simple(e))
+                        nasm_nonfatal("cannot use relocatable"
+                                      " expression as common-variable element size");
+                    else
+                        ext->commonelem = reloc_value(e);
+                }
+                special = stdscan_get();
+            } else {
+                nasm_nonfatal("`%s': element-size specifications only"
+                              " apply to common variables", ext->name);
+                while (*special && *special != ':')
+                    special++;
+                if (*special == ':')
+                    special++;
+            }
+        }
+    }
+
+    i = segment / 2;
+    eb = ebhead;
+    if (!eb) {
+        eb = *ebtail = nasm_zalloc(sizeof(*eb));
+        eb->next = NULL;
+        ebtail = &eb->next;
+    }
+    while (i >= EXT_BLKSIZ) {
+        if (eb && eb->next)
+            eb = eb->next;
+        else {
+            eb = *ebtail = nasm_zalloc(sizeof(*eb));
+            eb->next = NULL;
+            ebtail = &eb->next;
+        }
+        i -= EXT_BLKSIZ;
+    }
+    eb->exts[i] = ext;
+    ext->index = ++externals;
+
+    if (special && !used_special)
+        nasm_nonfatal("OBJ supports no special symbol features"
+                      " for this symbol type");
+}
+
+/* forward declaration */
+static void obj_write_fixup(ObjRecord * orp, int bytes,
+                            int segrel, int32_t seg, int32_t wrt,
+                            struct Segment *segto);
+
+static void obj_out(int32_t segto, const void *data,
+		    enum out_type type, uint64_t size,
+                    int32_t segment, int32_t wrt)
+{
+    const uint8_t *ucdata;
+    int32_t ldata;
+    struct Segment *seg;
+    ObjRecord *orp;
+
+    /*
+     * If `any_segs' is still false, we must define a default
+     * segment.
+     */
+    if (!any_segs) {
+        int tempint = 0;
+        if (segto != obj_segment("__NASMDEFSEG", &tempint))
+            nasm_panic("strange segment conditions in OBJ driver");
+    }
+
+    /*
+     * Find the segment we are targeting.
+     */
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segto)
+            break;
+    if (!seg)
+        nasm_panic("code directed to nonexistent segment?");
+
+    orp = seg->orp;
+    orp->parm[0] = seg->currentpos;
+
+    switch (type) {
+    case OUT_RAWDATA:
+        ucdata = data;
+        while (size > 0) {
+            unsigned int len;
+            orp = obj_check(seg->orp, 1);
+            len = RECORD_MAX - orp->used;
+            if (len > size)
+                len = size;
+            memcpy(orp->buf + orp->used, ucdata, len);
+            orp->committed = orp->used += len;
+            orp->parm[0] = seg->currentpos += len;
+            ucdata += len;
+            size -= len;
+        }
+	break;
+
+    case OUT_ADDRESS:
+    case OUT_REL1ADR:
+    case OUT_REL2ADR:
+    case OUT_REL4ADR:
+    case OUT_REL8ADR:
+    {
+        int rsize;
+
+        if (type == OUT_ADDRESS)
+            size = abs((int)size);
+
+        if (segment == NO_SEG && type != OUT_ADDRESS)
+            nasm_nonfatal("relative call to absolute address not"
+                          " supported by OBJ format");
+        if (segment >= SEG_ABS)
+            nasm_nonfatal("far-absolute relocations not supported"
+                          " by OBJ format");
+
+        ldata = *(int64_t *)data;
+        if (type != OUT_ADDRESS) {
+	    /*
+	     * For 16-bit and 32-bit x86 code, the size and realsize() always
+	     * matches as only jumps, calls and loops uses PC relative
+	     * addressing and the address isn't followed by any other opcode
+	     * bytes.  In 64-bit mode there is RIP relative addressing which
+	     * means the fixup location can be followed by an immediate value,
+	     * meaning that size > realsize().
+	     *
+	     * When the CPU is calculating the effective address, it takes the
+	     * RIP at the end of the instruction and adds the fixed up relative
+	     * address value to it.
+	     *
+	     * The linker's point of reference is the end of the fixup location
+	     * (which is the end of the instruction for Jcc, CALL, LOOP[cc]).
+	     * It is calculating distance between the target symbol and the end
+	     * of the fixup location, and add this to the displacement value we
+	     * are calculating here and storing at the fixup location.
+	     *
+	     * To get the right effect, we need to _reduce_ the displacement
+	     * value by the number of bytes following the fixup.
+	     *
+	     * Example:
+	     *  data at address 0x100; REL4ADR at 0x050, 4 byte immediate,
+	     *  end of fixup at 0x054, end of instruction at 0x058.
+	     *  => size = 8.
+	     *  => realsize() -> 4
+	     *  => CPU needs a value of:   0x100 - 0x058 = 0x0a8
+	     *  => linker/loader will add: 0x100 - 0x054 = 0x0ac
+	     *  => We must add an addend of -4.
+	     *  => realsize() - size = -4.
+	     *
+	     * The code used to do size - realsize() at least since v0.90,
+	     * probably because it wasn't needed...
+	     */
+	    ldata -= size;
+	    size = realsize(type, size);
+	    ldata += size;
+        }
+
+	switch (size) {
+	default:
+            nasm_nonfatal("OBJ format can only handle 16- or "
+                          "32-byte relocations");
+	    segment = NO_SEG;	/* Don't actually generate a relocation */
+	    break;
+	case 2:
+            orp = obj_word(orp, ldata);
+	    break;
+	case 4:
+            orp = obj_dword(orp, ldata);
+	    break;
+	}
+
+        rsize = size;
+        if (segment < SEG_ABS && (segment != NO_SEG && segment % 2) &&
+            size == 4) {
+            /*
+             * This is a 4-byte segment-base relocation such as
+             * `MOV EAX,SEG foo'. OBJ format can't actually handle
+             * these, but if the constant term has the 16 low bits
+             * zero, we can just apply a 2-byte segment-base
+             * relocation to the low word instead.
+             */
+            rsize = 2;
+            if (ldata & 0xFFFF)
+                nasm_nonfatal("OBJ format cannot handle complex"
+                              " dword-size segment base references");
+        }
+        if (segment != NO_SEG)
+            obj_write_fixup(orp, rsize,
+                            (type == OUT_ADDRESS ? 0x4000 : 0),
+                            segment, wrt, seg);
+        seg->currentpos += size;
+	break;
+    }
+
+    default:
+        nasm_nonfatal("Relocation type not supported by output format");
+	/* fall through */
+
+    case OUT_RESERVE:
+        if (orp->committed)
+            orp = obj_bump(orp);
+        seg->currentpos += size;
+	break;
+    }
+    obj_commit(orp);
+}
+
+static void obj_write_fixup(ObjRecord * orp, int bytes,
+                            int segrel, int32_t seg, int32_t wrt,
+                            struct Segment *segto)
+{
+    unsigned locat;
+    int method;
+    int base;
+    int32_t tidx, fidx;
+    struct Segment *s = NULL;
+    struct Group *g = NULL;
+    struct External *e = NULL;
+    ObjRecord *forp;
+
+    if (bytes != 2 && bytes != 4) {
+        nasm_nonfatal("`obj' output driver does not support"
+                      " %d-bit relocations", bytes << 3);
+        return;
+    }
+
+    forp = orp->child;
+    if (forp == NULL) {
+        orp->child = forp = obj_new();
+        forp->up = &(orp->child);
+        /* We should choose between FIXUPP and FIXU32 record type */
+        /* If we're targeting a 32-bit segment, use a FIXU32 record */
+        if (segto->use32)
+            forp->type = FIXU32;
+        else
+            forp->type = FIXUPP;
+    }
+
+    if (seg % 2) {
+        base = true;
+        locat = FIX_16_SELECTOR;
+        seg--;
+        if (bytes != 2)
+            nasm_panic("OBJ: 4-byte segment base fixup got"
+                  " through sanity check");
+    } else {
+        base = false;
+        locat = (bytes == 2) ? FIX_16_OFFSET : FIX_32_OFFSET;
+        if (!segrel)
+            /*
+             * There is a bug in tlink that makes it process self relative
+             * fixups incorrectly if the x_size doesn't match the location
+             * size.
+             */
+            forp = obj_force(forp, bytes << 3);
+    }
+
+    forp = obj_rword(forp, locat | segrel | (orp->parm[0] - orp->parm[2]));
+
+    tidx = fidx = -1, method = 0;       /* placate optimisers */
+
+    /*
+     * See if we can find the segment ID in our segment list. If
+     * so, we have a T4 (LSEG) target.
+     */
+    for (s = seghead; s; s = s->next)
+        if (s->index == seg)
+            break;
+    if (s)
+        method = 4, tidx = s->obj_index;
+    else {
+        for (g = grphead; g; g = g->next)
+            if (g->index == seg)
+                break;
+        if (g)
+            method = 5, tidx = g->obj_index;
+        else {
+            int32_t i = seg / 2;
+            struct ExtBack *eb = ebhead;
+            while (i >= EXT_BLKSIZ) {
+                if (eb)
+                    eb = eb->next;
+                else
+                    break;
+                i -= EXT_BLKSIZ;
+            }
+            if (eb)
+                method = 6, e = eb->exts[i], tidx = e->index;
+            else
+                nasm_panic("unrecognised segment value in obj_write_fixup");
+        }
+    }
+
+    /*
+     * If no WRT given, assume the natural default, which is method
+     * F5 unless:
+     *
+     * - we are doing an OFFSET fixup for a grouped segment, in
+     *   which case we require F1 (group).
+     *
+     * - we are doing an OFFSET fixup for an external with a
+     *   default WRT, in which case we must honour the default WRT.
+     */
+    if (wrt == NO_SEG) {
+        if (!base && s && s->grp)
+            method |= 0x10, fidx = s->grp->obj_index;
+        else if (!base && e && e->defwrt_type != DEFWRT_NONE) {
+            if (e->defwrt_type == DEFWRT_SEGMENT)
+                method |= 0x00, fidx = e->defwrt_ptr.seg->obj_index;
+            else if (e->defwrt_type == DEFWRT_GROUP)
+                method |= 0x10, fidx = e->defwrt_ptr.grp->obj_index;
+            else {
+                nasm_nonfatal("default WRT specification for"
+                              " external `%s' unresolved", e->name);
+                method |= 0x50, fidx = -1;      /* got to do _something_ */
+            }
+        } else
+            method |= 0x50, fidx = -1;
+    } else {
+        /*
+         * See if we can find the WRT-segment ID in our segment
+         * list. If so, we have a F0 (LSEG) frame.
+         */
+        for (s = seghead; s; s = s->next)
+            if (s->index == wrt - 1)
+                break;
+        if (s)
+            method |= 0x00, fidx = s->obj_index;
+        else {
+            for (g = grphead; g; g = g->next)
+                if (g->index == wrt - 1)
+                    break;
+            if (g)
+                method |= 0x10, fidx = g->obj_index;
+            else {
+                int32_t i = wrt / 2;
+                struct ExtBack *eb = ebhead;
+                while (i >= EXT_BLKSIZ) {
+                    if (eb)
+                        eb = eb->next;
+                    else
+                        break;
+                    i -= EXT_BLKSIZ;
+                }
+                if (eb)
+                    method |= 0x20, fidx = eb->exts[i]->index;
+                else
+                    nasm_panic("unrecognised WRT value in obj_write_fixup");
+            }
+        }
+    }
+
+    forp = obj_byte(forp, method);
+    if (fidx != -1)
+        forp = obj_index(forp, fidx);
+    forp = obj_index(forp, tidx);
+    obj_commit(forp);
+}
+
+static int32_t obj_segment(char *name, int *bits)
+{
+    /*
+     * We call the label manager here to define a name for the new
+     * segment, and when our _own_ label-definition stub gets
+     * called in return, it should register the new segment name
+     * using the pointer it gets passed. That way we save memory,
+     * by sponging off the label manager.
+     */
+    if (debug_level(3))
+        nasm_debug(" obj_segment: < %s >, *bits=%d\n", name, *bits);
+
+    if (!name) {
+        *bits = 16;
+        current_seg = NULL;
+        return first_seg;
+    } else {
+        struct Segment *seg;
+        struct Group *grp;
+        struct External **extp;
+        int obj_idx, i, attrs;
+	bool rn_error;
+        char *p;
+
+        /*
+         * Look for segment attributes.
+         */
+        attrs = 0;
+        while (*name == '.')
+            name++;             /* hack, but a documented one */
+        p = name;
+        while (*p && !nasm_isspace(*p))
+            p++;
+        if (*p) {
+            *p++ = '\0';
+            while (*p && nasm_isspace(*p))
+                *p++ = '\0';
+        }
+        while (*p) {
+            while (*p && !nasm_isspace(*p))
+                p++;
+            if (*p) {
+                *p++ = '\0';
+                while (*p && nasm_isspace(*p))
+                    *p++ = '\0';
+            }
+
+            attrs++;
+        }
+
+        for (seg = seghead, obj_idx = 1; ; seg = seg->next, obj_idx++) {
+            if (!seg)
+                break;
+
+            if (!strcmp(seg->name, name)) {
+                if (attrs > 0 && seg->pass_last_seen == pass_count())
+                    nasm_warn(WARN_OTHER, "segment attributes specified on"
+                              " redeclaration of segment: ignoring");
+                if (seg->use32)
+                    *bits = 32;
+                else
+                    *bits = 16;
+                current_seg = seg;
+                seg->pass_last_seen = pass_count();
+                return seg->index;
+            }
+        }
+
+        *segtail = seg = nasm_malloc(sizeof(*seg));
+        seg->next = NULL;
+        segtail = &seg->next;
+        seg->index = (any_segs ? seg_alloc() : first_seg);
+        seg->obj_index = obj_idx;
+        seg->grp = NULL;
+        any_segs = true;
+        seg->name = nasm_strdup(name);
+        seg->currentpos = 0;
+        seg->align = 1;         /* default */
+        seg->use32 = false;     /* default */
+        seg->combine = CMB_PUBLIC;      /* default */
+        seg->segclass = seg->overlay = NULL;
+        seg->pubhead = NULL;
+        seg->pubtail = &seg->pubhead;
+        seg->lochead = NULL;
+        seg->loctail = &seg->lochead;
+        seg->orp = obj_new();
+        seg->orp->up = &(seg->orp);
+        seg->orp->ori = ori_ledata;
+        seg->orp->type = LEDATA;
+        seg->orp->parm[1] = obj_idx;
+
+        /*
+         * Process the segment attributes.
+         */
+        p = name;
+        while (attrs--) {
+            p += strlen(p);
+            while (!*p)
+                p++;
+
+            /*
+             * `p' contains a segment attribute.
+             */
+            if (!nasm_stricmp(p, "private"))
+                seg->combine = CMB_PRIVATE;
+            else if (!nasm_stricmp(p, "public"))
+                seg->combine = CMB_PUBLIC;
+            else if (!nasm_stricmp(p, "common"))
+                seg->combine = CMB_COMMON;
+            else if (!nasm_stricmp(p, "stack"))
+                seg->combine = CMB_STACK;
+            else if (!nasm_stricmp(p, "use16"))
+                seg->use32 = false;
+            else if (!nasm_stricmp(p, "use32"))
+                seg->use32 = true;
+            else if (!nasm_stricmp(p, "flat")) {
+                /*
+                 * This segment is an OS/2 FLAT segment. That means
+                 * that its default group is group FLAT, even if
+                 * the group FLAT does not explicitly _contain_ the
+                 * segment.
+                 *
+                 * When we see this, we must create the group
+                 * `FLAT', containing no segments, if it does not
+                 * already exist; then we must set the default
+                 * group of this segment to be the FLAT group.
+                 */
+                struct Group *grp;
+                for (grp = grphead; grp; grp = grp->next)
+                    if (!strcmp(grp->name, "FLAT"))
+                        break;
+                if (!grp) {
+                    obj_directive(D_GROUP, "FLAT");
+                    for (grp = grphead; grp; grp = grp->next)
+                        if (!strcmp(grp->name, "FLAT"))
+                            break;
+                    if (!grp)
+                        nasm_panic("failure to define FLAT?!");
+                }
+                seg->grp = grp;
+            } else if (!nasm_strnicmp(p, "class=", 6))
+                seg->segclass = nasm_strdup(p + 6);
+            else if (!nasm_strnicmp(p, "overlay=", 8))
+                seg->overlay = nasm_strdup(p + 8);
+            else if (!nasm_strnicmp(p, "align=", 6)) {
+                seg->align = readnum(p + 6, &rn_error);
+                if (rn_error) {
+                    seg->align = 1;
+                    nasm_nonfatal("segment alignment should be numeric");
+                }
+                switch (seg->align) {
+                case 1:        /* BYTE */
+                case 2:        /* WORD */
+                case 4:        /* DWORD */
+                case 16:       /* PARA */
+                case 256:      /* PAGE */
+                case 4096:     /* PharLap extension */
+                    break;
+                case 8:
+                    nasm_warn(WARN_OTHER, "OBJ format does not support alignment"
+                              " of 8: rounding up to 16");
+                    seg->align = 16;
+                    break;
+                case 32:
+                case 64:
+                case 128:
+                    nasm_warn(WARN_OTHER, "OBJ format does not support alignment"
+                              " of %d: rounding up to 256", seg->align);
+                    seg->align = 256;
+                    break;
+                case 512:
+                case 1024:
+                case 2048:
+                    nasm_warn(WARN_OTHER, "OBJ format does not support alignment"
+                              " of %d: rounding up to 4096", seg->align);
+                    seg->align = 4096;
+                    break;
+                default:
+                    nasm_nonfatal("invalid alignment value %d",
+                                  seg->align);
+                    seg->align = 1;
+                    break;
+                }
+            } else if (!nasm_strnicmp(p, "absolute=", 9)) {
+                seg->align = SEG_ABS + readnum(p + 9, &rn_error);
+                if (rn_error)
+                    nasm_nonfatal("argument to `absolute' segment"
+                                  " attribute should be numeric");
+            }
+        }
+
+        /* We need to know whenever we have at least one 32-bit segment */
+        obj_use32 |= seg->use32;
+
+        obj_seg_needs_update = seg;
+        if (seg->align >= SEG_ABS)
+            define_label(name, NO_SEG, seg->align - SEG_ABS, false);
+        else
+            define_label(name, seg->index + 1, 0L, false);
+        obj_seg_needs_update = NULL;
+
+        /*
+         * See if this segment is defined in any groups.
+         */
+        for (grp = grphead; grp; grp = grp->next) {
+            for (i = grp->nindices; i < grp->nentries; i++) {
+                if (!strcmp(grp->segs[i].name, seg->name)) {
+                    nasm_free(grp->segs[i].name);
+                    grp->segs[i] = grp->segs[grp->nindices];
+                    grp->segs[grp->nindices++].index = seg->obj_index;
+                    if (seg->grp)
+                        nasm_warn(WARN_OTHER, "segment `%s' is already part of"
+                                  " a group: first one takes precedence",
+                                  seg->name);
+                    else
+                        seg->grp = grp;
+                }
+            }
+        }
+
+        /*
+         * Walk through the list of externals with unresolved
+         * default-WRT clauses, and resolve any that point at this
+         * segment.
+         */
+        extp = &dws;
+        while (*extp) {
+            if ((*extp)->defwrt_type == DEFWRT_STRING &&
+                !strcmp((*extp)->defwrt_ptr.string, seg->name)) {
+                nasm_free((*extp)->defwrt_ptr.string);
+                (*extp)->defwrt_type = DEFWRT_SEGMENT;
+                (*extp)->defwrt_ptr.seg = seg;
+                *extp = (*extp)->next_dws;
+            } else
+                extp = &(*extp)->next_dws;
+        }
+
+        if (seg->use32)
+            *bits = 32;
+        else
+            *bits = 16;
+        current_seg = seg;
+        return seg->index;
+    }
+}
+
+static enum directive_result
+obj_directive(enum directive directive, char *value)
+{
+    switch (directive) {
+    case D_GROUP:
+    {
+        char *p, *q, *v;
+        if (pass_first()) {     /* XXX */
+            struct Group *grp;
+            struct Segment *seg;
+            struct External **extp;
+            int obj_idx;
+
+            q = value;
+            while (*q == '.')
+                q++;            /* hack, but a documented one */
+            v = q;
+            while (*q && !nasm_isspace(*q))
+                q++;
+            if (nasm_isspace(*q)) {
+                *q++ = '\0';
+                while (*q && nasm_isspace(*q))
+                    q++;
+            }
+            /*
+             * Here we used to sanity-check the group directive to
+             * ensure nobody tried to declare a group containing no
+             * segments. However, OS/2 does this as standard
+             * practice, so the sanity check has been removed.
+             *
+             * if (!*q) {
+             *     nasm_error(ERR_NONFATAL,"GROUP directive contains no segments");
+             *     return DIRR_ERROR;
+             * }
+             */
+
+            obj_idx = 1;
+            for (grp = grphead; grp; grp = grp->next) {
+                obj_idx++;
+                if (!strcmp(grp->name, v)) {
+                    nasm_nonfatal("group `%s' defined twice", v);
+                    return DIRR_ERROR;
+                }
+            }
+
+            *grptail = grp = nasm_malloc(sizeof(*grp));
+            grp->next = NULL;
+            grptail = &grp->next;
+            grp->index = seg_alloc();
+            grp->obj_index = obj_idx;
+            grp->nindices = grp->nentries = 0;
+            grp->name = NULL;
+
+            obj_grp_needs_update = grp;
+            backend_label(v, grp->index + 1, 0L);
+            obj_grp_needs_update = NULL;
+
+            while (*q) {
+                p = q;
+                while (*q && !nasm_isspace(*q))
+                    q++;
+                if (nasm_isspace(*q)) {
+                    *q++ = '\0';
+                    while (*q && nasm_isspace(*q))
+                        q++;
+                }
+                /*
+                 * Now p contains a segment name. Find it.
+                 */
+                for (seg = seghead; seg; seg = seg->next)
+                    if (!strcmp(seg->name, p))
+                        break;
+                if (seg) {
+                    /*
+                     * We have a segment index. Shift a name entry
+                     * to the end of the array to make room.
+                     */
+                    grp->segs[grp->nentries++] = grp->segs[grp->nindices];
+                    grp->segs[grp->nindices++].index = seg->obj_index;
+                    if (seg->grp)
+                        nasm_warn(WARN_OTHER, "segment `%s' is already part of"
+                                  " a group: first one takes precedence",
+                                  seg->name);
+                    else
+                        seg->grp = grp;
+                } else {
+                    /*
+                     * We have an as-yet undefined segment.
+                     * Remember its name, for later.
+                     */
+                    grp->segs[grp->nentries++].name = nasm_strdup(p);
+                }
+            }
+
+            /*
+             * Walk through the list of externals with unresolved
+             * default-WRT clauses, and resolve any that point at
+             * this group.
+             */
+            extp = &dws;
+            while (*extp) {
+                if ((*extp)->defwrt_type == DEFWRT_STRING &&
+                    !strcmp((*extp)->defwrt_ptr.string, grp->name)) {
+                    nasm_free((*extp)->defwrt_ptr.string);
+                    (*extp)->defwrt_type = DEFWRT_GROUP;
+                    (*extp)->defwrt_ptr.grp = grp;
+                    *extp = (*extp)->next_dws;
+                } else
+                    extp = &(*extp)->next_dws;
+            }
+        }
+        return DIRR_OK;
+    }
+    case D_UPPERCASE:
+        obj_uppercase = true;
+        return DIRR_OK;
+
+    case D_IMPORT:
+    {
+        char *q, *extname, *libname, *impname;
+
+        if (!pass_first())      /* XXX */
+            return DIRR_OK;
+        extname = q = value;
+        while (*q && !nasm_isspace(*q))
+            q++;
+        if (nasm_isspace(*q)) {
+            *q++ = '\0';
+            while (*q && nasm_isspace(*q))
+                q++;
+        }
+
+        libname = q;
+        while (*q && !nasm_isspace(*q))
+            q++;
+        if (nasm_isspace(*q)) {
+            *q++ = '\0';
+            while (*q && nasm_isspace(*q))
+                q++;
+        }
+
+        impname = q;
+
+        if (!*extname || !*libname)
+            nasm_nonfatal("`import' directive requires symbol name"
+                          " and library name");
+        else {
+            struct ImpDef *imp;
+            bool err = false;
+
+            imp = *imptail = nasm_malloc(sizeof(struct ImpDef));
+            imptail = &imp->next;
+            imp->next = NULL;
+            imp->extname = nasm_strdup(extname);
+            imp->libname = nasm_strdup(libname);
+            imp->impindex = readnum(impname, &err);
+            if (!*impname || err)
+                imp->impname = nasm_strdup(impname);
+            else
+                imp->impname = NULL;
+        }
+
+        return DIRR_OK;
+    }
+    case D_EXPORT:
+    {
+        char *q, *extname, *intname, *v;
+        struct ExpDef *export;
+        int flags = 0;
+        unsigned int ordinal = 0;
+
+        if (!pass_first())
+            return DIRR_OK;     /* ignore in pass two */
+        intname = q = value;
+        while (*q && !nasm_isspace(*q))
+            q++;
+        if (nasm_isspace(*q)) {
+            *q++ = '\0';
+            while (*q && nasm_isspace(*q))
+                q++;
+        }
+
+        extname = q;
+        while (*q && !nasm_isspace(*q))
+            q++;
+        if (nasm_isspace(*q)) {
+            *q++ = '\0';
+            while (*q && nasm_isspace(*q))
+                q++;
+        }
+
+        if (!*intname) {
+            nasm_nonfatal("`export' directive requires export name");
+            return DIRR_OK;
+        }
+        if (!*extname) {
+            extname = intname;
+            intname = "";
+        }
+        while (*q) {
+            v = q;
+            while (*q && !nasm_isspace(*q))
+                q++;
+            if (nasm_isspace(*q)) {
+                *q++ = '\0';
+                while (*q && nasm_isspace(*q))
+                    q++;
+            }
+            if (!nasm_stricmp(v, "resident"))
+                flags |= EXPDEF_FLAG_RESIDENT;
+            else if (!nasm_stricmp(v, "nodata"))
+                flags |= EXPDEF_FLAG_NODATA;
+            else if (!nasm_strnicmp(v, "parm=", 5)) {
+                bool err = false;
+                flags |= EXPDEF_MASK_PARMCNT & readnum(v + 5, &err);
+                if (err) {
+                    nasm_nonfatal("value `%s' for `parm' is non-numeric", v + 5);
+                    return DIRR_ERROR;
+                }
+            } else {
+                bool err = false;
+                ordinal = readnum(v, &err);
+                if (err) {
+                    nasm_nonfatal("unrecognised export qualifier `%s'", v);
+                    return DIRR_ERROR;
+                }
+                flags |= EXPDEF_FLAG_ORDINAL;
+            }
+        }
+
+        export = *exptail = nasm_malloc(sizeof(struct ExpDef));
+        exptail = &export->next;
+        export->next = NULL;
+        export->extname = nasm_strdup(extname);
+        export->intname = nasm_strdup(intname);
+        export->ordinal = ordinal;
+        export->flags = flags;
+
+        return DIRR_OK;
+    }
+    default:
+	return DIRR_UNKNOWN;
+    }
+}
+
+static void obj_sectalign(int32_t seg, unsigned int value)
+{
+    struct Segment *s;
+
+    list_for_each(s, seghead) {
+        if (s->index == seg)
+            break;
+    }
+
+    /*
+     * it should not be too big value
+     * and applied on non-absolute sections
+     */
+    if (!s || !is_power2(value) ||
+        value > 4096 || s->align >= SEG_ABS)
+        return;
+
+    /*
+     * FIXME: No code duplication please
+     * consider making helper for this
+     * mapping since section handler has
+     * to do the same
+     */
+    switch (value) {
+    case 8:
+        value = 16;
+        break;
+    case 32:
+    case 64:
+    case 128:
+        value = 256;
+        break;
+    case 512:
+    case 1024:
+    case 2048:
+        value = 4096;
+        break;
+    }
+
+    if (s->align < (int)value)
+        s->align = value;
+}
+
+static int32_t obj_segbase(int32_t segment)
+{
+    struct Segment *seg;
+
+    /*
+     * Find the segment in our list.
+     */
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segment - 1)
+            break;
+
+    if (!seg) {
+        /*
+         * Might be an external with a default WRT.
+         */
+        int32_t i = segment / 2;
+        struct ExtBack *eb = ebhead;
+        struct External *e;
+
+        while (i >= EXT_BLKSIZ) {
+            if (eb)
+                eb = eb->next;
+            else
+                break;
+            i -= EXT_BLKSIZ;
+        }
+        if (eb) {
+            e = eb->exts[i];
+	    if (!e) {
+                /* Not available yet, probably a forward reference */
+		nasm_assert(!pass_final());
+		return NO_SEG;
+	    }
+
+	    switch (e->defwrt_type) {
+	    case DEFWRT_NONE:
+                return segment; /* fine */
+	    case DEFWRT_SEGMENT:
+                return e->defwrt_ptr.seg->index + 1;
+	    case DEFWRT_GROUP:
+                return e->defwrt_ptr.grp->index + 1;
+	    default:
+                return NO_SEG;  /* can't tell what it is */
+	    }
+        }
+
+        return segment;         /* not one of ours - leave it alone */
+    }
+
+    if (seg->align >= SEG_ABS)
+        return seg->align;      /* absolute segment */
+    if (seg->grp)
+        return seg->grp->index + 1;     /* grouped segment */
+
+    return segment;             /* no special treatment */
+}
+
+/* Get a file timestamp in MS-DOS format */
+static uint32_t obj_file_timestamp(const char *pathname)
+{
+    time_t t;
+    const struct tm *lt;
+
+    if (!nasm_file_time(&t, pathname))
+        return 0;
+
+    lt = localtime(&t);
+    if (!lt)
+        return 0;
+
+    if (lt->tm_year < 80 || lt->tm_year > 207)
+        return 0;               /* Only years 1980-2107 representable */
+
+    return
+        ((uint32_t)lt->tm_sec >> 1) +
+        ((uint32_t)lt->tm_min << 5) +
+        ((uint32_t)lt->tm_hour << 11) +
+        ((uint32_t)lt->tm_mday << 16) +
+        (((uint32_t)lt->tm_mon + 1) << 21) +
+        (((uint32_t)lt->tm_year - 80) << 25);
+}
+
+static void obj_write_file(void)
+{
+    struct Segment *seg, *entry_seg_ptr = 0;
+    struct FileName *fn;
+    struct LineNumber *ln;
+    struct Group *grp;
+    struct Public *pub, *loc;
+    struct External *ext;
+    struct ImpDef *imp;
+    struct ExpDef *export;
+    int lname_idx;
+    ObjRecord *orp;
+    const struct strlist_entry *depfile;
+    const bool debuginfo = (dfmt == &borland_debug_form);
+
+    /*
+     * Write the THEADR module header.
+     */
+    orp = obj_new();
+    orp->type = THEADR;
+    obj_name(orp, obj_infile);
+    obj_emit2(orp);
+
+    /*
+     * Write the NASM boast comment.
+     */
+    orp->type = COMENT;
+    obj_rword(orp, dTRANSL);
+    obj_name(orp, nasm_comment());
+    obj_emit2(orp);
+
+    /*
+     * Output file dependency information
+     */
+    if (!obj_nodepend && depend_list) {
+        strlist_for_each(depfile, depend_list) {
+            uint32_t ts;
+
+            ts = obj_file_timestamp(depfile->str);
+            if (ts) {
+                orp->type = COMENT;
+                obj_rword(orp, dDEPFILE);
+                obj_dword(orp, ts);
+                obj_name(orp, depfile->str);
+                obj_emit2(orp);
+            }
+        }
+    }
+
+    orp->type = COMENT;
+    /*
+     * Write the IMPDEF records, if any.
+     */
+    for (imp = imphead; imp; imp = imp->next) {
+        obj_rword(orp, dOMFEXT);
+        obj_byte(orp, 1);       /* subfunction 1: IMPDEF */
+        if (imp->impname)
+            obj_byte(orp, 0);   /* import by name */
+        else
+            obj_byte(orp, 1);   /* import by ordinal */
+        obj_name(orp, imp->extname);
+        obj_name(orp, imp->libname);
+        if (imp->impname)
+            obj_name(orp, imp->impname);
+        else
+            obj_word(orp, imp->impindex);
+        obj_emit2(orp);
+    }
+
+    /*
+     * Write the EXPDEF records, if any.
+     */
+    for (export = exphead; export; export = export->next) {
+        obj_rword(orp, dOMFEXT);
+        obj_byte(orp, 2);       /* subfunction 2: EXPDEF */
+        obj_byte(orp, export->flags);
+        obj_name(orp, export->extname);
+        obj_name(orp, export->intname);
+        if (export->flags & EXPDEF_FLAG_ORDINAL)
+            obj_word(orp, export->ordinal);
+        obj_emit2(orp);
+    }
+
+    /* we're using extended OMF if we put in debug info */
+    if (debuginfo) {
+        orp->type = COMENT;
+        obj_rword(orp, dEXTENDED);
+        obj_emit2(orp);
+    }
+
+    /*
+     * Write the first LNAMES record, containing LNAME one, which
+     * is null. Also initialize the LNAME counter.
+     */
+    orp->type = LNAMES;
+    obj_byte(orp, 0);
+    lname_idx = 1;
+    /*
+     * Write some LNAMES for the segment names
+     */
+    for (seg = seghead; seg; seg = seg->next) {
+        orp = obj_name(orp, seg->name);
+        if (seg->segclass)
+            orp = obj_name(orp, seg->segclass);
+        if (seg->overlay)
+            orp = obj_name(orp, seg->overlay);
+        obj_commit(orp);
+    }
+    /*
+     * Write some LNAMES for the group names
+     */
+    for (grp = grphead; grp; grp = grp->next) {
+        orp = obj_name(orp, grp->name);
+        obj_commit(orp);
+    }
+    obj_emit(orp);
+
+    /*
+     * Write the SEGDEF records.
+     */
+    orp->type = SEGDEF;
+    for (seg = seghead; seg; seg = seg->next) {
+        int acbp;
+        uint32_t seglen = seg->currentpos;
+
+        acbp = (seg->combine << 2);     /* C field */
+
+        if (seg->use32)
+            acbp |= 0x01;       /* P bit is Use32 flag */
+        else if (seglen == 0x10000L) {
+            seglen = 0;         /* This special case may be needed for old linkers */
+            acbp |= 0x02;       /* B bit */
+        }
+
+        /* A field */
+        if (seg->align >= SEG_ABS)
+            /* acbp |= 0x00 */ ;
+        else if (seg->align >= 4096) {
+            if (seg->align > 4096)
+                nasm_nonfatal("segment `%s' requires more alignment"
+                              " than OBJ format supports", seg->name);
+            acbp |= 0xC0;       /* PharLap extension */
+        } else if (seg->align >= 256) {
+            acbp |= 0x80;
+        } else if (seg->align >= 16) {
+            acbp |= 0x60;
+        } else if (seg->align >= 4) {
+            acbp |= 0xA0;
+        } else if (seg->align >= 2) {
+            acbp |= 0x40;
+        } else
+            acbp |= 0x20;
+
+        obj_byte(orp, acbp);
+        if (seg->align & SEG_ABS) {
+            obj_x(orp, seg->align - SEG_ABS);   /* Frame */
+            obj_byte(orp, 0);   /* Offset */
+        }
+        obj_x(orp, seglen);
+        obj_index(orp, ++lname_idx);
+        obj_index(orp, seg->segclass ? ++lname_idx : 1);
+        obj_index(orp, seg->overlay ? ++lname_idx : 1);
+        obj_emit2(orp);
+    }
+
+    /*
+     * Write the GRPDEF records.
+     */
+    orp->type = GRPDEF;
+    for (grp = grphead; grp; grp = grp->next) {
+        int i;
+
+        if (grp->nindices != grp->nentries) {
+            for (i = grp->nindices; i < grp->nentries; i++) {
+                nasm_nonfatal("group `%s' contains undefined segment"
+                              " `%s'", grp->name, grp->segs[i].name);
+                nasm_free(grp->segs[i].name);
+                grp->segs[i].name = NULL;
+            }
+        }
+        obj_index(orp, ++lname_idx);
+        for (i = 0; i < grp->nindices; i++) {
+            obj_byte(orp, 0xFF);
+            obj_index(orp, grp->segs[i].index);
+        }
+        obj_emit2(orp);
+    }
+
+    /*
+     * Write the PUBDEF records: first the ones in the segments,
+     * then the far-absolutes.
+     */
+    orp->type = PUBDEF;
+    orp->ori = ori_pubdef;
+    for (seg = seghead; seg; seg = seg->next) {
+        orp->parm[0] = seg->grp ? seg->grp->obj_index : 0;
+        orp->parm[1] = seg->obj_index;
+        for (pub = seg->pubhead; pub; pub = pub->next) {
+            orp = obj_name(orp, pub->name);
+            orp = obj_x(orp, pub->offset);
+            orp = obj_byte(orp, 0);     /* type index */
+            obj_commit(orp);
+        }
+        obj_emit(orp);
+    }
+    orp->parm[0] = 0;
+    orp->parm[1] = 0;
+    for (pub = fpubhead; pub; pub = pub->next) {        /* pub-crawl :-) */
+        if (orp->parm[2] != (uint32_t)pub->segment) {
+            obj_emit(orp);
+            orp->parm[2] = pub->segment;
+        }
+        orp = obj_name(orp, pub->name);
+        orp = obj_x(orp, pub->offset);
+        orp = obj_byte(orp, 0); /* type index */
+        obj_commit(orp);
+    }
+    obj_emit(orp);
+
+    /*
+     * Write the EXTDEF and COMDEF records, in order.
+     */
+    orp->ori = ori_null;
+    for (ext = exthead; ext; ext = ext->next) {
+        if (ext->commonsize == 0) {
+            if (orp->type != EXTDEF) {
+                obj_emit(orp);
+                orp->type = EXTDEF;
+            }
+            orp = obj_name(orp, ext->name);
+            orp = obj_index(orp, 0);
+        } else {
+            if (orp->type != COMDEF) {
+                obj_emit(orp);
+                orp->type = COMDEF;
+            }
+            orp = obj_name(orp, ext->name);
+            orp = obj_index(orp, 0);
+            if (ext->commonelem) {
+                orp = obj_byte(orp, 0x61);      /* far communal */
+                orp = obj_value(orp, (ext->commonsize / ext->commonelem));
+                orp = obj_value(orp, ext->commonelem);
+            } else {
+                orp = obj_byte(orp, 0x62);      /* near communal */
+                orp = obj_value(orp, ext->commonsize);
+            }
+        }
+        obj_commit(orp);
+    }
+    obj_emit(orp);
+
+    /*
+     * Write a COMENT record stating that the linker's first pass
+     * may stop processing at this point. Exception is if our
+     * MODEND record specifies a start point, in which case,
+     * according to some variants of the documentation, this COMENT
+     * should be omitted. So we'll omit it just in case.
+     * But, TASM puts it in all the time so if we are using
+     * TASM debug stuff we are putting it in
+     */
+    if (debuginfo || obj_entry_seg == NO_SEG) {
+        orp->type = COMENT;
+        obj_rword(orp, dLINKPASS);
+        obj_byte(orp, 1);
+        obj_emit2(orp);
+    }
+
+    /*
+     * 1) put out the compiler type
+     * 2) Put out the type info.  The only type we are using is near label #19
+     */
+    if (debuginfo) {
+        int i;
+        struct Array *arrtmp = arrhead;
+        orp->type = COMENT;
+        obj_rword(orp, dCOMPDEF);
+        obj_byte(orp, 4);
+        obj_byte(orp, 0);
+        obj_emit2(orp);
+
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x18);    /* type # for linking */
+        obj_word(orp, 6);       /* size of type */
+        obj_byte(orp, 0x2a);    /* absolute type for debugging */
+        obj_emit2(orp);
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x19);    /* type # for linking */
+        obj_word(orp, 0);       /* size of type */
+        obj_byte(orp, 0x24);    /* absolute type for debugging */
+        obj_byte(orp, 0);       /* near/far specifier */
+        obj_emit2(orp);
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x1A);    /* type # for linking */
+        obj_word(orp, 0);       /* size of type */
+        obj_byte(orp, 0x24);    /* absolute type for debugging */
+        obj_byte(orp, 1);       /* near/far specifier */
+        obj_emit2(orp);
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x1b);    /* type # for linking */
+        obj_word(orp, 0);       /* size of type */
+        obj_byte(orp, 0x23);    /* absolute type for debugging */
+        obj_byte(orp, 0);
+        obj_byte(orp, 0);
+        obj_byte(orp, 0);
+        obj_emit2(orp);
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x1c);    /* type # for linking */
+        obj_word(orp, 0);       /* size of type */
+        obj_byte(orp, 0x23);    /* absolute type for debugging */
+        obj_byte(orp, 0);
+        obj_byte(orp, 4);
+        obj_byte(orp, 0);
+        obj_emit2(orp);
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x1d);    /* type # for linking */
+        obj_word(orp, 0);       /* size of type */
+        obj_byte(orp, 0x23);    /* absolute type for debugging */
+        obj_byte(orp, 0);
+        obj_byte(orp, 1);
+        obj_byte(orp, 0);
+        obj_emit2(orp);
+        obj_rword(orp, dTYPEDEF);
+        obj_word(orp, 0x1e);    /* type # for linking */
+        obj_word(orp, 0);       /* size of type */
+        obj_byte(orp, 0x23);    /* absolute type for debugging */
+        obj_byte(orp, 0);
+        obj_byte(orp, 5);
+        obj_byte(orp, 0);
+        obj_emit2(orp);
+
+        /* put out the array types */
+        for (i = ARRAYBOT; i < arrindex; i++) {
+            obj_rword(orp, dTYPEDEF);
+            obj_word(orp, i);   /* type # for linking */
+            obj_word(orp, arrtmp->size);        /* size of type */
+            obj_byte(orp, 0x1A);        /* absolute type for debugging (array) */
+            obj_byte(orp, arrtmp->basetype);    /* base type */
+            obj_emit2(orp);
+            arrtmp = arrtmp->next;
+        }
+    }
+    /*
+     * write out line number info with a LINNUM record
+     * switch records when we switch segments, and output the
+     * file in a pseudo-TASM fashion.  The record switch is naive; that
+     * is that one file may have many records for the same segment
+     * if there are lots of segment switches
+     */
+    if (fnhead && debuginfo) {
+        seg = fnhead->lnhead->segment;
+
+        for (fn = fnhead; fn; fn = fn->next) {
+            /* write out current file name */
+            orp->type = COMENT;
+            orp->ori = ori_null;
+            obj_rword(orp, dFILNAME);
+            obj_byte(orp, 0);
+            obj_name(orp, fn->name);
+            obj_dword(orp, 0);
+            obj_emit2(orp);
+
+            /* write out line numbers this file */
+
+            orp->type = LINNUM;
+            orp->ori = ori_linnum;
+            for (ln = fn->lnhead; ln; ln = ln->next) {
+                if (seg != ln->segment) {
+                    /* if we get here have to flush the buffer and start
+                     * a new record for a new segment
+                     */
+                    seg = ln->segment;
+                    obj_emit(orp);
+                }
+                orp->parm[0] = seg->grp ? seg->grp->obj_index : 0;
+                orp->parm[1] = seg->obj_index;
+                orp = obj_word(orp, ln->lineno);
+                orp = obj_x(orp, ln->offset);
+                obj_commit(orp);
+            }
+            obj_emit(orp);
+        }
+    }
+    /*
+     * we are going to locate the entry point segment now
+     * rather than wait until the MODEND record, because,
+     * then we can output a special symbol to tell where the
+     * entry point is.
+     *
+     */
+    if (obj_entry_seg != NO_SEG) {
+        for (seg = seghead; seg; seg = seg->next) {
+            if (seg->index == obj_entry_seg) {
+                entry_seg_ptr = seg;
+                break;
+            }
+        }
+        if (!seg)
+            nasm_nonfatal("entry point is not in this module");
+    }
+
+    /*
+     * get ready to put out symbol records
+     */
+    orp->type = COMENT;
+    orp->ori = ori_local;
+
+    /*
+     * put out a symbol for the entry point
+     * no dots in this symbol, because, borland does
+     * not (officially) support dots in label names
+     * and I don't know what various versions of TLINK will do
+     */
+    if (debuginfo && obj_entry_seg != NO_SEG) {
+        orp = obj_name(orp, "start_of_program");
+        orp = obj_word(orp, 0x19);      /* type: near label */
+        orp = obj_index(orp, seg->grp ? seg->grp->obj_index : 0);
+        orp = obj_index(orp, seg->obj_index);
+        orp = obj_x(orp, obj_entry_ofs);
+        obj_commit(orp);
+    }
+
+    /*
+     * put out the local labels
+     */
+    for (seg = seghead; seg && debuginfo; seg = seg->next) {
+        /* labels this seg */
+        for (loc = seg->lochead; loc; loc = loc->next) {
+            orp = obj_name(orp, loc->name);
+            orp = obj_word(orp, loc->type);
+            orp = obj_index(orp, seg->grp ? seg->grp->obj_index : 0);
+            orp = obj_index(orp, seg->obj_index);
+            orp = obj_x(orp, loc->offset);
+            obj_commit(orp);
+        }
+    }
+    if (orp->used)
+        obj_emit(orp);
+
+    /*
+     * Write the LEDATA/FIXUPP pairs.
+     */
+    for (seg = seghead; seg; seg = seg->next) {
+        obj_emit(seg->orp);
+        nasm_free(seg->orp);
+    }
+
+    /*
+     * Write the MODEND module end marker.
+     */
+    orp->type = obj_use32 ? MODE32 : MODEND;
+    orp->ori = ori_null;
+    if (entry_seg_ptr) {
+        orp->type = entry_seg_ptr->use32 ? MODE32 : MODEND;
+        obj_byte(orp, 0xC1);
+        seg = entry_seg_ptr;
+        if (seg->grp) {
+            obj_byte(orp, 0x10);
+            obj_index(orp, seg->grp->obj_index);
+        } else {
+            /*
+             * the below changed to prevent TLINK crashing.
+             * Previous more efficient version read:
+             *
+             *  obj_byte (orp, 0x50);
+             */
+            obj_byte(orp, 0x00);
+            obj_index(orp, seg->obj_index);
+        }
+        obj_index(orp, seg->obj_index);
+        obj_x(orp, obj_entry_ofs);
+    } else
+        obj_byte(orp, 0);
+    obj_emit2(orp);
+    nasm_free(orp);
+}
+
+static void obj_fwrite(ObjRecord * orp)
+{
+    unsigned int cksum, len;
+    uint8_t *ptr;
+
+    cksum = orp->type;
+    if (orp->x_size == 32)
+        cksum |= 1;
+    fputc(cksum, ofile);
+    len = orp->committed + 1;
+    cksum += (len & 0xFF) + ((len >> 8) & 0xFF);
+    fwriteint16_t(len, ofile);
+    nasm_write(orp->buf, len-1, ofile);
+    for (ptr = orp->buf; --len; ptr++)
+        cksum += *ptr;
+    fputc((-cksum) & 0xFF, ofile);
+}
+
+static enum directive_result
+obj_pragma(const struct pragma *pragma)
+{
+    switch (pragma->opcode) {
+    case D_NODEPEND:
+        obj_nodepend = true;
+        break;
+
+    default:
+        break;
+    }
+
+    return DIRR_OK;
+}
+
+extern macros_t obj_stdmac[];
+
+static void dbgbi_init(void)
+{
+    fnhead = NULL;
+    fntail = &fnhead;
+    arrindex = ARRAYBOT;
+    arrhead = NULL;
+    arrtail = &arrhead;
+}
+static void dbgbi_cleanup(void)
+{
+    struct Segment *segtmp;
+    while (fnhead) {
+        struct FileName *fntemp = fnhead;
+        while (fnhead->lnhead) {
+            struct LineNumber *lntemp = fnhead->lnhead;
+            fnhead->lnhead = lntemp->next;
+            nasm_free(lntemp);
+        }
+        fnhead = fnhead->next;
+        nasm_free(fntemp->name);
+        nasm_free(fntemp);
+    }
+    for (segtmp = seghead; segtmp; segtmp = segtmp->next) {
+        while (segtmp->lochead) {
+            struct Public *loctmp = segtmp->lochead;
+            segtmp->lochead = loctmp->next;
+            nasm_free(loctmp->name);
+            nasm_free(loctmp);
+        }
+    }
+    while (arrhead) {
+        struct Array *arrtmp = arrhead;
+        arrhead = arrhead->next;
+        nasm_free(arrtmp);
+    }
+}
+
+static void dbgbi_linnum(const char *lnfname, int32_t lineno, int32_t segto)
+{
+    struct FileName *fn;
+    struct LineNumber *ln;
+    struct Segment *seg;
+
+    if (segto == NO_SEG)
+        return;
+
+    /*
+     * If `any_segs' is still false, we must define a default
+     * segment.
+     */
+    if (!any_segs) {
+        int tempint = 0;
+        if (segto != obj_segment("__NASMDEFSEG", &tempint))
+            nasm_panic("strange segment conditions in OBJ driver");
+    }
+
+    /*
+     * Find the segment we are targeting.
+     */
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segto)
+            break;
+    if (!seg)
+        nasm_panic("lineno directed to nonexistent segment?");
+
+/*    for (fn = fnhead; fn; fn = fnhead->next) */
+    for (fn = fnhead; fn; fn = fn->next)        /* fbk - Austin Lunnen - John Fine */
+        if (!nasm_stricmp(lnfname, fn->name))
+            break;
+    if (!fn) {
+        fn = nasm_malloc(sizeof(*fn));
+        fn->name = nasm_malloc(strlen(lnfname) + 1);
+        strcpy(fn->name, lnfname);
+        fn->lnhead = NULL;
+        fn->lntail = &fn->lnhead;
+        fn->next = NULL;
+        *fntail = fn;
+        fntail = &fn->next;
+    }
+    ln = nasm_malloc(sizeof(*ln));
+    ln->segment = seg;
+    ln->offset = seg->currentpos;
+    ln->lineno = lineno;
+    ln->next = NULL;
+    *fn->lntail = ln;
+    fn->lntail = &ln->next;
+
+}
+static void dbgbi_deflabel(char *name, int32_t segment,
+                           int64_t offset, int is_global, char *special)
+{
+    struct Segment *seg;
+
+    (void)special;
+
+    /*
+     * Note: ..[^@] special symbols are filtered in labels.c
+     */
+
+    /*
+     * If it's a special-retry from pass two, discard it.
+     */
+    if (is_global == 3)
+        return;
+
+    /*
+     * Case (i):
+     */
+    if (obj_seg_needs_update) {
+        return;
+    } else if (obj_grp_needs_update) {
+        return;
+    }
+    if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
+        return;
+
+    if (segment >= SEG_ABS || segment == NO_SEG) {
+        return;
+    }
+
+    /*
+     * If `any_segs' is still false, we might need to define a
+     * default segment, if they're trying to declare a label in
+     * `first_seg'.  But the label should exist due to a prior
+     * call to obj_deflabel so we can skip that.
+     */
+
+    for (seg = seghead; seg; seg = seg->next)
+        if (seg->index == segment) {
+            struct Public *loc = nasm_malloc(sizeof(*loc));
+            /*
+             * Case (ii). Maybe MODPUB someday?
+             */
+            last_defined = *seg->loctail = loc;
+            seg->loctail = &loc->next;
+            loc->next = NULL;
+            loc->name = nasm_strdup(name);
+            loc->offset = offset;
+        }
+}
+static void dbgbi_typevalue(int32_t type)
+{
+    int vsize;
+    int elem = TYM_ELEMENTS(type);
+    type = TYM_TYPE(type);
+
+    if (!last_defined)
+        return;
+
+    switch (type) {
+    case TY_BYTE:
+        last_defined->type = 8; /* uint8_t */
+        vsize = 1;
+        break;
+    case TY_WORD:
+        last_defined->type = 10;        /* unsigned word */
+        vsize = 2;
+        break;
+    case TY_DWORD:
+        last_defined->type = 12;        /* unsigned dword */
+        vsize = 4;
+        break;
+    case TY_FLOAT:
+        last_defined->type = 14;        /* float */
+        vsize = 4;
+        break;
+    case TY_QWORD:
+        last_defined->type = 15;        /* qword */
+        vsize = 8;
+        break;
+    case TY_TBYTE:
+        last_defined->type = 16;        /* TBYTE */
+        vsize = 10;
+        break;
+    default:
+        last_defined->type = 0x19;      /* label */
+        vsize = 0;
+        break;
+    }
+
+    if (elem > 1) {
+        struct Array *arrtmp = nasm_malloc(sizeof(*arrtmp));
+        int vtype = last_defined->type;
+        arrtmp->size = vsize * elem;
+        arrtmp->basetype = vtype;
+        arrtmp->next = NULL;
+        last_defined->type = arrindex++;
+        *arrtail = arrtmp;
+        arrtail = &(arrtmp->next);
+    }
+    last_defined = NULL;
+}
+static void dbgbi_output(int output_type, void *param)
+{
+    (void)output_type;
+    (void)param;
+}
+static const struct dfmt borland_debug_form = {
+    "Borland Debug Records",
+    "borland",
+    dbgbi_init,
+    dbgbi_linnum,
+    dbgbi_deflabel,
+    NULL,                       /* .debug_smacros */
+    NULL,                       /* .debug_include */
+    NULL,                       /* .debug_mmacros */
+    null_debug_directive,
+    dbgbi_typevalue,
+    dbgbi_output,
+    dbgbi_cleanup,
+    NULL                        /* pragma list */
+};
+
+static const struct dfmt * const borland_debug_arr[3] = {
+    &borland_debug_form,
+    &null_debug_form,
+    NULL
+};
+
+static const struct pragma_facility obj_pragma_list[] = {
+    { NULL, obj_pragma }
+};
+
+const struct ofmt of_obj = {
+    "Intel/Microsoft OMF (MS-DOS, OS/2, Win16)",
+    "obj",
+    ".obj",
+    0,
+    32,
+    borland_debug_arr,
+    &borland_debug_form,
+    obj_stdmac,
+    obj_init,
+    null_reset,
+    nasm_do_legacy_output,
+    obj_out,
+    obj_deflabel,
+    obj_segment,
+    NULL,
+    obj_sectalign,
+    obj_segbase,
+    obj_directive,
+    obj_cleanup,
+    obj_pragma_list
+};
+#endif                          /* OF_OBJ */
diff --git a/vere/ext/nasm/output/outobj.mac b/vere/ext/nasm/output/outobj.mac
new file mode 100644
index 0000000..09158f2
--- /dev/null
+++ b/vere/ext/nasm/output/outobj.mac
@@ -0,0 +1,49 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;     
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: obj
+%define __?SECT?__ [section .text]
+%imacro group 1+.nolist
+[group %1]
+%endmacro
+%imacro uppercase 0+.nolist
+[uppercase %1]
+%endmacro
+%imacro export 1+.nolist
+[export %1]
+%endmacro
+%imacro import 1+.nolist
+[import %1]
+%endmacro
+%macro __?NASM_CDecl?__ 1
+%endmacro
diff --git a/vere/ext/nasm/output/pecoff.h b/vere/ext/nasm/output/pecoff.h
new file mode 100644
index 0000000..b99bed0
--- /dev/null
+++ b/vere/ext/nasm/output/pecoff.h
@@ -0,0 +1,542 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef PECOFF_H
+#define PECOFF_H
+
+/*
+ * Microsoft Portable Executable and Common Object
+ * File Format Specification
+ *
+ * Revision 8.1 – February 15, 2008
+ */
+
+/*
+ * Machine types
+ */
+#define IMAGE_FILE_MACHINE_UNKNOWN      0x0000
+#define IMAGE_FILE_MACHINE_AM33         0x01d3
+#define IMAGE_FILE_MACHINE_AMD64        0x8664
+#define IMAGE_FILE_MACHINE_EBC          0x0ebc
+#define IMAGE_FILE_MACHINE_M32R         0x9041
+#define IMAGE_FILE_MACHINE_ALPHA        0x0184
+#define IMAGE_FILE_MACHINE_ARM          0x01c0
+#define IMAGE_FILE_MACHINE_ALPHA64      0x0284
+#define IMAGE_FILE_MACHINE_I386         0x014c
+#define IMAGE_FILE_MACHINE_IA64         0x0200
+#define IMAGE_FILE_MACHINE_M68K         0x0268
+#define IMAGE_FILE_MACHINE_MIPS16       0x0266
+#define IMAGE_FILE_MACHINE_MIPSFPU      0x0366
+#define IMAGE_FILE_MACHINE_MIPSFPU16    0x0466
+#define IMAGE_FILE_MACHINE_POWERPC      0x01f0
+#define IMAGE_FILE_MACHINE_POWERPCFP    0x01f1
+#define IMAGE_FILE_MACHINE_R3000        0x0162
+#define IMAGE_FILE_MACHINE_R4000        0x0166
+#define IMAGE_FILE_MACHINE_R10000       0x0168
+#define IMAGE_FILE_MACHINE_SH3          0x01a2
+#define IMAGE_FILE_MACHINE_SH3DSP       0x01a3
+#define IMAGE_FILE_MACHINE_SH4          0x01a6
+#define IMAGE_FILE_MACHINE_SH5          0x01a8
+#define IMAGE_FILE_MACHINE_THUMB        0x01c2
+#define IMAGE_FILE_MACHINE_WCEMIPSV2    0x0169
+#define IMAGE_FILE_MACHINE_MASK         0xffff
+
+/*
+ * Characteristics
+ */
+#define IMAGE_FILE_RELOCS_STRIPPED              0x0001
+#define IMAGE_FILE_EXECUTABLE_IMAGE             0x0002
+#define IMAGE_FILE_LINE_NUMS_STRIPPED           0x0004
+#define IMAGE_FILE_LOCAL_SYMS_STRIPPED          0x0008
+#define IMAGE_FILE_AGGRESSIVE_WS_TRIM           0x0010
+#define IMAGE_FILE_LARGE_ADDRESS_AWARE          0x0020
+#define IMAGE_FILE_BYTES_REVERSED_LO            0x0080
+#define IMAGE_FILE_32BIT_MACHINE                0x0100
+#define IMAGE_FILE_DEBUG_STRIPPED               0x0200
+#define IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP      0x0400
+#define IMAGE_FILE_NET_RUN_FROM_SWAP            0x0800
+#define IMAGE_FILE_SYSTEM                       0x1000
+#define IMAGE_FILE_DLL                          0x2000
+#define IMAGE_FILE_UP_SYSTEM_ONLY               0x4000
+#define IMAGE_FILE_BYTES_REVERSED_HI            0x8000
+
+/*
+ * Windows subsystem
+ */
+#define IMAGE_SUBSYSTEM_UNKNOWN                 0
+#define IMAGE_SUBSYSTEM_NATIVE                  1
+#define IMAGE_SUBSYSTEM_WINDOWS_GUI             2
+#define IMAGE_SUBSYSTEM_WINDOWS_CUI             3
+#define IMAGE_SUBSYSTEM_POSIX_CUI               7
+#define IMAGE_SUBSYSTEM_WINDOWS_CE_GUI          9
+#define IMAGE_SUBSYSTEM_EFI_APPLICATION         10
+#define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11
+#define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER      12
+#define IMAGE_SUBSYSTEM_EFI_ROM                 13
+#define IMAGE_SUBSYSTEM_XBOX                    14
+
+/*
+ * DLL characteristics
+ */
+#define IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE          0x0040
+#define IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY       0x0080
+#define IMAGE_DLL_CHARACTERISTICS_NX_COMPAT             0x0100
+#define IMAGE_DLLCHARACTERISTICS_NO_ISOLATION           0x0200
+#define IMAGE_DLLCHARACTERISTICS_NO_SEH                 0x0400
+#define IMAGE_DLLCHARACTERISTICS_NO_BIND                0x0800
+#define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER             0x2000
+#define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE  0x8000
+
+/*
+ * Section flags
+ */
+#define IMAGE_SCN_TYPE_REG                      0x00000000
+#define IMAGE_SCN_TYPE_DSECT                    0x00000001
+#define IMAGE_SCN_TYPE_NOLOAD                   0x00000002
+#define IMAGE_SCN_TYPE_GROUP                    0x00000004
+#define IMAGE_SCN_TYPE_NO_PAD                   0x00000008
+#define IMAGE_SCN_TYPE_COPY                     0x00000010
+
+#define IMAGE_SCN_CNT_CODE                      0x00000020
+#define IMAGE_SCN_CNT_INITIALIZED_DATA          0x00000040
+#define IMAGE_SCN_CNT_UNINITIALIZED_DATA        0x00000080
+
+#define IMAGE_SCN_LNK_OTHER                     0x00000100
+#define IMAGE_SCN_LNK_INFO                      0x00000200
+#define IMAGE_SCN_TYPE_OVER                     0x00000400
+#define IMAGE_SCN_LNK_REMOVE                    0x00000800
+#define IMAGE_SCN_LNK_COMDAT                    0x00001000
+
+#define IMAGE_SCN_MAX_RELOC			0xffff
+
+#define IMAGE_SCN_MEM_FARDATA                   0x00008000
+#define IMAGE_SCN_MEM_PURGEABLE                 0x00020000
+#define IMAGE_SCN_MEM_16BIT                     0x00020000
+#define IMAGE_SCN_MEM_LOCKED                    0x00040000
+#define IMAGE_SCN_MEM_PRELOAD                   0x00080000
+
+#define IMAGE_SCN_ALIGN_1BYTES                  0x00100000
+#define IMAGE_SCN_ALIGN_2BYTES                  0x00200000
+#define IMAGE_SCN_ALIGN_4BYTES                  0x00300000
+#define IMAGE_SCN_ALIGN_8BYTES                  0x00400000
+#define IMAGE_SCN_ALIGN_16BYTES                 0x00500000
+#define IMAGE_SCN_ALIGN_32BYTES                 0x00600000
+#define IMAGE_SCN_ALIGN_64BYTES                 0x00700000
+#define IMAGE_SCN_ALIGN_128BYTES                0x00800000
+#define IMAGE_SCN_ALIGN_256BYTES                0x00900000
+#define IMAGE_SCN_ALIGN_512BYTES                0x00a00000
+#define IMAGE_SCN_ALIGN_1024BYTES               0x00b00000
+#define IMAGE_SCN_ALIGN_2048BYTES               0x00c00000
+#define IMAGE_SCN_ALIGN_4096BYTES               0x00d00000
+#define IMAGE_SCN_ALIGN_8192BYTES               0x00e00000
+#define IMAGE_SCN_ALIGN_MASK                    0x00f00000
+
+#define IMAGE_SCN_LNK_NRELOC_OVFL               0x01000000
+#define IMAGE_SCN_MEM_DISCARDABLE               0x02000000
+#define IMAGE_SCN_MEM_NOT_CACHED                0x04000000
+#define IMAGE_SCN_MEM_NOT_PAGED                 0x08000000
+#define IMAGE_SCN_MEM_SHARED                    0x10000000
+#define IMAGE_SCN_MEM_EXECUTE                   0x20000000
+#define IMAGE_SCN_MEM_READ                      0x40000000
+#define IMAGE_SCN_MEM_WRITE                     0x80000000
+
+/*
+ * Relocation type x86-64
+ */
+#define IMAGE_REL_AMD64_ABSOLUTE        0x0000
+#define IMAGE_REL_AMD64_ADDR64          0x0001
+#define IMAGE_REL_AMD64_ADDR32          0x0002
+#define IMAGE_REL_AMD64_ADDR32NB        0x0003
+#define IMAGE_REL_AMD64_REL32           0x0004
+#define IMAGE_REL_AMD64_REL32_1         0x0005
+#define IMAGE_REL_AMD64_REL32_2         0x0006
+#define IMAGE_REL_AMD64_REL32_3         0x0007
+#define IMAGE_REL_AMD64_REL32_4         0x0008
+#define IMAGE_REL_AMD64_REL32_5         0x0009
+#define IMAGE_REL_AMD64_SECTION         0x000a
+#define IMAGE_REL_AMD64_SECREL          0x000b
+#define IMAGE_REL_AMD64_SECREL7         0x000c
+#define IMAGE_REL_AMD64_TOKEN           0x000d
+#define IMAGE_REL_AMD64_SREL32          0x000e
+#define IMAGE_REL_AMD64_PAIR            0x000f
+#define IMAGE_REL_AMD64_SSPAN32         0x0010
+
+/*
+ * Relocation types i386
+ */
+#define IMAGE_REL_I386_ABSOLUTE         0x0000
+#define IMAGE_REL_I386_DIR16            0x0001
+#define IMAGE_REL_I386_REL16            0x0002
+#define IMAGE_REL_I386_DIR32            0x0006
+#define IMAGE_REL_I386_DIR32NB          0x0007
+#define IMAGE_REL_I386_SEG12            0x0009
+#define IMAGE_REL_I386_SECTION          0x000a
+#define IMAGE_REL_I386_SECREL           0x000b
+#define IMAGE_REL_I386_TOKEN            0x000c
+#define IMAGE_REL_I386_SECREL7          0x000d
+#define IMAGE_REL_I386_REL32            0x0014
+
+/*
+ * Relocation types ARM
+ */
+#define IMAGE_REL_ARM_ABSOLUTE          0x0000
+#define IMAGE_REL_ARM_ADDR32            0x0001
+#define IMAGE_REL_ARM_ADDR32NB          0x0002
+#define IMAGE_REL_ARM_BRANCH24          0x0003
+#define IMAGE_REL_ARM_BRANCH11          0x0004
+#define IMAGE_REL_ARM_SECTION           0x000e
+#define IMAGE_REL_ARM_SECREL            0x000f
+
+/*
+ * Relocation types Hitachi SuperH
+ */
+#define IMAGE_REL_SH3_ABSOLUTE          0x0000
+#define IMAGE_REL_SH3_DIRECT16          0x0001
+#define IMAGE_REL_SH3_DIRECT32          0x0002
+#define IMAGE_REL_SH3_DIRECT8           0x0003
+#define IMAGE_REL_SH3_DIRECT8_WORD      0x0004
+#define IMAGE_REL_SH3_DIRECT8_LONG      0x0005
+#define IMAGE_REL_SH3_DIRECT4           0x0006
+#define IMAGE_REL_SH3_DIRECT4_WORD      0x0007
+#define IMAGE_REL_SH3_DIRECT4_LONG      0x0008
+#define IMAGE_REL_SH3_PCREL8_WORD       0x0009
+#define IMAGE_REL_SH3_PCREL8_LONG       0x000a
+#define IMAGE_REL_SH3_PCREL12_WORD      0x000b
+#define IMAGE_REL_SH3_STARTOF_SECTION   0x000c
+#define IMAGE_REL_SH3_SIZEOF_SECTION    0x000d
+#define IMAGE_REL_SH3_SECTION           0x000e
+#define IMAGE_REL_SH3_SECREL            0x000f
+#define IMAGE_REL_SH3_DIRECT32_NB       0x0010
+#define IMAGE_REL_SH3_GPREL4_LONG       0x0011
+#define IMAGE_REL_SH3_TOKEN             0x0012
+#define IMAGE_REL_SHM_PCRELPT           0x0013
+#define IMAGE_REL_SHM_REFLO             0x0014
+#define IMAGE_REL_SHM_REFHALF           0x0015
+#define IMAGE_REL_SHM_RELLO             0x0016
+#define IMAGE_REL_SHM_RELHALF           0x0017
+#define IMAGE_REL_SHM_PAIR              0x0018
+#define IMAGE_REL_SHM_NOMODE            0x8000
+
+/*
+ * Relocation types IBM PowerPC processors
+ */
+#define IMAGE_REL_PPC_ABSOLUTE          0x0000
+#define IMAGE_REL_PPC_ADDR64            0x0001
+#define IMAGE_REL_PPC_ADDR32            0x0002
+#define IMAGE_REL_PPC_ADDR24            0x0003
+#define IMAGE_REL_PPC_ADDR16            0x0004
+#define IMAGE_REL_PPC_ADDR14            0x0005
+#define IMAGE_REL_PPC_REL24             0x0006
+#define IMAGE_REL_PPC_REL14             0x0007
+#define IMAGE_REL_PPC_ADDR32NB          0x000a
+#define IMAGE_REL_PPC_SECREL            0x000b
+#define IMAGE_REL_PPC_SECTION           0x000c
+#define IMAGE_REL_PPC_SECREL16          0x000f
+#define IMAGE_REL_PPC_REFHI             0x0010
+#define IMAGE_REL_PPC_REFLO             0x0011
+#define IMAGE_REL_PPC_PAIR              0x0012
+#define IMAGE_REL_PPC_SECRELLO          0x0013
+#define IMAGE_REL_PPC_GPREL             0x0015
+#define IMAGE_REL_PPC_TOKEN             0x0016
+
+/*
+ * Relocation types Intel Itanium processor family (IPF)
+ */
+#define IMAGE_REL_IA64_ABSOLUTE         0x0000
+#define IMAGE_REL_IA64_IMM14            0x0001
+#define IMAGE_REL_IA64_IMM22            0x0002
+#define IMAGE_REL_IA64_IMM64            0x0003
+#define IMAGE_REL_IA64_DIR32            0x0004
+#define IMAGE_REL_IA64_DIR64            0x0005
+#define IMAGE_REL_IA64_PCREL21B         0x0006
+#define IMAGE_REL_IA64_PCREL21M         0x0007
+#define IMAGE_REL_IA64_PCREL21F         0x0008
+#define IMAGE_REL_IA64_GPREL22          0x0009
+#define IMAGE_REL_IA64_LTOFF22          0x000a
+#define IMAGE_REL_IA64_SECTION          0x000b
+#define IMAGE_REL_IA64_SECREL22         0x000c
+#define IMAGE_REL_IA64_SECREL64I        0x000d
+#define IMAGE_REL_IA64_SECREL32         0x000e
+#define IMAGE_REL_IA64_DIR32NB          0x0010
+#define IMAGE_REL_IA64_SREL14           0x0011
+#define IMAGE_REL_IA64_SREL22           0x0012
+#define IMAGE_REL_IA64_SREL32           0x0013
+#define IMAGE_REL_IA64_UREL32           0x0014
+#define IMAGE_REL_IA64_PCREL60X         0x0015
+#define IMAGE_REL_IA64_PCREL 60B        0x0016
+#define IMAGE_REL_IA64_PCREL60F         0x0017
+#define IMAGE_REL_IA64_PCREL60I         0x0018
+#define IMAGE_REL_IA64_PCREL60M         0x0019
+#define IMAGE_REL_IA64_IMMGPREL64       0x001a
+#define IMAGE_REL_IA64_TOKEN            0x001b
+#define IMAGE_REL_IA64_GPREL32          0x001c
+#define IMAGE_REL_IA64_ADDEND           0x001f
+
+/*
+ * Relocation types MIPS Processors
+ */
+#define IMAGE_REL_MIPS_ABSOLUTE         0x0000
+#define IMAGE_REL_MIPS_REFHALF          0x0001
+#define IMAGE_REL_MIPS_REFWORD          0x0002
+#define IMAGE_REL_MIPS_JMPADDR          0x0003
+#define IMAGE_REL_MIPS_REFHI            0x0004
+#define IMAGE_REL_MIPS_REFLO            0x0005
+#define IMAGE_REL_MIPS_GPREL            0x0006
+#define IMAGE_REL_MIPS_LITERAL          0x0007
+#define IMAGE_REL_MIPS_SECTION          0x000a
+#define IMAGE_REL_MIPS_SECREL           0x000b
+#define IMAGE_REL_MIPS_SECRELLO         0x000c
+#define IMAGE_REL_MIPS_SECRELHI         0x000d
+#define IMAGE_REL_MIPS_JMPADDR16        0x0010
+#define IMAGE_REL_MIPS_REFWORDNB        0x0022
+#define IMAGE_REL_MIPS_PAIR             0x0025
+
+/*
+ * Relocation types Mitsubishi M32R
+ */
+#define IMAGE_REL_M32R_ABSOLUTE         0x0000
+#define IMAGE_REL_M32R_ADDR32           0x0001
+#define IMAGE_REL_M32R_ADDR32NB         0x0002
+#define IMAGE_REL_M32R_ADDR24           0x0003
+#define IMAGE_REL_M32R_GPREL16          0x0004
+#define IMAGE_REL_M32R_PCREL24          0x0005
+#define IMAGE_REL_M32R_PCREL16          0x0006
+#define IMAGE_REL_M32R_PCREL8           0x0007
+#define IMAGE_REL_M32R_REFHALF          0x0008
+#define IMAGE_REL_M32R_REFHI            0x0009
+#define IMAGE_REL_M32R_REFLO            0x000a
+#define IMAGE_REL_M32R_PAIR             0x000b
+#define IMAGE_REL_M32R_SECTION          0x000c
+#define IMAGE_REL_M32R_SECREL           0x000d
+#define IMAGE_REL_M32R_TOKEN            0x000e
+
+/*
+ * Section number values
+ */
+#define IMAGE_SYM_UNDEFINED      0
+#define IMAGE_SYM_ABSOLUTE      -1
+#define IMAGE_SYM_DEBUG         -2
+
+/*
+ * Type representation
+ */
+#define IMAGE_SYM_TYPE_NULL             0
+#define IMAGE_SYM_TYPE_VOID             1
+#define IMAGE_SYM_TYPE_CHAR             2
+#define IMAGE_SYM_TYPE_SHORT            3
+#define IMAGE_SYM_TYPE_INT              4
+#define IMAGE_SYM_TYPE_LONG             5
+#define IMAGE_SYM_TYPE_FLOAT            6
+#define IMAGE_SYM_TYPE_DOUBLE           7
+#define IMAGE_SYM_TYPE_STRUCT           8
+#define IMAGE_SYM_TYPE_UNION            9
+#define IMAGE_SYM_TYPE_ENUM             10
+#define IMAGE_SYM_TYPE_MOE              11
+#define IMAGE_SYM_TYPE_BYTE             12
+#define IMAGE_SYM_TYPE_WORD             13
+#define IMAGE_SYM_TYPE_UINT             14
+#define IMAGE_SYM_TYPE_DWORD            15
+
+#define IMAGE_SYM_DTYPE_NULL            0
+#define IMAGE_SYM_DTYPE_POINTER         1
+#define IMAGE_SYM_DTYPE_FUNCTION        2
+#define IMAGE_SYM_DTYPE_ARRAY           3
+
+/*
+ * Storage class
+ */
+#define IMAGE_SYM_CLASS_END_OF_FUNCTION         -1
+#define IMAGE_SYM_CLASS_NULL                    0
+#define IMAGE_SYM_CLASS_AUTOMATIC               1
+#define IMAGE_SYM_CLASS_EXTERNAL                2
+#define IMAGE_SYM_CLASS_STATIC                  3
+#define IMAGE_SYM_CLAS S_REGISTER               4
+#define IMAGE_SYM_CLASS_EXTERNAL_DEF            5
+#define IMAGE_SYM_CLASS_LABEL                   6
+#define IMAGE_SYM_CLASS_UNDEFINED_LABEL         7
+#define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT        8
+#define IMAGE_SYM_CLASS_ARGUMENT                9
+#define IMAGE_SYM_CLASS_STRUCT_TAG              10
+#define IMAGE_SYM_CLASS_MEMBER_OF_UNION         11
+#define IMAGE_SYM_CLASS_UNION_TAG               12
+#define IMAGE_SYM_CLASS_TYPE_DEFINITION         13
+#define IMAGE_SYM_CLASS_UNDEFINED_STATIC        14
+#define IMAGE_SYM_CLASS_ENUM_TAG                15
+#define IMAGE_SYM_CLASS_MEMBER_OF_ENUM          16
+#define IMAGE_SYM_CLASS_REGISTER_PARAM          17
+#define IMAGE_SYM_CLASS_BIT_FIELD               18
+#define IMAGE_SYM_CLASS_BLOCK                   100
+#define IMAGE_SYM_CLASS_FUNCTION                101
+#define IMAGE_SYM_CLASS_END_OF_STRUCT           102
+#define IMAGE_SYM_CLASS_FILE                    103
+#define IMAGE_SYM_CLASS_SECTION                 104
+#define IMAGE_SYM_CLASS_WEAK_EXTERNAL           105
+#define IMAGE_SYM_CLASS_CLR_TOKEN               107
+
+/*
+ * COMDAT sections
+ */
+#define IMAGE_COMDAT_SELECT_NODUPLICATES        1
+#define IMAGE_COMDAT_SELECT_ANY                 2
+#define IMAGE_COMDAT_SELECT_SAME_SIZE           3
+#define IMAGE_COMDAT_SELECT_EXACT_MATCH         4
+#define IMAGE_COMDAT_SELECT_ASSOCIATIVE         5
+#define IMAGE_COMDAT_SELECT_LARGEST             6
+
+/*
+ * Attribute certificate table
+ */
+#define WIN_CERT_REVISION_1_0           0x0100
+#define WIN_CERT_REVISION_2_0           0x0200
+#define WIN_CERT_TYPE_X509              0x0001
+#define WIN_CERT_TYPE_PKCS_SIGNED_DATA  0x0002
+#define WIN_CERT_TYPE_RESERVED_1        0x0003
+#define WIN_CERT_TYPE_TS_STACK_SIGNED   0x0004
+
+/*
+ * Debug type
+ */
+#define IMAGE_DEBUG_TYPE_UNKNOWN        0
+#define IMAGE_DEBUG_TYPE_COFF           1
+#define IMAGE_DEBUG_TYPE_CODEVIEW       2
+#define IMAGE_DEBUG_TYPE_FPO            3
+#define IMAGE_DEBUG_TYPE_MISC           4
+#define IMAGE_DEBUG_TYPE_EXCEPTION      5
+#define IMAGE_DEBUG_TYPE_FIXUP          6
+#define IMAGE_DEBUG_TYPE_OMAP_TO_SRC    7
+#define IMAGE_DEBUG_TYPE_OMAP_FROM_SRC  8
+#define IMAGE_DEBUG_TYP E_BORLAND       9
+#define IMAGE_DEBUG_TYPE_RESERVED10     10
+#define IMAGE_DEBUG_TYPE_CLSID          11
+
+/*
+ * Base relocation types
+ */
+#define IMAGE_REL_BASED_ABSOLUTE        0
+#define IMAGE_REL_BASED_HIGH            1
+#define IMAGE_REL_BASED_LOW             2
+#define IMAGE_REL_BASED_HIGHLOW         3
+#define IMAGE_REL_BASED_HIGHADJ         4
+#define IMAGE_REL_BASED_MIPS_JMPADDR    5
+#define IMAGE_REL_BASED_MIPS_JMPADDR16  9
+#define IMAGE_REL_BASED_DIR64           10
+
+/*
+ * TLS callback functions
+ */
+#define DLL_PROCESS_ATTACH      1
+#define DLL_THREAD_ATTACH       2
+#define DLL_THREAD_DETACH       3
+#define DLL_PROCESS_DETACH      0
+
+/*
+ * Import Type
+ */
+#define IMPORT_CODE     0
+#define IMPORT_DATA     1
+#define IMPORT_CONST    2
+
+/*
+ * Import name type
+ */
+#define IMPORT_ORDINAL          0
+#define IMPORT_NAME             1
+#define IMPORT_NAME_NOPREFIX    2
+#define IMPORT_NAME_UNDECORATE  3
+
+struct coff_Section {
+    struct SAA *data;
+    uint32_t len;
+    int nrelocs;
+    int32_t index;
+    struct coff_Reloc *head, **tail;
+    uint32_t flags;             /* section flags */
+    uint32_t align_flags;       /* user-specified alignment flags */
+    uint32_t sectalign_flags;   /* minimum alignment from sectalign */
+    char *name;
+    int32_t namepos;            /* Offset of name into the strings table */
+    int32_t pos, relpos;
+    int64_t pass_last_seen;
+
+    /* comdat-related members */
+    char *comdat_name;
+    uint32_t checksum;          /* set only for comdat sections */
+    int8_t comdat_selection;
+    int8_t comdat_symbol;       /* is the "comdat name" in symbol table? */
+    int32_t comdat_associated;  /* associated section for selection==5 */
+};
+
+struct coff_Reloc {
+    struct coff_Reloc *next;
+    int32_t address;            /* relative to _start_ of section */
+    int32_t symbol;             /* symbol number */
+    enum {
+        SECT_SYMBOLS,
+        ABS_SYMBOL,
+        REAL_SYMBOLS
+    } symbase;                  /* relocation for symbol number :) */
+    int16_t type;
+};
+
+struct coff_Symbol {
+    char name[9];
+    int32_t strpos;             /* string table position of name */
+    int32_t value;              /* address, or COMMON variable size */
+    int section;                /* section number where it's defined
+                                 * - in COFF codes, not NASM codes */
+    bool is_global;             /* is it a global symbol or not? */
+    int16_t type;               /* 0 - notype, 0x20 - function */
+    int32_t namlen;             /* full name length */
+};
+
+struct coff_DebugInfo {
+    int32_t segto;
+    int32_t seg;
+    uint64_t size;
+    struct coff_Section *section;
+};
+
+extern struct coff_Section **coff_sects;
+extern int coff_nsects;
+extern struct SAA *coff_syms;
+extern uint32_t coff_nsyms;
+extern struct SAA *coff_strs;
+extern bool win32, win64;
+
+extern char coff_infile[FILENAME_MAX];
+extern char coff_outfile[FILENAME_MAX];
+
+extern int coff_make_section(char *name, uint32_t flags);
+
+
+#endif /* PECOFF_H */
diff --git a/vere/ext/nasm/output/stabs.h b/vere/ext/nasm/output/stabs.h
new file mode 100644
index 0000000..dbc4986
--- /dev/null
+++ b/vere/ext/nasm/output/stabs.h
@@ -0,0 +1,150 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef STABS_H_
+#define STABS_H_
+
+#include "nctype.h"
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "nasm.h"
+
+/* offsets */
+enum stab_offsets {
+	STAB_strdxoff	= 0,
+	STAB_typeoff	= 4,
+	STAB_otheroff	= 5,
+	STAB_descoff	= 6,
+	STAB_valoff	= 8,
+	STAB_stabsize	= 12
+};
+
+/* stab/non-stab types */
+enum stab_types {
+	N_UNDF		= 0x00, /* Undefined symbol */
+	N_EXT		= 0x01, /* External symbol */
+	N_ABS		= 0x02, /* Absolute symbol */
+	N_ABS_EXT	= 0x03, /* Absolute external symbol */
+	N_TEXT		= 0x04, /* Symbol in text segment */
+	N_TEXT_EXT	= 0x05, /* Symbol in external text segment */
+	N_DATA		= 0x06,
+	N_DATA_EXT	= 0x07,
+	N_BSS		= 0x08,
+	N_BSS_EXT	= 0x09,
+	N_INDR		= 0x0a,
+	N_FN_SEQ	= 0x0c, /* N_FN from Sequent compilers */
+	N_WEAKU		= 0x0d, /* Weak undefined symbol */
+	N_WEAKA		= 0x0e, /* Weak absolute symbl */
+	N_WEAKT		= 0x0f, /* Weak text symbol */
+	N_WEAKD		= 0x10, /* Weak data symbol */
+	N_WEAKB		= 0x11, /* Weak bss symbol */
+	N_COMM		= 0x12, /* Common symbol */
+	N_SETA		= 0x14, /* Absolute set element symbol */
+	N_SETA_EXT	= 0x15,
+	N_SETT		= 0x16, /* Text set element symbol */
+	N_SETT_EXT	= 0x17,
+	N_SETD		= 0x18, /* Data set element symbol */
+	N_SETD_EXT	= 0x19,
+	N_SETB		= 0x1a, /* BSS set element symbol */
+	N_SETB_EXT	= 0x1b,
+	N_SETV		= 0x1c, /* Pointer to set vector in data area */
+	N_SETV_EXT	= 0x1d,
+	N_WARNING	= 0x1e, /* Warning symbol */
+	N_FN		= 0x1f, /* Filename of .o file */
+	N_GSYM		= 0x20, /* Global variable */
+	N_FNAME		= 0x22, /* Function name for BSD Fortran */
+	N_FUN		= 0x24, /* Function name or text segment variable for C */
+	N_STSYM		= 0x26, /* Data-segment variable with internal linkage */
+	N_LCSYM		= 0x28, /* BSS-segment variable with internal linkage */
+	N_MAIN		= 0x2a, /* Name of main routine */
+	N_ROSYM		= 0x2c, /* Read-only data symbols */
+	N_BNSYM		= 0x2e, /* The beginning of a relocatable function block */
+	N_PC		= 0x30, /* Global symbol in Pascal */
+	N_NSYMS		= 0x32, /* Number of symbols */
+	N_NOMAP		= 0x34, /* No DST map for sym */
+	N_OBJ		= 0x38, /* Like N_SO, but for the object file */
+	N_OPT		= 0x3c, /* Options for the debugger */
+	N_RSYM		= 0x40, /* Register variable */
+	N_M2C		= 0x42, /* Modula-2 compilation unit */
+	N_SLINE		= 0x44, /* Line number in text segment */
+	N_DSLINE	= 0x46, /* Line number in data segment */
+	N_BSLINE	= 0x48, /* Line number in bss segment */
+	N_BROWS		= 0x48, /* Sun's source-code browser stabs */
+	N_DEFD		= 0x4a, /* GNU Modula-2 definition module dependency */
+	N_FLINE		= 0x4c, /* Function start/body/end line numbers */
+	N_ENSYM		= 0x4e, /* This tells the end of a relocatable function */
+	N_EHDECL	= 0x50, /* GNU C++ exception variable */
+	N_MOD2		= 0x50, /* Modula2 info "for imc" */
+	N_CATCH		= 0x54, /* GNU C++ `catch' clause */
+	N_SSYM		= 0x60, /* Structure or union element */
+	N_ENDM		= 0x62, /* Last stab emitted for module */
+	N_SO		= 0x64, /* ID for main source file */
+	N_OSO		= 0x66, /* Apple: This is the stab that associated the .o file  */
+	N_ALIAS		= 0x6c, /* SunPro F77: Name of alias */
+	N_LSYM		= 0x80, /* Automatic variable in the stack */
+	N_BINCL		= 0x82, /* Beginning of an include file */
+	N_SOL		= 0x84, /* ID for sub-source file */
+	N_PSYM		= 0xa0, /* Parameter variable */
+	N_EINCL		= 0xa2, /* End of an include file */
+	N_ENTRY		= 0xa4, /* Alternate entry point */
+	N_LBRAC		= 0xc0, /* Beginning of lexical block */
+	N_EXCL		= 0xc2, /* Place holder for deleted include file */
+	N_SCOPE		= 0xc4, /* Modula-2 scope information */
+	N_PATCH		= 0xd0, /* Solaris2: Patch Run Time Checker */
+	N_RBRAC		= 0xe0, /* End of a lexical block */
+	N_BCOMM		= 0xe2, /* Begin named common block */
+	N_ECOMM		= 0xe4, /* End named common block */
+	N_ECOML		= 0xe8, /* Member of a common block */
+	N_WITH		= 0xea, /* Solaris2: Pascal "with" statement */
+	N_NBTEXT	= 0xf0,
+	N_NBDATA	= 0xf2,
+	N_NBBSS		= 0xf4,
+	N_NBSTS		= 0xf6,
+	N_NBLCS		= 0xf8,
+	N_LENG		= 0xfe  /* Second symbol entry whih a length-value for the preceding entry */
+};
+
+enum stab_source_file {
+	N_SO_AS		= 0x01,
+	N_SO_C		= 0x02,
+	N_SO_ANSI_C	= 0x03,
+	N_SO_CC		= 0x04,
+	N_SO_FORTRAN	= 0x05,
+	N_SO_PASCAL	= 0x06,
+	N_SO_FORTRAN90	= 0x07,
+	N_SO_OBJC	= 0x32,
+	N_SO_OBJCPLUS	= 0x33
+};
+
+#endif /* STABS_H_ */
diff --git a/vere/ext/nasm/perllib/crc64.ph b/vere/ext/nasm/perllib/crc64.ph
new file mode 100644
index 0000000..30a4775
--- /dev/null
+++ b/vere/ext/nasm/perllib/crc64.ph
@@ -0,0 +1,158 @@
+# -*- perl -*-
+#
+# Pure Perl implementation of the same CRC64 implementation used
+# elsewhere in NASM.
+#
+# Note: Perl may have 32- or 64-bit integers; we need to handle both
+# without overflowing into floating point (yuck), so handle them as
+# pairs of 32-bit numbers.  Ordering is BIGENDIAN.
+#
+
+@crc64_tab = (
+    [0x00000000, 0x00000000], [0x7ad870c8, 0x30358979],
+    [0xf5b0e190, 0x606b12f2], [0x8f689158, 0x505e9b8b],
+    [0xc038e573, 0x9841b68f], [0xbae095bb, 0xa8743ff6],
+    [0x358804e3, 0xf82aa47d], [0x4f50742b, 0xc81f2d04],
+    [0xab28ecb4, 0x6814fe75], [0xd1f09c7c, 0x5821770c],
+    [0x5e980d24, 0x087fec87], [0x24407dec, 0x384a65fe],
+    [0x6b1009c7, 0xf05548fa], [0x11c8790f, 0xc060c183],
+    [0x9ea0e857, 0x903e5a08], [0xe478989f, 0xa00bd371],
+    [0x7d08ff3b, 0x88be6f81], [0x07d08ff3, 0xb88be6f8],
+    [0x88b81eab, 0xe8d57d73], [0xf2606e63, 0xd8e0f40a],
+    [0xbd301a48, 0x10ffd90e], [0xc7e86a80, 0x20ca5077],
+    [0x4880fbd8, 0x7094cbfc], [0x32588b10, 0x40a14285],
+    [0xd620138f, 0xe0aa91f4], [0xacf86347, 0xd09f188d],
+    [0x2390f21f, 0x80c18306], [0x594882d7, 0xb0f40a7f],
+    [0x1618f6fc, 0x78eb277b], [0x6cc08634, 0x48deae02],
+    [0xe3a8176c, 0x18803589], [0x997067a4, 0x28b5bcf0],
+    [0xfa11fe77, 0x117cdf02], [0x80c98ebf, 0x2149567b],
+    [0x0fa11fe7, 0x7117cdf0], [0x75796f2f, 0x41224489],
+    [0x3a291b04, 0x893d698d], [0x40f16bcc, 0xb908e0f4],
+    [0xcf99fa94, 0xe9567b7f], [0xb5418a5c, 0xd963f206],
+    [0x513912c3, 0x79682177], [0x2be1620b, 0x495da80e],
+    [0xa489f353, 0x19033385], [0xde51839b, 0x2936bafc],
+    [0x9101f7b0, 0xe12997f8], [0xebd98778, 0xd11c1e81],
+    [0x64b11620, 0x8142850a], [0x1e6966e8, 0xb1770c73],
+    [0x8719014c, 0x99c2b083], [0xfdc17184, 0xa9f739fa],
+    [0x72a9e0dc, 0xf9a9a271], [0x08719014, 0xc99c2b08],
+    [0x4721e43f, 0x0183060c], [0x3df994f7, 0x31b68f75],
+    [0xb29105af, 0x61e814fe], [0xc8497567, 0x51dd9d87],
+    [0x2c31edf8, 0xf1d64ef6], [0x56e99d30, 0xc1e3c78f],
+    [0xd9810c68, 0x91bd5c04], [0xa3597ca0, 0xa188d57d],
+    [0xec09088b, 0x6997f879], [0x96d17843, 0x59a27100],
+    [0x19b9e91b, 0x09fcea8b], [0x636199d3, 0x39c963f2],
+    [0xdf7adabd, 0x7a6e2d6f], [0xa5a2aa75, 0x4a5ba416],
+    [0x2aca3b2d, 0x1a053f9d], [0x50124be5, 0x2a30b6e4],
+    [0x1f423fce, 0xe22f9be0], [0x659a4f06, 0xd21a1299],
+    [0xeaf2de5e, 0x82448912], [0x902aae96, 0xb271006b],
+    [0x74523609, 0x127ad31a], [0x0e8a46c1, 0x224f5a63],
+    [0x81e2d799, 0x7211c1e8], [0xfb3aa751, 0x42244891],
+    [0xb46ad37a, 0x8a3b6595], [0xceb2a3b2, 0xba0eecec],
+    [0x41da32ea, 0xea507767], [0x3b024222, 0xda65fe1e],
+    [0xa2722586, 0xf2d042ee], [0xd8aa554e, 0xc2e5cb97],
+    [0x57c2c416, 0x92bb501c], [0x2d1ab4de, 0xa28ed965],
+    [0x624ac0f5, 0x6a91f461], [0x1892b03d, 0x5aa47d18],
+    [0x97fa2165, 0x0afae693], [0xed2251ad, 0x3acf6fea],
+    [0x095ac932, 0x9ac4bc9b], [0x7382b9fa, 0xaaf135e2],
+    [0xfcea28a2, 0xfaafae69], [0x8632586a, 0xca9a2710],
+    [0xc9622c41, 0x02850a14], [0xb3ba5c89, 0x32b0836d],
+    [0x3cd2cdd1, 0x62ee18e6], [0x460abd19, 0x52db919f],
+    [0x256b24ca, 0x6b12f26d], [0x5fb35402, 0x5b277b14],
+    [0xd0dbc55a, 0x0b79e09f], [0xaa03b592, 0x3b4c69e6],
+    [0xe553c1b9, 0xf35344e2], [0x9f8bb171, 0xc366cd9b],
+    [0x10e32029, 0x93385610], [0x6a3b50e1, 0xa30ddf69],
+    [0x8e43c87e, 0x03060c18], [0xf49bb8b6, 0x33338561],
+    [0x7bf329ee, 0x636d1eea], [0x012b5926, 0x53589793],
+    [0x4e7b2d0d, 0x9b47ba97], [0x34a35dc5, 0xab7233ee],
+    [0xbbcbcc9d, 0xfb2ca865], [0xc113bc55, 0xcb19211c],
+    [0x5863dbf1, 0xe3ac9dec], [0x22bbab39, 0xd3991495],
+    [0xadd33a61, 0x83c78f1e], [0xd70b4aa9, 0xb3f20667],
+    [0x985b3e82, 0x7bed2b63], [0xe2834e4a, 0x4bd8a21a],
+    [0x6debdf12, 0x1b863991], [0x1733afda, 0x2bb3b0e8],
+    [0xf34b3745, 0x8bb86399], [0x8993478d, 0xbb8deae0],
+    [0x06fbd6d5, 0xebd3716b], [0x7c23a61d, 0xdbe6f812],
+    [0x3373d236, 0x13f9d516], [0x49aba2fe, 0x23cc5c6f],
+    [0xc6c333a6, 0x7392c7e4], [0xbc1b436e, 0x43a74e9d],
+    [0x95ac9329, 0xac4bc9b5], [0xef74e3e1, 0x9c7e40cc],
+    [0x601c72b9, 0xcc20db47], [0x1ac40271, 0xfc15523e],
+    [0x5594765a, 0x340a7f3a], [0x2f4c0692, 0x043ff643],
+    [0xa02497ca, 0x54616dc8], [0xdafce702, 0x6454e4b1],
+    [0x3e847f9d, 0xc45f37c0], [0x445c0f55, 0xf46abeb9],
+    [0xcb349e0d, 0xa4342532], [0xb1eceec5, 0x9401ac4b],
+    [0xfebc9aee, 0x5c1e814f], [0x8464ea26, 0x6c2b0836],
+    [0x0b0c7b7e, 0x3c7593bd], [0x71d40bb6, 0x0c401ac4],
+    [0xe8a46c12, 0x24f5a634], [0x927c1cda, 0x14c02f4d],
+    [0x1d148d82, 0x449eb4c6], [0x67ccfd4a, 0x74ab3dbf],
+    [0x289c8961, 0xbcb410bb], [0x5244f9a9, 0x8c8199c2],
+    [0xdd2c68f1, 0xdcdf0249], [0xa7f41839, 0xecea8b30],
+    [0x438c80a6, 0x4ce15841], [0x3954f06e, 0x7cd4d138],
+    [0xb63c6136, 0x2c8a4ab3], [0xcce411fe, 0x1cbfc3ca],
+    [0x83b465d5, 0xd4a0eece], [0xf96c151d, 0xe49567b7],
+    [0x76048445, 0xb4cbfc3c], [0x0cdcf48d, 0x84fe7545],
+    [0x6fbd6d5e, 0xbd3716b7], [0x15651d96, 0x8d029fce],
+    [0x9a0d8cce, 0xdd5c0445], [0xe0d5fc06, 0xed698d3c],
+    [0xaf85882d, 0x2576a038], [0xd55df8e5, 0x15432941],
+    [0x5a3569bd, 0x451db2ca], [0x20ed1975, 0x75283bb3],
+    [0xc49581ea, 0xd523e8c2], [0xbe4df122, 0xe51661bb],
+    [0x3125607a, 0xb548fa30], [0x4bfd10b2, 0x857d7349],
+    [0x04ad6499, 0x4d625e4d], [0x7e751451, 0x7d57d734],
+    [0xf11d8509, 0x2d094cbf], [0x8bc5f5c1, 0x1d3cc5c6],
+    [0x12b59265, 0x35897936], [0x686de2ad, 0x05bcf04f],
+    [0xe70573f5, 0x55e26bc4], [0x9ddd033d, 0x65d7e2bd],
+    [0xd28d7716, 0xadc8cfb9], [0xa85507de, 0x9dfd46c0],
+    [0x273d9686, 0xcda3dd4b], [0x5de5e64e, 0xfd965432],
+    [0xb99d7ed1, 0x5d9d8743], [0xc3450e19, 0x6da80e3a],
+    [0x4c2d9f41, 0x3df695b1], [0x36f5ef89, 0x0dc31cc8],
+    [0x79a59ba2, 0xc5dc31cc], [0x037deb6a, 0xf5e9b8b5],
+    [0x8c157a32, 0xa5b7233e], [0xf6cd0afa, 0x9582aa47],
+    [0x4ad64994, 0xd625e4da], [0x300e395c, 0xe6106da3],
+    [0xbf66a804, 0xb64ef628], [0xc5bed8cc, 0x867b7f51],
+    [0x8aeeace7, 0x4e645255], [0xf036dc2f, 0x7e51db2c],
+    [0x7f5e4d77, 0x2e0f40a7], [0x05863dbf, 0x1e3ac9de],
+    [0xe1fea520, 0xbe311aaf], [0x9b26d5e8, 0x8e0493d6],
+    [0x144e44b0, 0xde5a085d], [0x6e963478, 0xee6f8124],
+    [0x21c64053, 0x2670ac20], [0x5b1e309b, 0x16452559],
+    [0xd476a1c3, 0x461bbed2], [0xaeaed10b, 0x762e37ab],
+    [0x37deb6af, 0x5e9b8b5b], [0x4d06c667, 0x6eae0222],
+    [0xc26e573f, 0x3ef099a9], [0xb8b627f7, 0x0ec510d0],
+    [0xf7e653dc, 0xc6da3dd4], [0x8d3e2314, 0xf6efb4ad],
+    [0x0256b24c, 0xa6b12f26], [0x788ec284, 0x9684a65f],
+    [0x9cf65a1b, 0x368f752e], [0xe62e2ad3, 0x06bafc57],
+    [0x6946bb8b, 0x56e467dc], [0x139ecb43, 0x66d1eea5],
+    [0x5ccebf68, 0xaecec3a1], [0x2616cfa0, 0x9efb4ad8],
+    [0xa97e5ef8, 0xcea5d153], [0xd3a62e30, 0xfe90582a],
+    [0xb0c7b7e3, 0xc7593bd8], [0xca1fc72b, 0xf76cb2a1],
+    [0x45775673, 0xa732292a], [0x3faf26bb, 0x9707a053],
+    [0x70ff5290, 0x5f188d57], [0x0a272258, 0x6f2d042e],
+    [0x854fb300, 0x3f739fa5], [0xff97c3c8, 0x0f4616dc],
+    [0x1bef5b57, 0xaf4dc5ad], [0x61372b9f, 0x9f784cd4],
+    [0xee5fbac7, 0xcf26d75f], [0x9487ca0f, 0xff135e26],
+    [0xdbd7be24, 0x370c7322], [0xa10fceec, 0x0739fa5b],
+    [0x2e675fb4, 0x576761d0], [0x54bf2f7c, 0x6752e8a9],
+    [0xcdcf48d8, 0x4fe75459], [0xb7173810, 0x7fd2dd20],
+    [0x387fa948, 0x2f8c46ab], [0x42a7d980, 0x1fb9cfd2],
+    [0x0df7adab, 0xd7a6e2d6], [0x772fdd63, 0xe7936baf],
+    [0xf8474c3b, 0xb7cdf024], [0x829f3cf3, 0x87f8795d],
+    [0x66e7a46c, 0x27f3aa2c], [0x1c3fd4a4, 0x17c62355],
+    [0x935745fc, 0x4798b8de], [0xe98f3534, 0x77ad31a7],
+    [0xa6df411f, 0xbfb21ca3], [0xdc0731d7, 0x8f8795da],
+    [0x536fa08f, 0xdfd90e51], [0x29b7d047, 0xefec8728]
+    );
+
+sub crc64($$) {
+    my ($cv, $str) = @_;
+    my $c;
+    my @cc = @$cv;
+    $cc[0] %= 4294967296;
+    $cc[1] %= 4294967296;
+
+    foreach $c (unpack("C*", $str)) {
+	my @ct = @{$crc64_tab[($cc[1] & 0xff) ^ $c]};
+
+	$cc[1] = $ct[1] ^
+	    ((($cc[1] & 0xffffff00) >> 8) | (($cc[0] & 0xff) << 24));
+	$cc[0] = $ct[0] ^ (($cc[0] & 0xffffff00) >> 8);
+    }
+
+    return @cc;
+}
diff --git a/vere/ext/nasm/perllib/gensv.pl b/vere/ext/nasm/perllib/gensv.pl
new file mode 100755
index 0000000..b80ccbe
--- /dev/null
+++ b/vere/ext/nasm/perllib/gensv.pl
@@ -0,0 +1,34 @@
+#!/usr/bin/perl
+#
+# Generate a list of rotation vectors so we always use the same set.
+# This needs to be run on a platform with /dev/urandom.
+#
+
+($n) = @ARGV;
+
+sysopen(UR, '/dev/urandom', O_RDONLY) or die;
+
+$maxlen = 78;
+
+print "\@random_sv_vectors = (\n";
+$outl = '   ';
+
+for ($i = 0; $i < $n; $i++) {
+
+    die if (sysread(UR, $x8, 8) != 8);
+    @n = unpack("V*", $x8);
+
+    $xl = sprintf(" [0x%08x, 0x%08x]%s",
+		  $n[0], $n[1],
+		  ($i == $n-1) ? '' : ',');
+    if (length($outl.$xl) > $maxlen) {
+	print $outl, "\n";
+	$outl = '   ';
+    }
+    $outl .= $xl;
+}
+close(UR);
+
+print $outl, "\n";
+print ");\n";
+print "1;\n";
diff --git a/vere/ext/nasm/perllib/phash.ph b/vere/ext/nasm/perllib/phash.ph
new file mode 100644
index 0000000..b5e4411
--- /dev/null
+++ b/vere/ext/nasm/perllib/phash.ph
@@ -0,0 +1,203 @@
+# -*- perl -*-
+#
+# Perfect Minimal Hash Generator written in Perl, which produces
+# C output.
+#
+
+require 'random_sv_vectors.ph';
+require 'crc64.ph';
+
+#
+# Compute the prehash for a key
+#
+# prehash(key, sv, N)
+#
+sub prehash($$$) {
+    my($key, $n, $sv) = @_;
+    my @c = crc64($sv, $key);
+    my $nmask = ($n << 1) - 2;
+
+    # Create a bipartite graph...
+    $k1 = ($c[1] & $nmask) + 0; # low word
+    $k2 = ($c[0] & $nmask) + 1; # high word
+
+    return ($k1, $k2);
+}
+
+#
+# Walk the assignment graph, return true on success
+#
+sub walk_graph($$$$) {
+    my($nodeval,$nodeneigh,$n,$v) = @_;
+    my $nx;
+
+    # print STDERR "Vertex $n value $v\n";
+    $$nodeval[$n] = $v;
+
+    foreach $nx (@{$$nodeneigh[$n]}) {
+	# $nx -> [neigh, hash]
+	my ($o, $e) = @$nx;
+
+	# print STDERR "Edge $n,$o value $e: ";
+	my $ov;
+	if (defined($ov = $$nodeval[$o])) {
+	    if ($v+$ov != $e) {
+		# Cyclic graph with collision
+		# print STDERR "error, should be ", $v+$ov, "\n";
+		return 0;
+	    } else {
+		# print STDERR "ok\n";
+	    }
+	} else {
+	    return 0 unless (walk_graph($nodeval, $nodeneigh, $o, $e-$v));
+	}
+    }
+    return 1;
+}
+
+#
+# Generate the function assuming a given N.
+#
+# gen_hash_n(N, sv, \%data, run)
+#
+sub gen_hash_n($$$$) {
+    my($n, $sv, $href, $run) = @_;
+    my @keys = keys(%{$href});
+    my $i;
+    my $gr;
+    my ($k, $v);
+    my $gsize = 2*$n;
+    my @nodeval;
+    my @nodeneigh;
+    my %edges;
+
+    for ($i = 0; $i < $gsize; $i++) {
+	$nodeneigh[$i] = [];
+    }
+
+    %edges = ();
+    foreach $k (@keys) {
+	my ($pf1, $pf2) = prehash($k, $n, $sv);
+	($pf1,$pf2) = ($pf2,$pf1) if ($pf1 > $pf2); # Canonicalize order
+
+	my $pf = "$pf1,$pf2";
+	my $e = ${$href}{$k};
+	my $xkey;
+
+	if (defined($xkey = $edges{$pf})) {
+	    next if ($e == ${$href}{$xkey}); # Duplicate hash, safe to ignore
+	    if (defined($run)) {
+		print STDERR "$run: Collision: $pf: $k with $xkey\n";
+	    }
+	    return;
+	}
+
+	# print STDERR "Edge $pf value $e from $k\n";
+
+	$edges{$pf} = $k;
+	push(@{$nodeneigh[$pf1]}, [$pf2, $e]);
+	push(@{$nodeneigh[$pf2]}, [$pf1, $e]);
+    }
+
+    # Now we need to assign values to each vertex, so that for each
+    # edge, the sum of the values for the two vertices give the value
+    # for the edge (which is our hash index.)  If we find an impossible
+    # situation, the graph was cyclic.
+    @nodeval = (undef) x $gsize;
+
+    for ($i = 0; $i < $gsize; $i++) {
+	if (scalar(@{$nodeneigh[$i]})) {
+	    # This vertex has neighbors (is used)
+	    if (!defined($nodeval[$i])) {
+		# First vertex in a cluster
+		unless (walk_graph(\@nodeval, \@nodeneigh, $i, 0)) {
+		    if (defined($run)) {
+			print STDERR "$run: Graph is cyclic\n";
+		    }
+		    return;
+		}
+	    }
+	}
+    }
+
+    # for ($i = 0; $i < $n; $i++) {
+    #	print STDERR "Vertex ", $i, ": ", $g[$i], "\n";
+    # }
+
+    if (defined($run)) {
+	printf STDERR "$run: Done: n = $n, sv = [0x%08x, 0x%08x]\n",
+	$$sv[0], $$sv[1];
+    }
+
+    return ($n, $sv, \@nodeval);
+}
+
+#
+# Driver for generating the function
+#
+# gen_perfect_hash(\%data)
+#
+sub gen_perfect_hash($) {
+    my($href) = @_;
+    my @keys = keys(%{$href});
+    my @hashinfo;
+    my ($n, $i, $j, $sv, $maxj);
+    my $run = 1;
+
+    # Minimal power of 2 value for N with enough wiggle room.
+    # The scaling constant must be larger than 0.5 in order for the
+    # algorithm to ever terminate. The higher the scaling constant,
+    # the more space does the hash take up, but the less likely is it
+    # that an invalid token will require a string comparison.
+    my $room = int(scalar(@keys)*1.6);
+    $n = 1;
+    while ($n < $room) {
+	$n <<= 1;
+    }
+
+    # Number of times to try...
+    $maxj = scalar @random_sv_vectors;
+
+    for ($i = 0; $i < 4; $i++) {
+	printf STDERR "%d vectors, trying n = %d...\n",
+		scalar @keys, $n;
+	for ($j = 0; $j < $maxj; $j++) {
+	    $sv = $random_sv_vectors[$j];
+	    @hashinfo = gen_hash_n($n, $sv, $href, $run++);
+	    return @hashinfo if (@hashinfo);
+	}
+	$n <<= 1;
+    }
+
+    return;
+}
+
+#
+# Verify that the hash table is actually correct...
+#
+sub verify_hash_table($$)
+{
+    my ($href, $hashinfo) = @_;
+    my ($n, $sv, $g) = @{$hashinfo};
+    my $k;
+    my $err = 0;
+
+    foreach $k (keys(%$href)) {
+	my ($pf1, $pf2) = prehash($k, $n, $sv);
+	my $g1 = ${$g}[$pf1];
+	my $g2 = ${$g}[$pf2];
+
+	if ($g1+$g2 != ${$href}{$k}) {
+	    printf STDERR "%s(%d,%d): %d+%d = %d != %d\n",
+	    $k, $pf1, $pf2, $g1, $g2, $g1+$g2, ${$href}{$k};
+	    $err = 1;
+	} else {
+	    # printf STDERR "%s: %d+%d = %d ok\n",
+	    # $k, $g1, $g2, $g1+$g2;
+	}
+    }
+
+    die "$0: hash validation error\n" if ($err);
+}
+
+1;
diff --git a/vere/ext/nasm/perllib/random_sv_vectors.ph b/vere/ext/nasm/perllib/random_sv_vectors.ph
new file mode 100644
index 0000000..db2dc6e
--- /dev/null
+++ b/vere/ext/nasm/perllib/random_sv_vectors.ph
@@ -0,0 +1,67 @@
+@random_sv_vectors = (
+    [0x076259c3, 0xe291c26c], [0xaee7ac5c, 0xcabdec91],
+    [0x5d3862fb, 0x2e8a3060], [0x6fb3635c, 0x4783593a],
+    [0x13f0eafb, 0x407e486a], [0x7436afdd, 0xd04c4829],
+    [0xace2d0e4, 0x80575791], [0x2dd9a392, 0xdc1e869e],
+    [0x199c3e38, 0x026a9d67], [0x9f911c85, 0x3a489c87],
+    [0x9ac31028, 0x0b6e14b2], [0x2ccfbcf9, 0x3f9f2308],
+    [0x2e0210fb, 0x392f380f], [0x14ab403a, 0x81a11065],
+    [0xd496f63c, 0x53196b13], [0x48a34d7f, 0x2ffc6036],
+    [0x34ea8e9d, 0xcd1ed098], [0x2da1a3f2, 0x3d6c23f2],
+    [0xca7374da, 0x06054f89], [0xc909a0bb, 0x31d6c0d2],
+    [0x87454496, 0x15b360d7], [0x9eebbd12, 0x89532131],
+    [0x1119c65b, 0xd9e49705], [0x60c3be0b, 0xd6cc7c8a],
+    [0x117723cd, 0x40af090f], [0xfc284f51, 0x3dcf4c06],
+    [0xb41fcda4, 0xec03644c], [0xd99e1ea7, 0x84eaf76d],
+    [0x534b956a, 0x06d3fb8d], [0x2da4bb09, 0x078092eb],
+    [0x6a5be463, 0xbfa51a88], [0xc4e8be95, 0xe7eec27c],
+    [0x15a1fbb9, 0xfadc08cd], [0x0bcfab08, 0xbccade0f],
+    [0x629f1f6c, 0x90ccede7], [0x5c2b26aa, 0x1f0b1fce],
+    [0xdfe0e3fd, 0xbd7c3cfb], [0xa1628ca9, 0x90a05686],
+    [0xbf0267f2, 0xd2964139], [0x8009a9b9, 0xd2195918],
+    [0xfcc7b5f8, 0xc108c643], [0xf447d4b0, 0x71953863],
+    [0x95d091ed, 0xdbe01948], [0x81dec325, 0x2bfecda2],
+    [0x2ed2acaa, 0x7eeaa0d0], [0xb7b0a20e, 0x8bf5c01b],
+    [0x75eb3917, 0xfd2f758f], [0xb33a5b49, 0x8a8cedf6],
+    [0x3aaf2757, 0x69b319a9], [0x32cfa41b, 0xeba36f19],
+    [0xf54209dd, 0x941f3a08], [0x232703bb, 0x786a6f84],
+    [0x4937b242, 0xc9f07398], [0x74dc5d39, 0x550a58e8],
+    [0x6c9aebdc, 0x8fda5069], [0x5ae6d62a, 0x05cd24a3],
+    [0x8111e50a, 0xc1c6d19b], [0xb980a92b, 0x448b4d1f],
+    [0x568cf58a, 0x8bcb93ca], [0xfe96002f, 0x410cd2f1],
+    [0xaf511e45, 0x99e4872f], [0x822c20bc, 0x3db49ddd],
+    [0x184fec4e, 0xbb82ec52], [0x30ca5326, 0xf3180297],
+    [0x97962aa4, 0x7d4bc6d4], [0x9199a315, 0x8e9f18c6],
+    [0xead69a7e, 0x3262a683], [0xe261ec00, 0x81edc47a],
+    [0x06080c0e, 0x6d18fa9f], [0x1771ec43, 0x6747ed66],
+    [0xe71fe587, 0xe81ad0f3], [0xf083e80c, 0x0898bcd8],
+    [0x30328c5a, 0x2efb4ee7], [0xd04fa5d7, 0xec9c9f18],
+    [0x87820480, 0x48932224], [0xb1f18815, 0x1b27e3e3],
+    [0x79aa440c, 0xdf17a8fc], [0x8a83d404, 0x10fdec8c],
+    [0x7d4dfe60, 0x573561ee], [0x60315c7d, 0xa0692af6],
+    [0xb3ca4d52, 0x89ca832f], [0x9ebc5c79, 0xa84a28fc],
+    [0xdfa76008, 0x7772cf7c], [0xb0e3a15f, 0xbdc35aee],
+    [0x6e252b03, 0x32b2107d], [0x20dcc2a3, 0x21987229],
+    [0x848e3ad8, 0xe692a0c6], [0xdd07fa50, 0x0b64e1ae],
+    [0xc4072bc2, 0x2f120bba], [0xdb3af26e, 0xacab0c48],
+    [0xd7d4b59a, 0xcf72a7a7], [0x4628de45, 0x4dfb2750],
+    [0x7519211f, 0x4798b536], [0x19984af3, 0xffd2aa19],
+    [0x1372d9c0, 0x7512153a], [0x295d19da, 0x497416e5],
+    [0x70932c73, 0x8a9bf591], [0xa0960860, 0xfaa7dc61],
+    [0xd425f548, 0x43aeda4d], [0xaa2573c7, 0x01a2553d],
+    [0x988e71d7, 0xd3c004a4], [0x3da87545, 0x2197af10],
+    [0x2f89e592, 0xa686e2fc], [0x7b88018a, 0xae66d575],
+    [0x93215591, 0xed69e6ea], [0x4fcacc4a, 0x4d2aba97],
+    [0xbedb923b, 0x500b2f1a], [0x0b6d8aa0, 0x232511b0],
+    [0x282fb3ee, 0x23695de0], [0x0c455dfe, 0x820cca3f],
+    [0xe893868c, 0x87f698f6], [0xb6428730, 0x56e576ce],
+    [0xf3843ee7, 0xba79bc28], [0xa1c9ca45, 0x30c479c1],
+    [0xbfc244c2, 0xa9af65f0], [0x6eeb88eb, 0x62b4479c],
+    [0xcc328fe5, 0x60f5c9bf], [0x31aa2c21, 0xc55575fb],
+    [0x9429492d, 0x8e80612a], [0xb12fe59e, 0xf0e1e97b],
+    [0xc2501dad, 0x4a9f4bbf], [0x65ae8366, 0x3e8b0983],
+    [0xd5fc062a, 0xba74f808], [0x7398cc0a, 0x39a6a269],
+    [0x5581dd60, 0xff79d28c], [0xea5e52b3, 0x9be66c71],
+    [0x8f6e02a4, 0xe27318b5], [0xe8bceb99, 0xa48a7f2c],
+);
+1;
diff --git a/vere/ext/nasm/stdlib/snprintf.c b/vere/ext/nasm/stdlib/snprintf.c
new file mode 100644
index 0000000..e4a1c0b
--- /dev/null
+++ b/vere/ext/nasm/stdlib/snprintf.c
@@ -0,0 +1,26 @@
+/*
+ * snprintf()
+ *
+ * Implement snprintf() in terms of vsnprintf()
+ */
+
+#include "compiler.h"
+
+
+#include "nasmlib.h"
+
+#if !defined(HAVE_SNPRINTF) && !defined(HAVE__SNPRINTF)
+
+int snprintf(char *str, size_t size, const char *format, ...)
+{
+    va_list ap;
+    int rv;
+
+    va_start(ap, format);
+    rv = vsnprintf(str, size, format, ap);
+    va_end(ap);
+
+    return rv;
+}
+
+#endif
diff --git a/vere/ext/nasm/stdlib/strlcpy.c b/vere/ext/nasm/stdlib/strlcpy.c
new file mode 100644
index 0000000..22d9ccf
--- /dev/null
+++ b/vere/ext/nasm/stdlib/strlcpy.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "compiler.h"
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+#ifndef HAVE_STRLCPY
+
+size_t strlcpy(char *dst, const char *src, size_t siz)
+{
+    char *d = dst;
+    const char *s = src;
+    size_t n = siz;
+
+    /* Copy as many bytes as will fit */
+    if (n != 0) {
+	while (--n != 0) {
+	    if ((*d++ = *s++) == '\0')
+		break;
+	}
+    }
+
+    /* Not enough room in dst, add NUL and traverse rest of src */
+    if (n == 0) {
+	if (siz != 0)
+	    *d = '\0';		/* NUL-terminate dst */
+	while (*s++)
+	    ;
+    }
+
+    return(s - src - 1);	/* count does not include NUL */
+}
+
+#endif
diff --git a/vere/ext/nasm/stdlib/strnlen.c b/vere/ext/nasm/stdlib/strnlen.c
new file mode 100644
index 0000000..193245e
--- /dev/null
+++ b/vere/ext/nasm/stdlib/strnlen.c
@@ -0,0 +1,45 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+
+#ifndef HAVE_STRNLEN
+
+size_t strnlen(const char *s, size_t maxlen)
+{
+    const char *end = memchr(s, 0, maxlen);
+
+    return end ? (size_t)(end - s) : maxlen;
+}
+
+#endif
diff --git a/vere/ext/nasm/stdlib/strrchrnul.c b/vere/ext/nasm/stdlib/strrchrnul.c
new file mode 100644
index 0000000..2fc8eb6
--- /dev/null
+++ b/vere/ext/nasm/stdlib/strrchrnul.c
@@ -0,0 +1,49 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+
+#ifndef HAVE_STRRCHRNUL
+
+char *strrchrnul(const char *s, int c)
+{
+    char *p;
+
+    p = strrchr(s, c);
+    if (!p)
+        p = strchr(s, '\0');
+
+    return p;
+}
+
+#endif
diff --git a/vere/ext/nasm/stdlib/vsnprintf.c b/vere/ext/nasm/stdlib/vsnprintf.c
new file mode 100644
index 0000000..58de651
--- /dev/null
+++ b/vere/ext/nasm/stdlib/vsnprintf.c
@@ -0,0 +1,46 @@
+/*
+ * vsnprintf()
+ *
+ * Poor substitute for a real vsnprintf() function for systems
+ * that don't have them...
+ */
+
+#include "compiler.h"
+
+
+#include "nasmlib.h"
+#include "error.h"
+
+#if !defined(HAVE_VSNPRINTF) && !defined(HAVE__VSNPRINTF)
+
+#define BUFFER_SIZE     65536   /* Bigger than any string we might print... */
+
+static char snprintf_buffer[BUFFER_SIZE];
+
+int vsnprintf(char *str, size_t size, const char *format, va_list ap)
+{
+    int rv, bytes;
+
+    if (size > BUFFER_SIZE) {
+        nasm_panic("vsnprintf: size (%llu) > BUFFER_SIZE (%d)",
+                   (unsigned long long)size, BUFFER_SIZE);
+        size = BUFFER_SIZE;
+    }
+
+    rv = vsprintf(snprintf_buffer, format, ap);
+    if (rv >= BUFFER_SIZE)
+        nasm_panic("vsnprintf buffer overflow");
+
+    if (size > 0) {
+        if ((size_t)rv < size-1)
+            bytes = rv;
+        else
+            bytes = size-1;
+        memcpy(str, snprintf_buffer, bytes);
+        str[bytes] = '\0';
+    }
+
+    return rv;
+}
+
+#endif
diff --git a/vere/ext/nasm/x86/disp8.c b/vere/ext/nasm/x86/disp8.c
new file mode 100644
index 0000000..64c921b
--- /dev/null
+++ b/vere/ext/nasm/x86/disp8.c
@@ -0,0 +1,131 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2013 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * disp8.c   : Contains a common logic for EVEX compressed displacement
+ */
+
+#include "disp8.h"
+
+/*
+ * Find N value for compressed displacement (disp8 * N)
+ */
+uint8_t get_disp8N(insn *ins)
+{
+    static const uint8_t fv_n[2][2][VLMAX] = {{{16, 32, 64}, {4, 4, 4}},
+                                              {{16, 32, 64}, {8, 8, 8}}};
+    static const uint8_t hv_n[2][VLMAX]    =  {{8, 16, 32}, {4, 4, 4}};
+    static const uint8_t dup_n[VLMAX]      =   {8, 32, 64};
+
+    bool evex_b           = (ins->evex_p[2] & EVEX_P2B) >> 4;
+    enum ttypes   tuple   = ins->evex_tuple;
+    enum vectlens vectlen = (ins->evex_p[2] & EVEX_P2LL) >> 5;
+    bool evex_w           = (ins->evex_p[1] & EVEX_P1W) >> 7;
+    uint8_t n = 0;
+
+    switch(tuple) {
+    case FV:
+        n = fv_n[evex_w][evex_b][vectlen];
+        break;
+    case HV:
+        n = hv_n[evex_b][vectlen];
+        break;
+
+    case FVM:
+        /* 16, 32, 64 for VL 128, 256, 512 respectively*/
+        n = 1 << (vectlen + 4);
+        break;
+    case T1S8:  /* N = 1 */
+    case T1S16: /* N = 2 */
+        n = tuple - T1S8 + 1;
+        break;
+    case T1S:
+        /* N = 4 for 32bit, 8 for 64bit */
+        n = evex_w ? 8 : 4;
+        break;
+    case T1F32:
+    case T1F64:
+        /* N = 4 for 32bit, 8 for 64bit */
+        n = (tuple == T1F32 ? 4 : 8);
+        break;
+    case T2:
+    case T4:
+    case T8:
+        if (vectlen + 7 <= (evex_w + 5) + (tuple - T2 + 1))
+            n = 0;
+        else
+            n = 1 << (tuple - T2 + evex_w + 3);
+        break;
+    case HVM:
+    case QVM:
+    case OVM:
+        n = 1 << (OVM - tuple + vectlen + 1);
+        break;
+    case M128:
+        n = 16;
+        break;
+    case DUP:
+        n = dup_n[vectlen];
+        break;
+
+    default:
+        break;
+    }
+
+    return n;
+}
+
+/*
+ * Check if offset is a multiple of N with corresponding tuple type
+ * if Disp8*N is available, compressed displacement is stored in compdisp
+ */
+bool is_disp8n(operand *input, insn *ins, int8_t *compdisp)
+{
+    int32_t off           = input->offset;
+    uint8_t n;
+    int32_t disp8;
+
+    n = get_disp8N(ins);
+
+    if (n && !(off & (n - 1))) {
+        disp8 = off / n;
+        /* if it fits in Disp8 */
+        if (disp8 >= -128 && disp8 <= 127) {
+            *compdisp = disp8;
+            return true;
+        }
+    }
+
+    *compdisp = 0;
+    return false;
+}
diff --git a/vere/ext/nasm/x86/iflag.c b/vere/ext/nasm/x86/iflag.c
new file mode 100644
index 0000000..d47ce89
--- /dev/null
+++ b/vere/ext/nasm/x86/iflag.c
@@ -0,0 +1,315 @@
+/* This file is auto-generated. Don't edit. */
+#include "iflag.h"
+
+/* All combinations of instruction flags used in instruction patterns */
+const iflag_t insns_flags[309] = {
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*   0 : 8086 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*   1 : 8086,NOLONG */
+    {{UINT32_C(0x00000004),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*   2 : 8086,NOLONG,SB */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*   3 : 8086,LOCK,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*   4 : 386,LOCK,SM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*   5 : 386 */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000028),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*   6 : LOCK,LONG,SM,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*   7 : LONG,X86_64 */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*   8 : 8086,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*   9 : 386,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  10 : LONG,SM,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  11 : 8086,LOCK */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  12 : 386,LOCK */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000028),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  13 : LOCK,LONG,X86_64 */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000018),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  14 : 8086,LOCK,NOLONG,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000014),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  15 : 286,NOLONG,PROT,SM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000014),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  16 : 286,NOLONG,PROT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00040020)}}, /*  17 : CYRIX,OBSOLETE,PENT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000002)}}, /*  18 : 186,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  19 : 386,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000010)}}, /*  20 : 486 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000200),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  21 : 8086,BND */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000210),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  22 : 8086,BND,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000210),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  23 : 386,BND,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000220),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  24 : BND,LONG,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  25 : 286,PRIV */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  26 : 8086,NOLONG,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  27 : LOCK,PENT,SM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  28 : PENT */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000408),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000010)}}, /*  29 : 486,LOCK,OBSOLETE,SM,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000010)}}, /*  30 : 486,OBSOLETE,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  31 : LOCK,PENT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040020)}}, /*  32 : CYRIX,PENT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040040)}}, /*  33 : CYRIX,P6 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  34 : MMX,PENT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000002)}}, /*  35 : 186 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00001000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  36 : 8086,FPU */
+    {{UINT32_C(0x00000000),UINT32_C(0x00001000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040)}}, /*  37 : FPU,P6 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00001000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  38 : 386,FPU */
+    {{UINT32_C(0x00000000),UINT32_C(0x00004000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  39 : 3DNOW,PENT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00001400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  40 : 286,FPU,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00001000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200)}}, /*  41 : FPU,PRESCOTT */
+    {{UINT32_C(0x00000008),UINT32_C(0x00001000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  42 : 8086,FPU,SW */
+    {{UINT32_C(0x00000000),UINT32_C(0x00001000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  43 : 286,FPU */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  44 : 8086,PRIV */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000008)}}, /*  45 : 386,OBSOLETE,SW,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000008)}}, /*  46 : 386,OBSOLETE,UNDOC */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000008)}}, /*  47 : 386,OBSOLETE,SD,UNDOC */
+    {{UINT32_C(0x00000002),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000002)}}, /*  48 : 186,SM2 */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000002)}}, /*  49 : 186,SM */
+    {{UINT32_C(0x00000002),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  50 : 386,SM2 */
+    {{UINT32_C(0x00000002),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  51 : LONG,SM2,X86_64 */
+    {{UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  52 : 8086,SB */
+    {{UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  53 : 386,SB */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000010)}}, /*  54 : 486,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x80000011),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /*  55 : FUTURE,INVPCID,NOLONG,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x80000021),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /*  56 : FUTURE,INVPCID,LONG,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080400)}}, /*  57 : AMD,NOLONG,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080400)}}, /*  58 : AMD,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080400)}}, /*  59 : AMD,LONG,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00008000)}}, /*  60 : IA64 */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  61 : 286,PROT,SW */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  62 : 286,PROT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  63 : 386,PROT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000024),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  64 : LONG,PROT,X86_64 */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  65 : 386,PROT,SW */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000024),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  66 : LONG,PROT,SW,X86_64 */
+    {{UINT32_C(0x00000800),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  67 : 8086,ANYSIZE */
+    {{UINT32_C(0x00000800),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  68 : 386,ANYSIZE */
+    {{UINT32_C(0x00000800),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  69 : ANYSIZE,LONG,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000005),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /*  70 : 286,PRIV,PROT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000004)}}, /*  71 : 286,OBSOLETE,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200)}}, /*  72 : PRESCOTT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200)}}, /*  73 : NOLONG,PRESCOTT */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080000)}}, /*  74 : AMD */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  75 : 8086,SW */
+    {{UINT32_C(0x00020000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  76 : LONG,OPT,X86_64 */
+    {{UINT32_C(0x00020000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  77 : 8086,OPT */
+    {{UINT32_C(0x00020000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  78 : 386,OPT */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000040),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /*  79 : 8086,NOHLE,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000040),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  80 : 386,NOHLE,SM */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000060),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  81 : LONG,NOHLE,SM,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000011),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  82 : 386,NOLONG,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000021),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  83 : LONG,PRIV,X86_64 */
+    {{UINT32_C(0x00020001),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  84 : LONG,OPT,SM,X86_64 */
+    {{UINT32_C(0x00000010),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  85 : MMX,PENT,SD */
+    {{UINT32_C(0x00000400),UINT32_C(0x00002020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  86 : LONG,MMX,SX,X86_64 */
+    {{UINT32_C(0x00000020),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  87 : MMX,PENT,SQ */
+    {{UINT32_C(0x00000000),UINT32_C(0x00002020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  88 : LONG,MMX,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040)}}, /*  89 : P6 */
+    {{UINT32_C(0x00000020),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040020)}}, /*  90 : CYRIX,MMX,PENT,SQ */
+    {{UINT32_C(0x00000020),UINT32_C(0x00004000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  91 : 3DNOW,PENT,SQ */
+    {{UINT32_C(0x00000001),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040020)}}, /*  92 : CYRIX,MMX,PENT,SM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000001)}}, /*  93 : 8086,OBSOLETE,UNDOC */
+    {{UINT32_C(0x00001200),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000002)}}, /*  94 : 186,AR0,SIZE */
+    {{UINT32_C(0x00001200),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  95 : 386,AR0,NOLONG,SIZE */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /*  96 : 386,NOLONG,SD */
+    {{UINT32_C(0x00001200),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /*  97 : AR0,LONG,SIZE,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000002),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040040)}}, /*  98 : CYRIX,P6,SMM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /*  99 : PENT,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 100 : X86_64 */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000200),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /* 101 : 8086,BND,SW */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000210),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /* 102 : 8086,BND,NOLONG,SW */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000220),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 103 : BND,LONG,SW,X86_64 */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 104 : LONG,SW,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000002),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040010)}}, /* 105 : 486,CYRIX,SMM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000002),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020)}}, /* 106 : PENT,SMM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001)}}, /* 107 : 8086,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004)}}, /* 108 : 286 */
+    {{UINT32_C(0x00004006),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /* 109 : 386,AR2,SB,SM2 */
+    {{UINT32_C(0x00004006),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 110 : AR2,LONG,SB,SM2,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /* 111 : 386,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00040010)}}, /* 112 : 486,CYRIX,OBSOLETE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080040)}}, /* 113 : AMD,P6 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040)}}, /* 114 : P6,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080040)}}, /* 115 : AMD,P6,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000002)}}, /* 116 : 186,OBSOLETE */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /* 117 : 386,SM,UNDOC */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000010)}}, /* 118 : 486,LOCK,SM */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /* 119 : 386,SW,UNDOC */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /* 120 : 386,SD,UNDOC */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040)}}, /* 121 : P6,SM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000200),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008)}}, /* 122 : 386,BND */
+    {{UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 123 : KATMAI,SSE */
+    {{UINT32_C(0x00000000),UINT32_C(0x0000a000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 124 : KATMAI,MMX,SSE */
+    {{UINT32_C(0x00002010),UINT32_C(0x00008000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 125 : AR1,KATMAI,SD,SSE */
+    {{UINT32_C(0x00002020),UINT32_C(0x00008020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 126 : AR1,LONG,SQ,SSE,X86_64 */
+    {{UINT32_C(0x00002010),UINT32_C(0x00008020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 127 : AR1,LONG,SD,SSE,X86_64 */
+    {{UINT32_C(0x00000020),UINT32_C(0x0000a000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 128 : KATMAI,MMX,SQ,SSE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00008020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 129 : LONG,SSE,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00009000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040)}}, /* 130 : FPU,P6,SSE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00009020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 131 : FPU,LONG,SSE,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 132 : NEHALEM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 133 : NEHALEM,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 134 : LONG,NEHALEM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 135 : FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 136 : FUTURE,LONG */
+    {{UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 137 : KATMAI,SB */
+    {{UINT32_C(0x00000004),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100),UINT32_C(0x00004000)}}, /* 138 : FUTURE,PREFETCHI,SB */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 139 : KATMAI */
+    {{UINT32_C(0x00000000),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 140 : KATMAI,MMX */
+    {{UINT32_C(0x00000020),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 141 : KATMAI,MMX,SQ */
+    {{UINT32_C(0x00004004),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 142 : AR2,KATMAI,MMX,SB */
+    {{UINT32_C(0x00004006),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000080)}}, /* 143 : AR2,KATMAI,MMX,SB,SM2 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 144 : SSE2,WILLAMETTE */
+    {{UINT32_C(0x00000040),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 145 : SO,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 146 : SD,WILLAMETTE */
+    {{UINT32_C(0x00000020),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 147 : LONG,SQ,X86_64 */
+    {{UINT32_C(0x00000010),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 148 : SD,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00000020),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 149 : SQ,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00010020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 150 : LONG,SSE2,X86_64 */
+    {{UINT32_C(0x00000020),UINT32_C(0x00002000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 151 : MMX,SQ,WILLAMETTE */
+    {{UINT32_C(0x00004004),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 152 : AR2,SB,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00004004),UINT32_C(0x00010020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 153 : AR2,LONG,SB,SSE2,X86_64 */
+    {{UINT32_C(0x00004006),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 154 : AR2,SB,SM2,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00002004),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 155 : AR1,SB,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00002020),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 156 : AR1,SQ,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00002020),UINT32_C(0x00010020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 157 : AR1,LONG,SQ,SSE2,X86_64 */
+    {{UINT32_C(0x00002010),UINT32_C(0x00010000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100)}}, /* 158 : AR1,SD,SSE2,WILLAMETTE */
+    {{UINT32_C(0x00000040),UINT32_C(0x00020000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200)}}, /* 159 : PRESCOTT,SO,SSE3 */
+    {{UINT32_C(0x00000020),UINT32_C(0x00020000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200)}}, /* 160 : PRESCOTT,SQ,SSE3 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00020000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200)}}, /* 161 : PRESCOTT,SSE3 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080000)}}, /* 162 : AMD,VMX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 163 : VMX */
+    {{UINT32_C(0x00000010),UINT32_C(0x00040010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 164 : NOLONG,SD,VMX */
+    {{UINT32_C(0x00000020),UINT32_C(0x00040020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 165 : LONG,SQ,VMX,X86_64 */
+    {{UINT32_C(0x00000040),UINT32_C(0x00040010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 166 : NOLONG,SO,VMX */
+    {{UINT32_C(0x00000040),UINT32_C(0x00040020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 167 : LONG,SO,VMX */
+    {{UINT32_C(0x00000020),UINT32_C(0x00082000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 168 : MMX,SQ,SSSE3 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00080000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 169 : SSSE3 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00100000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080000)}}, /* 170 : AMD,SSE4A */
+    {{UINT32_C(0x00000020),UINT32_C(0x00100000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080000)}}, /* 171 : AMD,SQ,SSE4A */
+    {{UINT32_C(0x00000010),UINT32_C(0x00100000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080000)}}, /* 172 : AMD,SD,SSE4A */
+    {{UINT32_C(0x00000000),UINT32_C(0x00200000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 173 : SSE41 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00200020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 174 : LONG,SSE41,X86_64 */
+    {{UINT32_C(0x00004004),UINT32_C(0x00200000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 175 : AR2,SB,SSE41 */
+    {{UINT32_C(0x00004004),UINT32_C(0x00200020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 176 : AR2,LONG,SB,SSE41,X86_64 */
+    {{UINT32_C(0x00000020),UINT32_C(0x00200000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 177 : SQ,SSE41 */
+    {{UINT32_C(0x00000010),UINT32_C(0x00200000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 178 : SD,SSE41 */
+    {{UINT32_C(0x00000008),UINT32_C(0x00200000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 179 : SSE41,SW */
+    {{UINT32_C(0x00000000),UINT32_C(0x00400000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000)}}, /* 180 : SSE42 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00400020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 181 : LONG,SSE42,X86_64 */
+    {{UINT32_C(0x00000008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 182 : NEHALEM,SW */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 183 : NEHALEM,SD */
+    {{UINT32_C(0x00000020),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 184 : LONG,NEHALEM,SQ */
+    {{UINT32_C(0x00000020),UINT32_C(0x00004000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040020)}}, /* 185 : 3DNOW,CYRIX,PENT,SQ */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800)}}, /* 186 : NEHALEM,SM */
+    {{UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00001000)}}, /* 187 : SSE,WESTMERE */
+    {{UINT32_C(0x00000000),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 188 : AVX,SANDYBRIDGE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00002000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 189 : FUTURE,VAES,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00002081),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 190 : AVX512,AVX512VL,EVEX,FUTURE,VAES */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00002001),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 191 : AVX512,EVEX,FUTURE,VAES */
+    {{UINT32_C(0x00000040),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 192 : AVX,SANDYBRIDGE,SO,VEX */
+    {{UINT32_C(0x00000080),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 193 : AVX,SANDYBRIDGE,SY,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x01000020),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 194 : AVX,LONG,SANDYBRIDGE,VEX */
+    {{UINT32_C(0x00000010),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 195 : AVX,SANDYBRIDGE,SD,VEX */
+    {{UINT32_C(0x00000020),UINT32_C(0x01000020),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 196 : AVX,LONG,SANDYBRIDGE,SQ,VEX */
+    {{UINT32_C(0x00000020),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00002000)}}, /* 197 : AVX,SANDYBRIDGE,SQ,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 198 : FUTURE,VEX,VPCLMULQDQ */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 199 : AVX512VL,EVEX,FUTURE,VPCLMULQDQ */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004001),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 200 : AVX512,EVEX,FUTURE,VPCLMULQDQ */
+    {{UINT32_C(0x00000000),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 201 : FMA,FUTURE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 202 : AVX,FUTURE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 203 : FUTURE,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00080008)}}, /* 204 : 386,AMD,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00080400)}}, /* 205 : AMD,LONG,VEX,X86_64 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00800000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00080000)}}, /* 206 : AMD,SSE5,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x02000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 207 : AVX2,FUTURE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x40000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 208 : FUTURE,RTM */
+    {{UINT32_C(0x00000000),UINT32_C(0x40000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 209 : FUTURE,NOLONG,RTM */
+    {{UINT32_C(0x00000000),UINT32_C(0x40000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 210 : FUTURE,LONG,RTM */
+    {{UINT32_C(0x00000000),UINT32_C(0x40000800),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 211 : FUTURE,HLE,RTM */
+    {{UINT32_C(0x00000000),UINT32_C(0x08000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 212 : BMI1,FUTURE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x08000020),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 213 : BMI1,FUTURE,LONG,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x20000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 214 : FUTURE,TBM,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x20000020),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 215 : FUTURE,LONG,TBM,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x10000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 216 : BMI2,FUTURE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x10000020),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 217 : BMI2,FUTURE,LONG,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x08000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 218 : BMI1,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x08000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 219 : BMI1,FUTURE,LONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 220 : FUTURE,PREFETCHWT1 */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000080),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 221 : FUTURE,MIB,MPX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 222 : FUTURE,MPX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 223 : FUTURE,MPX,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 224 : FUTURE,LONG,MPX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000090),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 225 : FUTURE,MIB,MPX,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x000000a0),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 226 : FUTURE,LONG,MIB,MPX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 227 : FUTURE,SHA */
+    {{UINT32_C(0x00040008),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040800),UINT32_C(0x00004000)}}, /* 228 : AVXNECONVERT,FUTURE,LATEVEX,SW,VEX */
+    {{UINT32_C(0x00040400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040800),UINT32_C(0x00004000)}}, /* 229 : AVXNECONVERT,FUTURE,LATEVEX,SX,VEX */
+    {{UINT32_C(0x00040080),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040800),UINT32_C(0x00004000)}}, /* 230 : AVXNECONVERT,FUTURE,LATEVEX,SY,VEX */
+    {{UINT32_C(0x00040400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00041000),UINT32_C(0x00004000)}}, /* 231 : AVXVNNIINT8,FUTURE,LATEVEX,SX,VEX */
+    {{UINT32_C(0x00040080),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00041000),UINT32_C(0x00004000)}}, /* 232 : AVXVNNIINT8,FUTURE,LATEVEX,SY,VEX */
+    {{UINT32_C(0x00040400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00042000),UINT32_C(0x00004000)}}, /* 233 : AVXIFMA,FUTURE,LATEVEX,SX,VEX */
+    {{UINT32_C(0x00040080),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00042000),UINT32_C(0x00004000)}}, /* 234 : AVXIFMA,FUTURE,LATEVEX,SY,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 235 : FUTURE,VEX */
+    {{UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 236 : FUTURE,SM,VEX */
+    {{UINT32_C(0x00000005),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 237 : FUTURE,SB,SM,VEX */
+    {{UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 238 : FUTURE,SX,VEX */
+    {{UINT32_C(0x00000002),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 239 : FUTURE,SM2,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000081),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 240 : AVX512,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 241 : AVX512,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000180),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 242 : AVX512DQ,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000100),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 243 : AVX512DQ,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000280),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 244 : AVX512BW,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000200),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 245 : AVX512BW,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000004),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 246 : AVX512ER,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000008),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 247 : AVX512PF,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000082),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 248 : AVX512CD,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000002),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 249 : AVX512CD,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000880),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 250 : AVX512VBMI,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000800),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 251 : AVX512VBMI,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000480),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 252 : AVX512IFMA,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 253 : AVX512IFMA,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 254 : FUTURE,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000420),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 255 : FUTURE,LONG,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00038000),UINT32_C(0x00004000)}}, /* 256 : FUTURE,NEVER,NOP,OBSOLETE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00084000)}}, /* 257 : AMD,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00084000)}}, /* 258 : AMD,FUTURE,NOLONG */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00084000)}}, /* 259 : AMD,FUTURE,LONG */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 260 : FUTURE,SD */
+    {{UINT32_C(0x00000020),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 261 : FUTURE,LONG,SQ */
+    {{UINT32_C(0x00000000),UINT32_C(0x00008000),UINT32_C(0x00008000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 262 : FUTURE,GFNI,SSE */
+    {{UINT32_C(0x00000000),UINT32_C(0x01000000),UINT32_C(0x00008000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 263 : AVX,FUTURE,GFNI,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00008080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 264 : AVX512VL,EVEX,FUTURE,GFNI */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00008001),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 265 : AVX512,EVEX,FUTURE,GFNI */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00010080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 266 : AVX512VBMI2,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00010000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 267 : AVX512VBMI2,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00020080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 268 : AVX512VL,AVX512VNNI,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00020000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 269 : AVX512VNNI,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 270 : AVX512BITALG,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00040000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 271 : AVX512BITALG,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 272 : AVX512VL,AVX512VPOPCNTDQ,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00080000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 273 : AVX512VPOPCNTDQ,EVEX,FUTURE */
+    {{UINT32_C(0x00000040),UINT32_C(0x00000000),UINT32_C(0x00100000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 274 : AVX5124FMAPS,EVEX,FUTURE,SO */
+    {{UINT32_C(0x00000040),UINT32_C(0x00000000),UINT32_C(0x00200000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 275 : AVX5124VNNIW,EVEX,FUTURE,SO */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x01000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 276 : FUTURE,SGX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x02000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 277 : CET,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x02000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 278 : CET,FUTURE,LONG */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000010),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 279 : ENQCMD,FUTURE,NOLONG,SZ */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000000),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 280 : ENQCMD,FUTURE,SZ */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000020),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 281 : ENQCMD,FUTURE,LONG,SZ */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000011),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 282 : ENQCMD,FUTURE,NOLONG,PRIV,SZ */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000001),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 283 : ENQCMD,FUTURE,PRIV,SZ */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000021),UINT32_C(0x04000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 284 : ENQCMD,FUTURE,LONG,PRIV,SZ */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x08000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 285 : FUTURE,PCONFIG,PRIV */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x40000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 286 : FUTURE,SERIALIZE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000001),UINT32_C(0x10000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 287 : FUTURE,PRIV,WBNOINVD */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x20000000),UINT32_C(0x00000000),UINT32_C(0x00004000)}}, /* 288 : FUTURE,TSXLDTRK */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x80000000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 289 : AVX512BF16,EVEX,FUTURE */
+    {{UINT32_C(0x00000100),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040002),UINT32_C(0x00004000)}}, /* 290 : AMXTILE,FUTURE,LONG,SZ,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040004),UINT32_C(0x00004000)}}, /* 291 : AMXBF16,FUTURE,LONG,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040008),UINT32_C(0x00004000)}}, /* 292 : AMXINT8,FUTURE,LONG,VEX */
+    {{UINT32_C(0x00000400),UINT32_C(0x000001a0),UINT32_C(0x00000000),UINT32_C(0x00040002),UINT32_C(0x00004000)}}, /* 293 : AMXTILE,FUTURE,LONG,MIB,SIB,SX,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040002),UINT32_C(0x00004000)}}, /* 294 : AMXTILE,FUTURE,LONG,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00400080),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 295 : AVX512FP16,AVX512VL,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00400000),UINT32_C(0x00080000),UINT32_C(0x00004000)}}, /* 296 : AVX512FP16,EVEX,FUTURE */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00800000),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 297 : AVX512FC16,FUTURE,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00800080),UINT32_C(0x00040000),UINT32_C(0x00004000)}}, /* 298 : AVX512FC16,AVX512VL,FUTURE,VEX */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00004000)}}, /* 299 : FUTURE,RAOINT,SD */
+    {{UINT32_C(0x00000020),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00004000)}}, /* 300 : FUTURE,LONG,RAOINT,SQ */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00000040),UINT32_C(0x00004000)}}, /* 301 : FUTURE,LONG,UINTR */
+    {{UINT32_C(0x00000010),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040080),UINT32_C(0x00004000)}}, /* 302 : CMPCCXADD,FUTURE,LONG,SD,VEX */
+    {{UINT32_C(0x00000020),UINT32_C(0x00000020),UINT32_C(0x00000000),UINT32_C(0x00040080),UINT32_C(0x00004000)}}, /* 303 : CMPCCXADD,FUTURE,LONG,SQ,VEX */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000021),UINT32_C(0x00000000),UINT32_C(0x00000200),UINT32_C(0x00004000)}}, /* 304 : FUTURE,LONG,PRIV,WRMSRNS */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000021),UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00004000)}}, /* 305 : FUTURE,LONG,MSRLIST,PRIV */
+    {{UINT32_C(0x00000004),UINT32_C(0x00000001),UINT32_C(0x00000000),UINT32_C(0x00004000),UINT32_C(0x00004000)}}, /* 306 : FUTURE,HRESET,PRIV,SB */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000400),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000040)}}, /* 307 : P6,UNDOC */
+    {{UINT32_C(0x00000000),UINT32_C(0x00000420),UINT32_C(0x00000000),UINT32_C(0x00000000),UINT32_C(0x00000400)}}, /* 308 : LONG,UNDOC,X86_64 */
+};
diff --git a/vere/ext/nasm/x86/iflaggen.h b/vere/ext/nasm/x86/iflaggen.h
new file mode 100644
index 0000000..fdaee3b
--- /dev/null
+++ b/vere/ext/nasm/x86/iflaggen.h
@@ -0,0 +1,287 @@
+/* This file is auto-generated. Don't edit. */
+#ifndef NASM_IFLAGGEN_H
+#define NASM_IFLAGGEN_H 1
+
+#define IF_SM                 0 /* Size match                                                       */
+#define IF_SM2                1 /* Size match first two operands                                    */
+#define IF_SB                 2 /* Unsized operands can't be non-byte                               */
+#define IF_SW                 3 /* Unsized operands can't be non-word                               */
+#define IF_SD                 4 /* Unsized operands can't be non-dword                              */
+#define IF_SQ                 5 /* Unsized operands can't be non-qword                              */
+#define IF_SO                 6 /* Unsized operands can't be non-oword                              */
+#define IF_SY                 7 /* Unsized operands can't be non-yword                              */
+#define IF_SZ                 8 /* Unsized operands can't be non-zword                              */
+#define IF_SIZE               9 /* Unsized operands must match the bitsize                          */
+#define IF_SX                10 /* Unsized operands not allowed                                     */
+#define IF_ANYSIZE           11 /* Ignore operand size even if explicit                             */
+#define IF_AR0               12 /* SB, SW, SD applies to argument 0                                 */
+#define IF_AR1               13 /* SB, SW, SD applies to argument 1                                 */
+#define IF_AR2               14 /* SB, SW, SD applies to argument 2                                 */
+#define IF_AR3               15 /* SB, SW, SD applies to argument 3                                 */
+#define IF_AR4               16 /* SB, SW, SD applies to argument 4                                 */
+#define IF_OPT               17 /* Optimizing assembly only                                         */
+#define IF_LATEVEX           18 /* Only if EVEX instructions are disabled                           */
+                                /* 18...31 reserved                                                 */
+#define IF_PRIV              32 /* Privileged instruction                                           */
+#define IF_SMM               33 /* Only valid in SMM                                                */
+#define IF_PROT              34 /* Protected mode only                                              */
+#define IF_LOCK              35 /* Lockable if operand 0 is memory                                  */
+#define IF_NOLONG            36 /* Not available in long mode                                       */
+#define IF_LONG              37 /* Long mode                                                        */
+#define IF_NOHLE             38 /* HLE prefixes forbidden                                           */
+#define IF_MIB               39 /* split base/index EA                                              */
+#define IF_SIB               40 /* SIB encoding required                                            */
+#define IF_BND               41 /* BND (0xF2) prefix available                                      */
+#define IF_UNDOC             42 /* Undocumented                                                     */
+#define IF_HLE               43 /* HLE prefixed                                                     */
+#define IF_FPU               44 /* FPU                                                              */
+#define IF_MMX               45 /* MMX                                                              */
+#define IF_3DNOW             46 /* 3DNow!                                                           */
+#define IF_SSE               47 /* SSE (KNI, MMX2)                                                  */
+#define IF_SSE2              48 /* SSE2                                                             */
+#define IF_SSE3              49 /* SSE3 (PNI)                                                       */
+#define IF_VMX               50 /* VMX                                                              */
+#define IF_SSSE3             51 /* SSSE3                                                            */
+#define IF_SSE4A             52 /* AMD SSE4a                                                        */
+#define IF_SSE41             53 /* SSE4.1                                                           */
+#define IF_SSE42             54 /* SSE4.2                                                           */
+#define IF_SSE5              55 /* SSE5                                                             */
+#define IF_AVX               56 /* AVX  (256-bit floating point)                                    */
+#define IF_AVX2              57 /* AVX2 (256-bit integer)                                           */
+#define IF_FMA               58 /*                                                                  */
+#define IF_BMI1              59 /*                                                                  */
+#define IF_BMI2              60 /*                                                                  */
+#define IF_TBM               61 /*                                                                  */
+#define IF_RTM               62 /*                                                                  */
+#define IF_INVPCID           63 /*                                                                  */
+#define IF_AVX512            64 /* AVX-512F (512-bit base architecture)                             */
+#define IF_AVX512CD          65 /* AVX-512 Conflict Detection                                       */
+#define IF_AVX512ER          66 /* AVX-512 Exponential and Reciprocal                               */
+#define IF_AVX512PF          67 /* AVX-512 Prefetch                                                 */
+#define IF_MPX               68 /* MPX                                                              */
+#define IF_SHA               69 /* SHA                                                              */
+#define IF_PREFETCHWT1       70 /* PREFETCHWT1                                                      */
+#define IF_AVX512VL          71 /* AVX-512 Vector Length Orthogonality                              */
+#define IF_AVX512DQ          72 /* AVX-512 Dword and Qword                                          */
+#define IF_AVX512BW          73 /* AVX-512 Byte and Word                                            */
+#define IF_AVX512IFMA        74 /* AVX-512 IFMA instructions                                        */
+#define IF_AVX512VBMI        75 /* AVX-512 VBMI instructions                                        */
+#define IF_AES               76 /* AES instructions                                                 */
+#define IF_VAES              77 /* AES AVX instructions                                             */
+#define IF_VPCLMULQDQ        78 /* AVX Carryless Multiplication                                     */
+#define IF_GFNI              79 /* Galois Field instructions                                        */
+#define IF_AVX512VBMI2       80 /* AVX-512 VBMI2 instructions                                       */
+#define IF_AVX512VNNI        81 /* AVX-512 VNNI instructions                                        */
+#define IF_AVX512BITALG      82 /* AVX-512 Bit Algorithm instructions                               */
+#define IF_AVX512VPOPCNTDQ   83 /* AVX-512 VPOPCNTD/VPOPCNTQ                                        */
+#define IF_AVX5124FMAPS      84 /* AVX-512 4-iteration multiply-add                                 */
+#define IF_AVX5124VNNIW      85 /* AVX-512 4-iteration dot product                                  */
+#define IF_AVX512FP16        86 /* AVX-512 FP16 instructions                                        */
+#define IF_AVX512FC16        87 /* AVX-512 FC16 instructions                                        */
+#define IF_SGX               88 /* Intel Software Guard Extensions (SGX)                            */
+#define IF_CET               89 /* Intel Control-Flow Enforcement Technology (CET)                  */
+#define IF_ENQCMD            90 /* Enqueue command instructions                                     */
+#define IF_PCONFIG           91 /* Platform configuration instruction                               */
+#define IF_WBNOINVD          92 /* Writeback and do not invalidate instruction                      */
+#define IF_TSXLDTRK          93 /* TSX suspend load address tracking                                */
+#define IF_SERIALIZE         94 /* SERIALIZE instruction                                            */
+#define IF_AVX512BF16        95 /* AVX-512 bfloat16                                                 */
+#define IF_AVX512VP2INTERSECT  96 /* AVX-512 VP2INTERSECT instructions                                */
+#define IF_AMXTILE           97 /* AMX tile configuration instructions                              */
+#define IF_AMXBF16           98 /* AMX bfloat16 multiplication                                      */
+#define IF_AMXINT8           99 /* AMX 8-bit integer multiplication                                 */
+#define IF_FRED             100 /* Flexible Return and Exception Delivery (FRED)                    */
+#define IF_RAOINT           101 /* Remote atomic operations (RAO-INT)                               */
+#define IF_UINTR            102 /* User interrupts                                                  */
+#define IF_CMPCCXADD        103 /* CMPccXADD instructions                                           */
+#define IF_PREFETCHI        104 /* PREFETCHI0 and PREFETCHI1                                        */
+#define IF_WRMSRNS          105 /* WRMSRNS                                                          */
+#define IF_MSRLIST          106 /* RDMSRLIST and WRMSRLIST                                          */
+#define IF_AVXNECONVERT     107 /* AVX exceptionless floating-point conversions                     */
+#define IF_AVXVNNIINT8      108 /* AVX Vector Neural Network 8-bit integer instructions             */
+#define IF_AVXIFMA          109 /* AVX integer multiply and add                                     */
+#define IF_HRESET           110 /* History reset                                                    */
+#define IF_OBSOLETE         111 /* Instruction removed from architecture                            */
+#define IF_NEVER            112 /* Instruction never implemented                                    */
+#define IF_NOP              113 /* Instruction is always a (nonintentional) NOP                     */
+#define IF_VEX              114 /* VEX or XOP encoded instruction                                   */
+#define IF_EVEX             115 /* EVEX encoded instruction                                         */
+                                /* 115...127 reserved                                               */
+#define IF_8086             128 /* 8086                                                             */
+#define IF_186              129 /* 186+                                                             */
+#define IF_286              130 /* 286+                                                             */
+#define IF_386              131 /* 386+                                                             */
+#define IF_486              132 /* 486+                                                             */
+#define IF_PENT             133 /* Pentium                                                          */
+#define IF_P6               134 /* P6                                                               */
+#define IF_KATMAI           135 /* Katmai                                                           */
+#define IF_WILLAMETTE       136 /* Willamette                                                       */
+#define IF_PRESCOTT         137 /* Prescott                                                         */
+#define IF_X86_64           138 /* x86-64 (long or legacy mode)                                     */
+#define IF_NEHALEM          139 /* Nehalem                                                          */
+#define IF_WESTMERE         140 /* Westmere                                                         */
+#define IF_SANDYBRIDGE      141 /* Sandy Bridge                                                     */
+#define IF_FUTURE           142 /* Ivy Bridge or newer                                              */
+#define IF_IA64             143 /* IA64 (in x86 mode)                                               */
+#define IF_DEFAULT          144 /* Default CPU level                                                */
+#define IF_ANY              145 /* Allow any known instruction                                      */
+#define IF_CYRIX            146 /* Cyrix-specific                                                   */
+#define IF_AMD              147 /* AMD-specific                                                     */
+                                /* 147...159 reserved                                               */
+
+/* Mask bits for field 0 : 0...31 */
+#define IFM_SM              UINT32_C(0x00000001)     /*   0 */
+#define IFM_SM2             UINT32_C(0x00000002)     /*   1 */
+#define IFM_SB              UINT32_C(0x00000004)     /*   2 */
+#define IFM_SW              UINT32_C(0x00000008)     /*   3 */
+#define IFM_SD              UINT32_C(0x00000010)     /*   4 */
+#define IFM_SQ              UINT32_C(0x00000020)     /*   5 */
+#define IFM_SO              UINT32_C(0x00000040)     /*   6 */
+#define IFM_SY              UINT32_C(0x00000080)     /*   7 */
+#define IFM_SZ              UINT32_C(0x00000100)     /*   8 */
+#define IFM_SIZE            UINT32_C(0x00000200)     /*   9 */
+#define IFM_SX              UINT32_C(0x00000400)     /*  10 */
+#define IFM_ANYSIZE         UINT32_C(0x00000800)     /*  11 */
+#define IFM_AR0             UINT32_C(0x00001000)     /*  12 */
+#define IFM_AR1             UINT32_C(0x00002000)     /*  13 */
+#define IFM_AR2             UINT32_C(0x00004000)     /*  14 */
+#define IFM_AR3             UINT32_C(0x00008000)     /*  15 */
+#define IFM_AR4             UINT32_C(0x00010000)     /*  16 */
+#define IFM_OPT             UINT32_C(0x00020000)     /*  17 */
+#define IFM_LATEVEX         UINT32_C(0x00040000)     /*  18 */
+/* Mask bits for field 1 : 32...63 */
+#define IFM_PRIV            UINT32_C(0x00000001)     /*  32 */
+#define IFM_SMM             UINT32_C(0x00000002)     /*  33 */
+#define IFM_PROT            UINT32_C(0x00000004)     /*  34 */
+#define IFM_LOCK            UINT32_C(0x00000008)     /*  35 */
+#define IFM_NOLONG          UINT32_C(0x00000010)     /*  36 */
+#define IFM_LONG            UINT32_C(0x00000020)     /*  37 */
+#define IFM_NOHLE           UINT32_C(0x00000040)     /*  38 */
+#define IFM_MIB             UINT32_C(0x00000080)     /*  39 */
+#define IFM_SIB             UINT32_C(0x00000100)     /*  40 */
+#define IFM_BND             UINT32_C(0x00000200)     /*  41 */
+#define IFM_UNDOC           UINT32_C(0x00000400)     /*  42 */
+#define IFM_HLE             UINT32_C(0x00000800)     /*  43 */
+#define IFM_FPU             UINT32_C(0x00001000)     /*  44 */
+#define IFM_MMX             UINT32_C(0x00002000)     /*  45 */
+#define IFM_3DNOW           UINT32_C(0x00004000)     /*  46 */
+#define IFM_SSE             UINT32_C(0x00008000)     /*  47 */
+#define IFM_SSE2            UINT32_C(0x00010000)     /*  48 */
+#define IFM_SSE3            UINT32_C(0x00020000)     /*  49 */
+#define IFM_VMX             UINT32_C(0x00040000)     /*  50 */
+#define IFM_SSSE3           UINT32_C(0x00080000)     /*  51 */
+#define IFM_SSE4A           UINT32_C(0x00100000)     /*  52 */
+#define IFM_SSE41           UINT32_C(0x00200000)     /*  53 */
+#define IFM_SSE42           UINT32_C(0x00400000)     /*  54 */
+#define IFM_SSE5            UINT32_C(0x00800000)     /*  55 */
+#define IFM_AVX             UINT32_C(0x01000000)     /*  56 */
+#define IFM_AVX2            UINT32_C(0x02000000)     /*  57 */
+#define IFM_FMA             UINT32_C(0x04000000)     /*  58 */
+#define IFM_BMI1            UINT32_C(0x08000000)     /*  59 */
+#define IFM_BMI2            UINT32_C(0x10000000)     /*  60 */
+#define IFM_TBM             UINT32_C(0x20000000)     /*  61 */
+#define IFM_RTM             UINT32_C(0x40000000)     /*  62 */
+#define IFM_INVPCID         UINT32_C(0x80000000)     /*  63 */
+/* Mask bits for field 2 : 64...95 */
+#define IFM_AVX512          UINT32_C(0x00000001)     /*  64 */
+#define IFM_AVX512CD        UINT32_C(0x00000002)     /*  65 */
+#define IFM_AVX512ER        UINT32_C(0x00000004)     /*  66 */
+#define IFM_AVX512PF        UINT32_C(0x00000008)     /*  67 */
+#define IFM_MPX             UINT32_C(0x00000010)     /*  68 */
+#define IFM_SHA             UINT32_C(0x00000020)     /*  69 */
+#define IFM_PREFETCHWT1     UINT32_C(0x00000040)     /*  70 */
+#define IFM_AVX512VL        UINT32_C(0x00000080)     /*  71 */
+#define IFM_AVX512DQ        UINT32_C(0x00000100)     /*  72 */
+#define IFM_AVX512BW        UINT32_C(0x00000200)     /*  73 */
+#define IFM_AVX512IFMA      UINT32_C(0x00000400)     /*  74 */
+#define IFM_AVX512VBMI      UINT32_C(0x00000800)     /*  75 */
+#define IFM_AES             UINT32_C(0x00001000)     /*  76 */
+#define IFM_VAES            UINT32_C(0x00002000)     /*  77 */
+#define IFM_VPCLMULQDQ      UINT32_C(0x00004000)     /*  78 */
+#define IFM_GFNI            UINT32_C(0x00008000)     /*  79 */
+#define IFM_AVX512VBMI2     UINT32_C(0x00010000)     /*  80 */
+#define IFM_AVX512VNNI      UINT32_C(0x00020000)     /*  81 */
+#define IFM_AVX512BITALG    UINT32_C(0x00040000)     /*  82 */
+#define IFM_AVX512VPOPCNTDQ UINT32_C(0x00080000)     /*  83 */
+#define IFM_AVX5124FMAPS    UINT32_C(0x00100000)     /*  84 */
+#define IFM_AVX5124VNNIW    UINT32_C(0x00200000)     /*  85 */
+#define IFM_AVX512FP16      UINT32_C(0x00400000)     /*  86 */
+#define IFM_AVX512FC16      UINT32_C(0x00800000)     /*  87 */
+#define IFM_SGX             UINT32_C(0x01000000)     /*  88 */
+#define IFM_CET             UINT32_C(0x02000000)     /*  89 */
+#define IFM_ENQCMD          UINT32_C(0x04000000)     /*  90 */
+#define IFM_PCONFIG         UINT32_C(0x08000000)     /*  91 */
+#define IFM_WBNOINVD        UINT32_C(0x10000000)     /*  92 */
+#define IFM_TSXLDTRK        UINT32_C(0x20000000)     /*  93 */
+#define IFM_SERIALIZE       UINT32_C(0x40000000)     /*  94 */
+#define IFM_AVX512BF16      UINT32_C(0x80000000)     /*  95 */
+/* Mask bits for field 3 : 96...127 */
+#define IFM_AVX512VP2INTERSECT UINT32_C(0x00000001)     /*  96 */
+#define IFM_AMXTILE         UINT32_C(0x00000002)     /*  97 */
+#define IFM_AMXBF16         UINT32_C(0x00000004)     /*  98 */
+#define IFM_AMXINT8         UINT32_C(0x00000008)     /*  99 */
+#define IFM_FRED            UINT32_C(0x00000010)     /* 100 */
+#define IFM_RAOINT          UINT32_C(0x00000020)     /* 101 */
+#define IFM_UINTR           UINT32_C(0x00000040)     /* 102 */
+#define IFM_CMPCCXADD       UINT32_C(0x00000080)     /* 103 */
+#define IFM_PREFETCHI       UINT32_C(0x00000100)     /* 104 */
+#define IFM_WRMSRNS         UINT32_C(0x00000200)     /* 105 */
+#define IFM_MSRLIST         UINT32_C(0x00000400)     /* 106 */
+#define IFM_AVXNECONVERT    UINT32_C(0x00000800)     /* 107 */
+#define IFM_AVXVNNIINT8     UINT32_C(0x00001000)     /* 108 */
+#define IFM_AVXIFMA         UINT32_C(0x00002000)     /* 109 */
+#define IFM_HRESET          UINT32_C(0x00004000)     /* 110 */
+#define IFM_OBSOLETE        UINT32_C(0x00008000)     /* 111 */
+#define IFM_NEVER           UINT32_C(0x00010000)     /* 112 */
+#define IFM_NOP             UINT32_C(0x00020000)     /* 113 */
+#define IFM_VEX             UINT32_C(0x00040000)     /* 114 */
+#define IFM_EVEX            UINT32_C(0x00080000)     /* 115 */
+/* Mask bits for field 4 : 128...159 */
+#define IFM_8086            UINT32_C(0x00000001)     /* 128 */
+#define IFM_186             UINT32_C(0x00000002)     /* 129 */
+#define IFM_286             UINT32_C(0x00000004)     /* 130 */
+#define IFM_386             UINT32_C(0x00000008)     /* 131 */
+#define IFM_486             UINT32_C(0x00000010)     /* 132 */
+#define IFM_PENT            UINT32_C(0x00000020)     /* 133 */
+#define IFM_P6              UINT32_C(0x00000040)     /* 134 */
+#define IFM_KATMAI          UINT32_C(0x00000080)     /* 135 */
+#define IFM_WILLAMETTE      UINT32_C(0x00000100)     /* 136 */
+#define IFM_PRESCOTT        UINT32_C(0x00000200)     /* 137 */
+#define IFM_X86_64          UINT32_C(0x00000400)     /* 138 */
+#define IFM_NEHALEM         UINT32_C(0x00000800)     /* 139 */
+#define IFM_WESTMERE        UINT32_C(0x00001000)     /* 140 */
+#define IFM_SANDYBRIDGE     UINT32_C(0x00002000)     /* 141 */
+#define IFM_FUTURE          UINT32_C(0x00004000)     /* 142 */
+#define IFM_IA64            UINT32_C(0x00008000)     /* 143 */
+#define IFM_DEFAULT         UINT32_C(0x00010000)     /* 144 */
+#define IFM_ANY             UINT32_C(0x00020000)     /* 145 */
+#define IFM_CYRIX           UINT32_C(0x00040000)     /* 146 */
+#define IFM_AMD             UINT32_C(0x00080000)     /* 147 */
+
+/* IF_SM (0) ... IF_LATEVEX (18) */
+#define IF_IGEN_FIRST         0
+#define IF_IGEN_COUNT        19
+#define IF_IGEN_FIELD         0
+#define IF_IGEN_NFIELDS       1
+
+/* IF_PRIV (32) ... IF_EVEX (115) */
+#define IF_FEATURE_FIRST     32
+#define IF_FEATURE_COUNT     84
+#define IF_FEATURE_FIELD      1
+#define IF_FEATURE_NFIELDS    3
+
+/* IF_8086 (128) ... IF_AMD (147) */
+#define IF_CPU_FIRST        128
+#define IF_CPU_COUNT         20
+#define IF_CPU_FIELD          4
+#define IF_CPU_NFIELDS        1
+
+#define IF_FIELD_COUNT 5
+typedef struct {
+    uint32_t field[IF_FIELD_COUNT];
+} iflag_t;
+
+/* All combinations of instruction flags used in instruction patterns */
+extern const iflag_t insns_flags[309];
+
+#endif /* NASM_IFLAGGEN_H */
diff --git a/vere/ext/nasm/x86/iflags.ph b/vere/ext/nasm/x86/iflags.ph
new file mode 100644
index 0000000..ffeb8e5
--- /dev/null
+++ b/vere/ext/nasm/x86/iflags.ph
@@ -0,0 +1,153 @@
+# -*- perl -*-
+
+#
+# dword bound, index 0 - specific flags
+#
+if_align('IGEN');
+
+if_("SM",                "Size match");
+if_("SM2",               "Size match first two operands");
+if_("SB",                "Unsized operands can't be non-byte");
+if_("SW",                "Unsized operands can't be non-word");
+if_("SD",                "Unsized operands can't be non-dword");
+if_("SQ",                "Unsized operands can't be non-qword");
+if_("SO",                "Unsized operands can't be non-oword");
+if_("SY",                "Unsized operands can't be non-yword");
+if_("SZ",                "Unsized operands can't be non-zword");
+if_("SIZE",              "Unsized operands must match the bitsize");
+if_("SX",                "Unsized operands not allowed");
+if_("ANYSIZE",           "Ignore operand size even if explicit");
+if_("AR0",               "SB, SW, SD applies to argument 0");
+if_("AR1",               "SB, SW, SD applies to argument 1");
+if_("AR2",               "SB, SW, SD applies to argument 2");
+if_("AR3",               "SB, SW, SD applies to argument 3");
+if_("AR4",               "SB, SW, SD applies to argument 4");
+if_("OPT",               "Optimizing assembly only");
+if_("LATEVEX",            "Only if EVEX instructions are disabled");
+
+#
+# dword bound - instruction feature filtering flags
+#
+if_align('FEATURE');
+
+if_("PRIV",              "Privileged instruction");
+if_("SMM",               "Only valid in SMM");
+if_("PROT",              "Protected mode only");
+if_("LOCK",              "Lockable if operand 0 is memory");
+if_("NOLONG",            "Not available in long mode");
+if_("LONG",              "Long mode");
+if_("NOHLE",             "HLE prefixes forbidden");
+if_("MIB",               "split base/index EA");
+if_("SIB",               "SIB encoding required");
+if_("BND",               "BND (0xF2) prefix available");
+if_("UNDOC",             "Undocumented");
+if_("HLE",               "HLE prefixed");
+if_("FPU",               "FPU");
+if_("MMX",               "MMX");
+if_("3DNOW",             "3DNow!");
+if_("SSE",               "SSE (KNI, MMX2)");
+if_("SSE2",              "SSE2");
+if_("SSE3",              "SSE3 (PNI)");
+if_("VMX",               "VMX");
+if_("SSSE3",             "SSSE3");
+if_("SSE4A",             "AMD SSE4a");
+if_("SSE41",             "SSE4.1");
+if_("SSE42",             "SSE4.2");
+if_("SSE5",              "SSE5");
+if_("AVX",               "AVX  (256-bit floating point)");
+if_("AVX2",              "AVX2 (256-bit integer)");
+if_("FMA",               "");
+if_("BMI1",              "");
+if_("BMI2",              "");
+if_("TBM",               "");
+if_("RTM",               "");
+if_("INVPCID",           "");
+if_("AVX512",            "AVX-512F (512-bit base architecture)");
+if_("AVX512CD",          "AVX-512 Conflict Detection");
+if_("AVX512ER",          "AVX-512 Exponential and Reciprocal");
+if_("AVX512PF",          "AVX-512 Prefetch");
+if_("MPX",               "MPX");
+if_("SHA",               "SHA");
+if_("PREFETCHWT1",       "PREFETCHWT1");
+if_("AVX512VL",          "AVX-512 Vector Length Orthogonality");
+if_("AVX512DQ",          "AVX-512 Dword and Qword");
+if_("AVX512BW",          "AVX-512 Byte and Word");
+if_("AVX512IFMA",        "AVX-512 IFMA instructions");
+if_("AVX512VBMI",        "AVX-512 VBMI instructions");
+if_("AES",               "AES instructions");
+if_("VAES",              "AES AVX instructions");
+if_("VPCLMULQDQ",        "AVX Carryless Multiplication");
+if_("GFNI",              "Galois Field instructions");
+if_("AVX512VBMI2",       "AVX-512 VBMI2 instructions");
+if_("AVX512VNNI",        "AVX-512 VNNI instructions");
+if_("AVX512BITALG",      "AVX-512 Bit Algorithm instructions");
+if_("AVX512VPOPCNTDQ",   "AVX-512 VPOPCNTD/VPOPCNTQ");
+if_("AVX5124FMAPS",      "AVX-512 4-iteration multiply-add");
+if_("AVX5124VNNIW",      "AVX-512 4-iteration dot product");
+if_("AVX512FP16",        "AVX-512 FP16 instructions");
+if_("AVX512FC16",        "AVX-512 FC16 instructions");
+if_("SGX",               "Intel Software Guard Extensions (SGX)");
+if_("CET",               "Intel Control-Flow Enforcement Technology (CET)");
+if_("ENQCMD",            "Enqueue command instructions");
+if_("PCONFIG",           "Platform configuration instruction");
+if_("WBNOINVD",          "Writeback and do not invalidate instruction");
+if_("TSXLDTRK",          "TSX suspend load address tracking");
+if_("SERIALIZE",         "SERIALIZE instruction");
+if_("AVX512BF16",        "AVX-512 bfloat16");
+if_("AVX512VP2INTERSECT", "AVX-512 VP2INTERSECT instructions");
+if_("AMXTILE",           "AMX tile configuration instructions");
+if_("AMXBF16",           "AMX bfloat16 multiplication");
+if_("AMXINT8",           "AMX 8-bit integer multiplication");
+if_("FRED",              "Flexible Return and Exception Delivery (FRED)");
+if_("RAOINT",		 "Remote atomic operations (RAO-INT)");
+if_("UINTR",		 "User interrupts");
+if_("CMPCCXADD",         "CMPccXADD instructions");
+if_("PREFETCHI",         "PREFETCHI0 and PREFETCHI1");
+if_("WRMSRNS",		 "WRMSRNS");
+if_("MSRLIST",           "RDMSRLIST and WRMSRLIST");
+if_("AVXNECONVERT",	 "AVX exceptionless floating-point conversions");
+if_("AVXVNNIINT8",       "AVX Vector Neural Network 8-bit integer instructions");
+if_("AVXIFMA",           "AVX integer multiply and add");
+if_("HRESET",            "History reset");
+
+# Put these last to minimize their relevance
+if_("OBSOLETE",          "Instruction removed from architecture");
+if_("NEVER",             "Instruction never implemented");
+if_("NOP",               "Instruction is always a (nonintentional) NOP");
+if_("VEX",               "VEX or XOP encoded instruction");
+if_("EVEX",              "EVEX encoded instruction");
+
+#
+# dword bound - cpu type flags
+#
+# The CYRIX and AMD flags should have the highest bit values; the
+# disassembler selection algorithm depends on it.
+#
+if_align('CPU');
+
+if_("8086",              "8086");
+if_("186",               "186+");
+if_("286",               "286+");
+if_("386",               "386+");
+if_("486",               "486+");
+if_("PENT",              "Pentium");
+if_("P6",                "P6");
+if_("KATMAI",            "Katmai");
+if_("WILLAMETTE",        "Willamette");
+if_("PRESCOTT",          "Prescott");
+if_("X86_64",            "x86-64 (long or legacy mode)");
+if_("NEHALEM",           "Nehalem");
+if_("WESTMERE",          "Westmere");
+if_("SANDYBRIDGE",       "Sandy Bridge");
+if_("FUTURE",            "Ivy Bridge or newer");
+if_("IA64",              "IA64 (in x86 mode)");
+
+# Default CPU level
+if_("DEFAULT",           "Default CPU level");
+
+# Must be the last CPU definition
+if_("ANY",               "Allow any known instruction");
+
+# These must come after the CPU definitions proper
+if_("CYRIX",             "Cyrix-specific");
+if_("AMD",               "AMD-specific");
diff --git a/vere/ext/nasm/x86/insns-iflags.ph b/vere/ext/nasm/x86/insns-iflags.ph
new file mode 100644
index 0000000..3c73be9
--- /dev/null
+++ b/vere/ext/nasm/x86/insns-iflags.ph
@@ -0,0 +1,251 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2018 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# Instruction template flags. These specify which processor
+# targets the instruction is eligible for, whether it is
+# privileged or undocumented, and also specify extra error
+# checking on the matching of the instruction.
+#
+# IF_SM stands for Size Match: any operand whose size is not
+# explicitly specified by the template is `really' intended to be
+# the same size as the first size-specified operand.
+# Non-specification is tolerated in the input instruction, but
+# _wrong_ specification is not.
+#
+# IF_SM2 invokes Size Match on only the first _two_ operands, for
+# three-operand instructions such as SHLD: it implies that the
+# first two operands must match in size, but that the third is
+# required to be _unspecified_.
+#
+# IF_SB invokes Size Byte: operands with unspecified size in the
+# template are really bytes, and so no non-byte specification in
+# the input instruction will be tolerated. IF_SW similarly invokes
+# Size Word, and IF_SD invokes Size Doubleword.
+#
+# (The default state if neither IF_SM nor IF_SM2 is specified is
+# that any operand with unspecified size in the template is
+# required to have unspecified size in the instruction too...)
+#
+# iflag_t is defined to store these flags.
+#
+# The order does matter here. We use some predefined masks to quick test
+# for a set of flags, so be careful moving bits (and
+# don't forget to update C code generation then).
+#
+sub dword_align($) {
+    my($n) = @_;
+
+    $$n = ($$n + 31) & ~31;
+    return $n;
+}
+
+
+my $n_iflags = 0;
+my %flag_byname;
+my @flag_bynum;
+my @flag_fields;
+my $iflag_words;
+
+sub if_($$) {
+    my($name, $def) = @_;
+    my $num = $n_iflags++;
+    my $v = [$num, $name, $def];
+
+    $flag_byname{$name}  = $v;
+    $flag_bynum[$num] = $v;
+
+    return 1;
+}
+sub if_align($) {
+    my($name) = @_;
+
+    if ($#flag_fields >= 0) {
+	$flag_fields[$#flag_fields]->[2] = $n_iflags-1;
+    }
+    $n_iflags = ($n_iflags + 31) & ~31;
+
+    if (defined($name)) {
+	push(@flag_fields, [$name, $n_iflags, undef]);
+    }
+
+    return 1;
+}
+
+sub if_end() {
+    if_align(undef);
+    $iflag_words = $n_iflags >> 5;
+}
+
+# The actual flags definitions
+require 'x86/iflags.ph';
+if_end();
+
+# Compute the combinations of instruction flags actually used in templates
+
+my %insns_flag_hash = ();
+my @insns_flag_values = ();
+my @insns_flag_lists = ();
+
+sub insns_flag_index(@) {
+    return undef if $_[0] eq "ignore";
+
+    my @prekey = sort(@_);
+    my $key = join(',', @prekey);
+    my $flag_index = $insns_flag_hash{$key};
+
+    unless (defined($flag_index)) {
+        my @newkey = (0) x $iflag_words;
+
+        foreach my $i (@prekey) {
+	    my $flag = $flag_byname{$i};
+            die "No key for $i (in $key)\n" if not defined($flag);
+	    $newkey[$flag->[0] >> 5] |= (1 << ($flag->[0] & 31));
+        }
+
+	my $str = join(',', map { sprintf("UINT32_C(0x%08x)",$_) } @newkey);
+
+        push @insns_flag_values, $str;
+	push @insns_flag_lists, $key;
+        $insns_flag_hash{$key} = $flag_index = $#insns_flag_values;
+    }
+
+    return $flag_index;
+}
+
+sub write_iflaggen_h() {
+    print STDERR "Writing $oname...\n";
+
+    open(N, '>', $oname) or die "$0: $!\n";
+
+    print N "/* This file is auto-generated. Don't edit. */\n";
+    print N "#ifndef NASM_IFLAGGEN_H\n";
+    print N "#define NASM_IFLAGGEN_H 1\n\n";
+
+    # The flag numbers; the <= in the loop is intentional
+
+    my $next = 0;
+    for ($i = 0; $i <= $n_iflags; $i++) {
+	if ((defined($flag_bynum[$i]) || $i >= $n_iflags) &&
+	    $next != $i) {
+	    printf N "%-31s /* %-64s */\n", '',
+		($next < $i-1) ?
+		sprintf("%d...%d reserved", $next-1, $i-1) :
+		sprintf("%d reserved", $i-1);
+	}
+
+	if (defined($flag_bynum[$i])) {
+	    printf N "#define IF_%-16s %3d /* %-64s */\n",
+		$flag_bynum[$i]->[1], $i, $flag_bynum[$i]->[2];
+	    $next = $i+1;
+	}
+    }
+    print N "\n";
+
+    # The flag masks for individual bits
+
+    $next = 0;
+    for ($i = 0; $i < $n_iflags; $i++) {
+	if (($i & 31) == 0) {
+	    printf N "/* Mask bits for field %d : %d...%d */\n",
+		$i >> 5, $i, $i+31;
+	}
+	if (defined(my $v = $flag_bynum[$i])) {
+	    printf N "#define IFM_%-15s UINT32_C(0x%08x)     /* %3d */\n",
+		$v->[1], 1 << ($i & 31), $i;
+	    $next = $i+1;
+	}
+    }
+    print N "\n";
+
+    # The names of flag groups
+
+    for ($i = 0; $i <= $#flag_fields; $i++) {
+	printf N "/* IF_%s (%d) ... IF_%s (%d) */\n",
+		    $flag_bynum[$flag_fields[$i]->[1]]->[1],
+		    $flag_bynum[$flag_fields[$i]->[1]]->[0],
+		    $flag_bynum[$flag_fields[$i]->[2]]->[1],
+		    $flag_bynum[$flag_fields[$i]->[2]]->[0];
+
+	# Bit definitions
+	printf N "#define %-19s %3d\n",
+	    'IF_'.$flag_fields[$i]->[0].'_FIRST',
+	    $flag_fields[$i]->[1];
+	printf N "#define %-19s %3d\n",
+	    'IF_'.$flag_fields[$i]->[0].'_COUNT',
+	    ($flag_fields[$i]->[2] - $flag_fields[$i]->[1] + 1);
+
+	# Field (uint32) definitions
+	printf N "#define %-19s %3d\n",
+	    'IF_'.$flag_fields[$i]->[0].'_FIELD',
+	    $flag_fields[$i]->[1] >> 5;
+	printf N "#define %-19s %3d\n",
+	    'IF_'.$flag_fields[$i]->[0].'_NFIELDS',
+	    ($flag_fields[$i]->[2] - $flag_fields[$i]->[1] + 31) >> 5;
+	print N "\n";
+    }
+
+    printf N "#define IF_FIELD_COUNT %d\n", $iflag_words;
+    print N "typedef struct {\n";
+    print N "    uint32_t field[IF_FIELD_COUNT];\n";
+    print N "} iflag_t;\n";
+
+    print N "\n";
+    print N "/* All combinations of instruction flags used in instruction patterns */\n";
+    printf N "extern const iflag_t insns_flags[%d];\n\n",
+	$#insns_flag_values + 1;
+
+    print N "#endif /* NASM_IFLAGGEN_H */\n";
+    close N;
+}
+
+sub write_iflag_c() {
+    print STDERR "Writing $oname...\n";
+
+    open(N, '>', $oname) or die "$0: $!\n";
+
+    print N "/* This file is auto-generated. Don't edit. */\n";
+    print N "#include \"iflag.h\"\n\n";
+    print N "/* All combinations of instruction flags used in instruction patterns */\n";
+    printf N "const iflag_t insns_flags[%d] = {\n",
+        $#insns_flag_values + 1;
+    foreach my $i (0 .. $#insns_flag_values) {
+        printf N "    {{%s}}, /* %3d : %s */\n",
+	    $insns_flag_values[$i], $i, $insns_flag_lists[$i];
+    }
+    print N "};\n";
+    close N;
+}
+
+1;
diff --git a/vere/ext/nasm/x86/insns.dat b/vere/ext/nasm/x86/insns.dat
new file mode 100644
index 0000000..17a3f10
--- /dev/null
+++ b/vere/ext/nasm/x86/insns.dat
@@ -0,0 +1,6570 @@
+;; --------------------------------------------------------------------------
+;;
+;;   Copyright 1996-2022 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+
+;
+; insns.dat    table of instructions for the Netwide Assembler
+;
+; Format of file: All four fields must be present on every functional
+; line. Hence `void' for no-operand instructions, and `\0' for such
+; as EQU. If the last three fields are all `ignore', no action is
+; taken except to register the opcode as being present.
+;
+; For a detailed description of the code string (third field), please
+; see insns.pl and the comment at the top of assemble.c. For a detailed
+; description of the flags (fourth field), please see insns-iflags.ph.
+;
+; Comments with a pound sign after the semicolon generate section
+; subheaders in the NASM documentation.
+;
+
+;# Special instructions (pseudo-ops)
+; These MUST be first in this file and must maintain the pattern of
+; Dx by size, RESx by size, and INCBIN in that order.
+DB		ignore				ignore						ignore
+DW		ignore				ignore						ignore
+DD		ignore				ignore						ignore
+DQ		ignore				ignore						ignore
+DT		ignore				ignore						ignore
+DO		ignore				ignore						ignore
+DY		ignore				ignore						ignore
+DZ		ignore				ignore						ignore
+RESB		imm				[	resb]					8086
+RESW		imm				[	resb]					8086
+RESD		imm				[	resb]					8086
+RESQ		imm				[	resb]					8086
+REST		imm				[	resb]					8086
+RESO		imm				[	resb]					8086
+RESY		imm				[	resb]					8086
+RESZ		imm				[	resb]					8086
+INCBIN		ignore				ignore						ignore
+
+;# Conventional instructions
+AAA		void				[	37]					8086,NOLONG
+AAD		void				[	d5 0a]					8086,NOLONG
+AAD		imm				[i:	d5 ib,u]				8086,SB,NOLONG
+AAM		void				[	d4 0a]					8086,NOLONG
+AAM		imm				[i:	d4 ib,u]				8086,SB,NOLONG
+AAS		void				[	3f]					8086,NOLONG
+ADC		mem,reg8			[mr:	hle 10 /r]				8086,SM,LOCK
+ADC		reg8,reg8			[mr:	10 /r]					8086
+ADC		mem,reg16			[mr:	hle o16 11 /r]				8086,SM,LOCK
+ADC		reg16,reg16			[mr:	o16 11 /r]				8086
+ADC		mem,reg32			[mr:	hle o32 11 /r]				386,SM,LOCK
+ADC		reg32,reg32			[mr:	o32 11 /r]				386
+ADC		mem,reg64			[mr:	hle o64 11 /r]				X86_64,LONG,SM,LOCK
+ADC		reg64,reg64			[mr:	o64 11 /r]				X86_64,LONG
+ADC		reg8,mem			[rm:	12 /r]					8086,SM
+ADC		reg8,reg8			[rm:	12 /r]					8086
+ADC		reg16,mem			[rm:	o16 13 /r]				8086,SM
+ADC		reg16,reg16			[rm:	o16 13 /r]				8086
+ADC		reg32,mem			[rm:	o32 13 /r]				386,SM
+ADC		reg32,reg32			[rm:	o32 13 /r]				386
+ADC		reg64,mem			[rm:	o64 13 /r]				X86_64,LONG,SM
+ADC		reg64,reg64			[rm:	o64 13 /r]				X86_64,LONG
+ADC		rm16,imm8			[mi:	hle o16 83 /2 ib,s]			8086,LOCK
+ADC		rm32,imm8			[mi:	hle o32 83 /2 ib,s]			386,LOCK
+ADC		rm64,imm8			[mi:	hle o64 83 /2 ib,s]			X86_64,LONG,LOCK
+ADC		reg_al,imm			[-i:	14 ib]					8086,SM
+ADC		reg_ax,sbyteword		[mi:	o16 83 /2 ib,s]				8086,SM,ND
+ADC		reg_ax,imm			[-i:	o16 15 iw]				8086,SM
+ADC		reg_eax,sbytedword		[mi:	o32 83 /2 ib,s]				386,SM,ND
+ADC		reg_eax,imm			[-i:	o32 15 id]				386,SM
+ADC		reg_rax,sbytedword		[mi:	o64 83 /2 ib,s]				X86_64,LONG,SM,ND
+ADC		reg_rax,imm			[-i:	o64 15 id,s]				X86_64,LONG,SM
+ADC		rm8,imm				[mi:	hle 80 /2 ib]				8086,SM,LOCK
+ADC		rm16,sbyteword			[mi:	hle o16 83 /2 ib,s]			8086,SM,LOCK,ND
+ADC		rm16,imm			[mi:	hle o16 81 /2 iw]			8086,SM,LOCK
+ADC		rm32,sbytedword			[mi:	hle o32 83 /2 ib,s]			386,SM,LOCK,ND
+ADC		rm32,imm			[mi:	hle o32 81 /2 id]			386,SM,LOCK
+ADC		rm64,sbytedword			[mi:	hle o64 83 /2 ib,s]			X86_64,LONG,SM,LOCK,ND
+ADC		rm64,imm			[mi:	hle o64 81 /2 id,s]			X86_64,LONG,SM,LOCK
+ADC		mem,imm8			[mi:	hle 80 /2 ib]				8086,SM,LOCK,ND
+ADC		mem,sbyteword16			[mi:	hle o16 83 /2 ib,s]			8086,SM,LOCK,ND
+ADC		mem,imm16			[mi:	hle o16 81 /2 iw]			8086,SM,LOCK
+ADC		mem,sbytedword32		[mi:	hle o32 83 /2 ib,s]			386,SM,LOCK,ND
+ADC		mem,imm32			[mi:	hle o32 81 /2 id]			386,SM,LOCK
+ADC		rm8,imm				[mi:	hle 82 /2 ib]				8086,SM,LOCK,ND,NOLONG
+ADD		mem,reg8			[mr:	hle 00 /r]				8086,SM,LOCK
+ADD		reg8,reg8			[mr:	00 /r]					8086
+ADD		mem,reg16			[mr:	hle o16 01 /r]				8086,SM,LOCK
+ADD		reg16,reg16			[mr:	o16 01 /r]				8086
+ADD		mem,reg32			[mr:	hle o32 01 /r]				386,SM,LOCK
+ADD		reg32,reg32			[mr:	o32 01 /r]				386
+ADD		mem,reg64			[mr:	hle o64 01 /r]				X86_64,LONG,SM,LOCK
+ADD		reg64,reg64			[mr:	o64 01 /r]				X86_64,LONG
+ADD		reg8,mem			[rm:	02 /r]					8086,SM
+ADD		reg8,reg8			[rm:	02 /r]					8086
+ADD		reg16,mem			[rm:	o16 03 /r]				8086,SM
+ADD		reg16,reg16			[rm:	o16 03 /r]				8086
+ADD		reg32,mem			[rm:	o32 03 /r]				386,SM
+ADD		reg32,reg32			[rm:	o32 03 /r]				386
+ADD		reg64,mem			[rm:	o64 03 /r]				X86_64,LONG,SM
+ADD		reg64,reg64			[rm:	o64 03 /r]				X86_64,LONG
+ADD		rm16,imm8			[mi:	hle o16 83 /0 ib,s]			8086,LOCK
+ADD		rm32,imm8			[mi:	hle o32 83 /0 ib,s]			386,LOCK
+ADD		rm64,imm8			[mi:	hle o64 83 /0 ib,s]			X86_64,LONG,LOCK
+ADD		reg_al,imm			[-i:	04 ib]					8086,SM
+ADD		reg_ax,sbyteword		[mi:	o16 83 /0 ib,s]				8086,SM,ND
+ADD		reg_ax,imm			[-i:	o16 05 iw]				8086,SM
+ADD		reg_eax,sbytedword		[mi:	o32 83 /0 ib,s]				386,SM,ND
+ADD		reg_eax,imm			[-i:	o32 05 id]				386,SM
+ADD		reg_rax,sbytedword		[mi:	o64 83 /0 ib,s]				X86_64,LONG,SM,ND
+ADD		reg_rax,imm			[-i:	o64 05 id,s]				X86_64,LONG,SM
+ADD		rm8,imm				[mi:	hle 80 /0 ib]				8086,SM,LOCK
+ADD		rm16,sbyteword			[mi:	hle o16 83 /0 ib,s]			8086,SM,LOCK,ND
+ADD		rm16,imm			[mi:	hle o16 81 /0 iw]			8086,SM,LOCK
+ADD		rm32,sbytedword			[mi:	hle o32 83 /0 ib,s]			386,SM,LOCK,ND
+ADD		rm32,imm			[mi:	hle o32 81 /0 id]			386,SM,LOCK
+ADD		rm64,sbytedword			[mi:	hle o64 83 /0 ib,s]			X86_64,LONG,SM,LOCK,ND
+ADD		rm64,imm			[mi:	hle o64 81 /0 id,s]			X86_64,LONG,SM,LOCK
+ADD		mem,imm8			[mi:	hle 80 /0 ib]				8086,SM,LOCK
+ADD		mem,sbyteword16			[mi:	hle o16 83 /0 ib,s]			8086,SM,LOCK,ND
+ADD		mem,imm16			[mi:	hle o16 81 /0 iw]			8086,SM,LOCK
+ADD		mem,sbytedword32		[mi:	hle o32 83 /0 ib,s]			386,SM,LOCK,ND
+ADD		mem,imm32			[mi:	hle o32 81 /0 id]			386,SM,LOCK
+ADD		rm8,imm				[mi:	hle 82 /0 ib]				8086,SM,LOCK,ND,NOLONG
+AND		mem,reg8			[mr:	hle 20 /r]				8086,SM,LOCK
+AND		reg8,reg8			[mr:	20 /r]					8086
+AND		mem,reg16			[mr:	hle o16 21 /r]				8086,SM,LOCK
+AND		reg16,reg16			[mr:	o16 21 /r]				8086
+AND		mem,reg32			[mr:	hle o32 21 /r]				386,SM,LOCK
+AND		reg32,reg32			[mr:	o32 21 /r]				386
+AND		mem,reg64			[mr:	hle o64 21 /r]				X86_64,LONG,SM,LOCK
+AND		reg64,reg64			[mr:	o64 21 /r]				X86_64,LONG
+AND		reg8,mem			[rm:	22 /r]					8086,SM
+AND		reg8,reg8			[rm:	22 /r]					8086
+AND		reg16,mem			[rm:	o16 23 /r]				8086,SM
+AND		reg16,reg16			[rm:	o16 23 /r]				8086
+AND		reg32,mem			[rm:	o32 23 /r]				386,SM
+AND		reg32,reg32			[rm:	o32 23 /r]				386
+AND		reg64,mem			[rm:	o64 23 /r]				X86_64,LONG,SM
+AND		reg64,reg64			[rm:	o64 23 /r]				X86_64,LONG
+AND		rm16,imm8			[mi:	hle o16 83 /4 ib,s]			8086,LOCK
+AND		rm32,imm8			[mi:	hle o32 83 /4 ib,s]			386,LOCK
+AND		rm64,imm8			[mi:	hle o64 83 /4 ib,s]			X86_64,LONG,LOCK
+AND		reg_al,imm			[-i:	24 ib]					8086,SM
+AND		reg_ax,sbyteword		[mi:	o16 83 /4 ib,s]				8086,SM,ND
+AND		reg_ax,imm			[-i:	o16 25 iw]				8086,SM
+AND		reg_eax,sbytedword		[mi:	o32 83 /4 ib,s]				386,SM,ND
+AND		reg_eax,imm			[-i:	o32 25 id]				386,SM
+AND		reg_rax,sbytedword		[mi:	o64 83 /4 ib,s]				X86_64,LONG,SM,ND
+AND		reg_rax,imm			[-i:	o64 25 id,s]				X86_64,LONG,SM
+AND		rm8,imm				[mi:	hle 80 /4 ib]				8086,SM,LOCK
+AND		rm16,sbyteword			[mi:	hle o16 83 /4 ib,s]			8086,SM,LOCK,ND
+AND		rm16,imm			[mi:	hle o16 81 /4 iw]			8086,SM,LOCK
+AND		rm32,sbytedword			[mi:	hle o32 83 /4 ib,s]			386,SM,LOCK,ND
+AND		rm32,imm			[mi:	hle o32 81 /4 id]			386,SM,LOCK
+AND		rm64,sbytedword			[mi:	hle o64 83 /4 ib,s]			X86_64,LONG,SM,LOCK,ND
+AND		rm64,imm			[mi:	hle o64 81 /4 id,s]			X86_64,LONG,SM,LOCK
+AND		mem,imm8			[mi:	hle 80 /4 ib]				8086,SM,LOCK
+AND		mem,sbyteword16			[mi:	hle o16 83 /4 ib,s]			8086,SM,LOCK,ND
+AND		mem,imm16			[mi:	hle o16 81 /4 iw]			8086,SM,LOCK
+AND		mem,sbytedword32		[mi:	hle o32 83 /4 ib,s]			386,SM,LOCK,ND
+AND		mem,imm32			[mi:	hle o32 81 /4 id]			386,SM,LOCK
+AND		rm8,imm				[mi:	hle 82 /4 ib]				8086,SM,LOCK,ND,NOLONG
+ARPL		mem,reg16			[mr:	63 /r]					286,PROT,SM,NOLONG
+ARPL		reg16,reg16			[mr:	63 /r]					286,PROT,NOLONG
+BB0_RESET	void				[	0f 3a]					PENT,CYRIX,ND,OBSOLETE
+BB1_RESET	void				[	0f 3b]					PENT,CYRIX,ND,OBSOLETE
+BOUND		reg16,mem			[rm:	o16 62 /r]				186,NOLONG
+BOUND		reg32,mem			[rm:	o32 62 /r]				386,NOLONG
+BSF		reg16,mem			[rm:	o16 nof3 0f bc /r]			386,SM
+BSF		reg16,reg16			[rm:	o16 nof3 0f bc /r]			386
+BSF		reg32,mem			[rm:	o32 nof3 0f bc /r]			386,SM
+BSF		reg32,reg32			[rm:	o32 nof3 0f bc /r]			386
+BSF		reg64,mem			[rm:	o64 nof3 0f bc /r]			X86_64,LONG,SM
+BSF		reg64,reg64			[rm:	o64 nof3 0f bc /r]			X86_64,LONG
+BSR		reg16,mem			[rm:	o16 nof3 0f bd /r]			386,SM
+BSR		reg16,reg16			[rm:	o16 nof3 0f bd /r]			386
+BSR		reg32,mem			[rm:	o32 nof3 0f bd /r]			386,SM
+BSR		reg32,reg32			[rm:	o32 nof3 0f bd /r]			386
+BSR		reg64,mem			[rm:	o64 nof3 0f bd /r]			X86_64,LONG,SM
+BSR		reg64,reg64			[rm:	o64 nof3 0f bd /r]			X86_64,LONG
+BSWAP		reg32				[r:	o32 0f c8+r]				486
+BSWAP		reg64				[r:	o64 0f c8+r]				X86_64,LONG
+BT		mem,reg16			[mr:	o16 0f a3 /r]				386,SM
+BT		reg16,reg16			[mr:	o16 0f a3 /r]				386
+BT		mem,reg32			[mr:	o32 0f a3 /r]				386,SM
+BT		reg32,reg32			[mr:	o32 0f a3 /r]				386
+BT		mem,reg64			[mr:	o64 0f a3 /r]				X86_64,LONG,SM
+BT		reg64,reg64			[mr:	o64 0f a3 /r]				X86_64,LONG
+BT		rm16,imm8			[mi:	o16 0f ba /4 ib,u]			386
+BT		rm32,imm8			[mi:	o32 0f ba /4 ib,u]			386
+BT		rm64,imm8			[mi:	o64 0f ba /4 ib,u]			X86_64,LONG
+BTC		mem,reg16			[mr:	hle o16 0f bb /r]			386,SM,LOCK
+BTC		reg16,reg16			[mr:	o16 0f bb /r]				386
+BTC		mem,reg32			[mr:	hle o32 0f bb /r]			386,SM,LOCK
+BTC		reg32,reg32			[mr:	o32 0f bb /r]				386
+BTC		mem,reg64			[mr:	hle o64 0f bb /r]			X86_64,LONG,SM,LOCK
+BTC		reg64,reg64			[mr:	o64 0f bb /r]				X86_64,LONG
+BTC		rm16,imm8			[mi:	hle o16 0f ba /7 ib,u]			386,LOCK
+BTC		rm32,imm8			[mi:	hle o32 0f ba /7 ib,u]			386,LOCK
+BTC		rm64,imm8			[mi:	hle o64 0f ba /7 ib,u]			X86_64,LONG,LOCK
+BTR		mem,reg16			[mr:	hle o16 0f b3 /r]			386,SM,LOCK
+BTR		reg16,reg16			[mr:	o16 0f b3 /r]				386
+BTR		mem,reg32			[mr:	hle o32 0f b3 /r]			386,SM,LOCK
+BTR		reg32,reg32			[mr:	o32 0f b3 /r]				386
+BTR		mem,reg64			[mr:	hle o64 0f b3 /r]			X86_64,LONG,SM,LOCK
+BTR		reg64,reg64			[mr:	o64 0f b3 /r]				X86_64,LONG
+BTR		rm16,imm8			[mi:	hle o16 0f ba /6 ib,u]			386,LOCK
+BTR		rm32,imm8			[mi:	hle o32 0f ba /6 ib,u]			386,LOCK
+BTR		rm64,imm8			[mi:	hle o64 0f ba /6 ib,u]			X86_64,LONG,LOCK
+BTS		mem,reg16			[mr:	hle o16 0f ab /r]			386,SM,LOCK
+BTS		reg16,reg16			[mr:	o16 0f ab /r]				386
+BTS		mem,reg32			[mr:	hle o32 0f ab /r]			386,SM,LOCK
+BTS		reg32,reg32			[mr:	o32 0f ab /r]				386
+BTS		mem,reg64			[mr:	hle o64 0f ab /r]			X86_64,LONG,SM,LOCK
+BTS		reg64,reg64			[mr:	o64 0f ab /r]				X86_64,LONG
+BTS		rm16,imm8			[mi:	hle o16 0f ba /5 ib,u]			386,LOCK
+BTS		rm32,imm8			[mi:	hle o32 0f ba /5 ib,u]			386,LOCK
+BTS		rm64,imm8			[mi:	hle o64 0f ba /5 ib,u]			X86_64,LONG,LOCK
+CALL		imm				[i:	odf e8 rel]				8086,BND
+CALL		imm|near			[i:	odf e8 rel]				8086,ND,BND
+CALL		imm|far				[i:	odf 9a iwd seg]				8086,ND,NOLONG
+; Call/jmp near imm/reg/mem is always 64-bit in long mode.
+CALL		imm16				[i:	o16 e8 rel]				8086,NOLONG,BND
+CALL		imm16|near			[i:	o16 e8 rel]				8086,ND,NOLONG,BND
+CALL		imm16|far			[i:	o16 9a iwd seg]				8086,ND,NOLONG
+CALL		imm32				[i:	o32 e8 rel]				386,NOLONG,BND
+CALL		imm32|near			[i:	o32 e8 rel]				386,ND,NOLONG,BND
+CALL		imm32|far			[i:	o32 9a iwd seg]				386,ND,NOLONG
+CALL		imm64				[i:	o64nw e8 rel]				X86_64,LONG,BND
+CALL		imm64|near			[i:	o64nw e8 rel]				X86_64,LONG,ND,BND
+CALL		imm:imm				[ji:	odf 9a iwd iw]				8086,NOLONG
+CALL		imm16:imm			[ji:	o16 9a iw iw]				8086,NOLONG
+CALL		imm:imm16			[ji:	o16 9a iw iw]				8086,NOLONG
+CALL		imm32:imm			[ji:	o32 9a id iw]				386,NOLONG
+CALL		imm:imm32			[ji:	o32 9a id iw]				386,NOLONG
+CALL		mem|far				[m:	odf ff /3]				8086,NOLONG
+CALL		mem|far				[m:	o64 ff /3]				X86_64,LONG
+CALL		mem16|far			[m:	o16 ff /3]				8086
+CALL		mem32|far			[m:	o32 ff /3]				386
+CALL		mem64|far			[m:	o64 ff /3]				X86_64,LONG
+CALL		mem|near			[m:	odf ff /2]				8086,ND,BND
+CALL		rm16|near			[m:	o16 ff /2]				8086,NOLONG,ND,BND
+CALL		rm32|near			[m:	o32 ff /2]				386,NOLONG,ND,BND
+CALL		rm64|near			[m:	o64nw ff /2]				X86_64,LONG,ND,BND
+CALL		mem				[m:	odf ff /2]				8086,BND
+CALL		rm16				[m:	o16 ff /2]				8086,NOLONG,BND
+CALL		rm32				[m:	o32 ff /2]				386,NOLONG,BND
+CALL		rm64				[m:	o64nw ff /2]				X86_64,LONG,BND
+
+CBW		void				[	o16 98]					8086
+CDQ		void				[	o32 99]					386
+CDQE		void				[	o64 98]					X86_64,LONG
+CLC		void				[	f8]					8086
+CLD		void				[	fc]					8086
+CLI		void				[	fa]					8086
+CLTS		void				[	0f 06]					286,PRIV
+CMC		void				[	f5]					8086
+CMP		mem,reg8			[mr:	38 /r]					8086,SM
+CMP		reg8,reg8			[mr:	38 /r]					8086
+CMP		mem,reg16			[mr:	o16 39 /r]				8086,SM
+CMP		reg16,reg16			[mr:	o16 39 /r]				8086
+CMP		mem,reg32			[mr:	o32 39 /r]				386,SM
+CMP		reg32,reg32			[mr:	o32 39 /r]				386
+CMP		mem,reg64			[mr:	o64 39 /r]				X86_64,LONG,SM
+CMP		reg64,reg64			[mr:	o64 39 /r]				X86_64,LONG
+CMP		reg8,mem			[rm:	3a /r]					8086,SM
+CMP		reg8,reg8			[rm:	3a /r]					8086
+CMP		reg16,mem			[rm:	o16 3b /r]				8086,SM
+CMP		reg16,reg16			[rm:	o16 3b /r]				8086
+CMP		reg32,mem			[rm:	o32 3b /r]				386,SM
+CMP		reg32,reg32			[rm:	o32 3b /r]				386
+CMP		reg64,mem			[rm:	o64 3b /r]				X86_64,LONG,SM
+CMP		reg64,reg64			[rm:	o64 3b /r]				X86_64,LONG
+CMP		rm16,imm8			[mi:	o16 83 /7 ib,s]				8086
+CMP		rm32,imm8			[mi:	o32 83 /7 ib,s]				386
+CMP		rm64,imm8			[mi:	o64 83 /7 ib,s]				X86_64,LONG
+CMP		reg_al,imm			[-i:	3c ib]					8086,SM
+CMP		reg_ax,sbyteword		[mi:	o16 83 /7 ib,s]				8086,SM,ND
+CMP		reg_ax,imm			[-i:	o16 3d iw]				8086,SM
+CMP		reg_eax,sbytedword		[mi:	o32 83 /7 ib,s]				386,SM,ND
+CMP		reg_eax,imm			[-i:	o32 3d id]				386,SM
+CMP		reg_rax,sbytedword		[mi:	o64 83 /7 ib,s]				X86_64,LONG,SM,ND
+CMP		reg_rax,imm			[-i:	o64 3d id,s]				X86_64,LONG,SM
+CMP		rm8,imm				[mi:	80 /7 ib]				8086,SM
+CMP		rm16,sbyteword			[mi:	o16 83 /7 ib,s]				8086,SM,ND
+CMP		rm16,imm			[mi:	o16 81 /7 iw]				8086,SM
+CMP		rm32,sbytedword			[mi:	o32 83 /7 ib,s]				386,SM,ND
+CMP		rm32,imm			[mi:	o32 81 /7 id]				386,SM
+CMP		rm64,sbytedword			[mi:	o64 83 /7 ib,s]				X86_64,LONG,SM,ND
+CMP		rm64,imm			[mi:	o64 81 /7 id,s]				X86_64,LONG,SM
+CMP		mem,imm8			[mi:	80 /7 ib]				8086,SM
+CMP		mem,sbyteword16			[mi:	o16 83 /7 ib,s]				8086,SM,ND
+CMP		mem,imm16			[mi:	o16 81 /7 iw]				8086,SM
+CMP		mem,sbytedword32		[mi:	o32 83 /7 ib,s]				386,SM,ND
+CMP		mem,imm32			[mi:	o32 81 /7 id]				386,SM
+CMP		rm8,imm				[mi:	82 /7 ib]				8086,SM,ND,NOLONG
+CMPSB		void				[	repe a6]				8086
+CMPSD		void				[	repe o32 a7]				386
+CMPSQ		void				[	repe o64 a7]				X86_64,LONG
+CMPSW		void				[	repe o16 a7]				8086
+CMPXCHG		mem,reg8			[mr:	hle 0f b0 /r]				PENT,SM,LOCK
+CMPXCHG		reg8,reg8			[mr:	0f b0 /r]				PENT
+CMPXCHG		mem,reg16			[mr:	hle o16 0f b1 /r]			PENT,SM,LOCK
+CMPXCHG		reg16,reg16			[mr:	o16 0f b1 /r]				PENT
+CMPXCHG		mem,reg32			[mr:	hle o32 0f b1 /r]			PENT,SM,LOCK
+CMPXCHG		reg32,reg32			[mr:	o32 0f b1 /r]				PENT
+CMPXCHG		mem,reg64			[mr:	hle o64 0f b1 /r]			X86_64,LONG,SM,LOCK
+CMPXCHG		reg64,reg64			[mr:	o64 0f b1 /r]				X86_64,LONG
+CMPXCHG486	mem,reg8			[mr:	0f a6 /r]				486,SM,UNDOC,ND,LOCK,OBSOLETE
+CMPXCHG486	reg8,reg8			[mr:	0f a6 /r]				486,UNDOC,ND,OBSOLETE
+CMPXCHG486	mem,reg16			[mr:	o16 0f a7 /r]				486,SM,UNDOC,ND,LOCK,OBSOLETE
+CMPXCHG486	reg16,reg16			[mr:	o16 0f a7 /r]				486,UNDOC,ND,OBSOLETE
+CMPXCHG486	mem,reg32			[mr:	o32 0f a7 /r]				486,SM,UNDOC,ND,LOCK,OBSOLETE
+CMPXCHG486	reg32,reg32			[mr:	o32 0f a7 /r]				486,UNDOC,ND,OBSOLETE
+CMPXCHG8B	mem64				[m:	hle norexw 0f c7 /1]			PENT,LOCK
+CMPXCHG16B	mem128				[m:	o64 0f c7 /1]				X86_64,LONG,LOCK
+CPUID		void				[	0f a2]					PENT
+CPU_READ	void				[	0f 3d]					PENT,CYRIX
+CPU_WRITE	void				[	0f 3c]					PENT,CYRIX
+CQO		void				[	o64 99]					X86_64,LONG
+CWD		void				[	o16 99]					8086
+CWDE		void				[	o32 98]					386
+DAA		void				[	27]					8086,NOLONG
+DAS		void				[	2f]					8086,NOLONG
+DEC		reg16				[r:	o16 48+r]				8086,NOLONG
+DEC		reg32				[r:	o32 48+r]				386,NOLONG
+DEC		rm8				[m:	hle fe /1]				8086,LOCK
+DEC		rm16				[m:	hle o16 ff /1]				8086,LOCK
+DEC		rm32				[m:	hle o32 ff /1]				386,LOCK
+DEC		rm64				[m:	hle o64 ff /1]				X86_64,LONG,LOCK
+DIV		rm8				[m:	f6 /6]					8086
+DIV		rm16				[m:	o16 f7 /6]				8086
+DIV		rm32				[m:	o32 f7 /6]				386
+DIV		rm64				[m:	o64 f7 /6]				X86_64,LONG
+DMINT		void				[	0f 39]					P6,CYRIX
+EMMS		void				[	0f 77]					PENT,MMX
+ENTER		imm,imm				[ij:	c8 iw ib,u]				186
+EQU		imm				ignore						8086
+EQU		imm:imm				ignore						8086
+F2XM1		void				[	d9 f0]					8086,FPU
+FABS		void				[	d9 e1]					8086,FPU
+FADD		mem32				[m:	d8 /0]					8086,FPU
+FADD		mem64				[m:	dc /0]					8086,FPU
+FADD		fpureg|to			[r:	dc c0+r]				8086,FPU
+FADD		fpureg				[r:	d8 c0+r]				8086,FPU
+FADD		fpureg,fpu0			[r-:	dc c0+r]				8086,FPU
+FADD		fpu0,fpureg			[-r:	d8 c0+r]				8086,FPU
+FADD		void				[	de c1]					8086,FPU,ND
+FADDP		fpureg				[r:	de c0+r]				8086,FPU
+FADDP		fpureg,fpu0			[r-:	de c0+r]				8086,FPU
+FADDP		void				[	de c1]					8086,FPU,ND
+FBLD		mem80				[m:	df /4]					8086,FPU
+FBLD		mem				[m:	df /4]					8086,FPU
+FBSTP		mem80				[m:	df /6]					8086,FPU
+FBSTP		mem				[m:	df /6]					8086,FPU
+FCHS		void				[	d9 e0]					8086,FPU
+FCLEX		void				[	wait db e2]				8086,FPU
+FCMOVB		fpureg				[r:	da c0+r]				P6,FPU
+FCMOVB		fpu0,fpureg			[-r:	da c0+r]				P6,FPU
+FCMOVB		void				[	da c1]					P6,FPU,ND
+FCMOVBE		fpureg				[r:	da d0+r]				P6,FPU
+FCMOVBE		fpu0,fpureg			[-r:	da d0+r]				P6,FPU
+FCMOVBE		void				[	da d1]					P6,FPU,ND
+FCMOVE		fpureg				[r:	da c8+r]				P6,FPU
+FCMOVE		fpu0,fpureg			[-r:	da c8+r]				P6,FPU
+FCMOVE		void				[	da c9]					P6,FPU,ND
+FCMOVNB		fpureg				[r:	db c0+r]				P6,FPU
+FCMOVNB		fpu0,fpureg			[-r:	db c0+r]				P6,FPU
+FCMOVNB		void				[	db c1]					P6,FPU,ND
+FCMOVNBE	fpureg				[r:	db d0+r]				P6,FPU
+FCMOVNBE	fpu0,fpureg			[-r:	db d0+r]				P6,FPU
+FCMOVNBE	void				[	db d1]					P6,FPU,ND
+FCMOVNE		fpureg				[r:	db c8+r]				P6,FPU
+FCMOVNE		fpu0,fpureg			[-r:	db c8+r]				P6,FPU
+FCMOVNE		void				[	db c9]					P6,FPU,ND
+FCMOVNU		fpureg				[r:	db d8+r]				P6,FPU
+FCMOVNU		fpu0,fpureg			[-r:	db d8+r]				P6,FPU
+FCMOVNU		void				[	db d9]					P6,FPU,ND
+FCMOVU		fpureg				[r:	da d8+r]				P6,FPU
+FCMOVU		fpu0,fpureg			[-r:	da d8+r]				P6,FPU
+FCMOVU		void				[	da d9]					P6,FPU,ND
+FCOM		mem32				[m:	d8 /2]					8086,FPU
+FCOM		mem64				[m:	dc /2]					8086,FPU
+FCOM		fpureg				[r:	d8 d0+r]				8086,FPU
+FCOM		fpu0,fpureg			[-r:	d8 d0+r]				8086,FPU
+FCOM		void				[	d8 d1]					8086,FPU,ND
+FCOMI		fpureg				[r:	db f0+r]				P6,FPU
+FCOMI		fpu0,fpureg			[-r:	db f0+r]				P6,FPU
+FCOMI		void				[	db f1]					P6,FPU,ND
+FCOMIP		fpureg				[r:	df f0+r]				P6,FPU
+FCOMIP		fpu0,fpureg			[-r:	df f0+r]				P6,FPU
+FCOMIP		void				[	df f1]					P6,FPU,ND
+FCOMP		mem32				[m:	d8 /3]					8086,FPU
+FCOMP		mem64				[m:	dc /3]					8086,FPU
+FCOMP		fpureg				[r:	d8 d8+r]				8086,FPU
+FCOMP		fpu0,fpureg			[-r:	d8 d8+r]				8086,FPU
+FCOMP		void				[	d8 d9]					8086,FPU,ND
+FCOMPP		void				[	de d9]					8086,FPU
+FCOS		void				[	d9 ff]					386,FPU
+FDECSTP		void				[	d9 f6]					8086,FPU
+FDISI		void				[	wait db e1]				8086,FPU
+FDIV		mem32				[m:	d8 /6]					8086,FPU
+FDIV		mem64				[m:	dc /6]					8086,FPU
+FDIV		fpureg|to			[r:	dc f8+r]				8086,FPU
+FDIV		fpureg				[r:	d8 f0+r]				8086,FPU
+FDIV		fpureg,fpu0			[r-:	dc f8+r]				8086,FPU
+FDIV		fpu0,fpureg			[-r:	d8 f0+r]				8086,FPU
+FDIV		void				[	de f9]					8086,FPU,ND
+FDIVP		fpureg				[r:	de f8+r]				8086,FPU
+FDIVP		fpureg,fpu0			[r-:	de f8+r]				8086,FPU
+FDIVP		void				[	de f9]					8086,FPU,ND
+FDIVR		mem32				[m:	d8 /7]					8086,FPU
+FDIVR		mem64				[m:	dc /7]					8086,FPU
+FDIVR		fpureg|to			[r:	dc f0+r]				8086,FPU
+FDIVR		fpureg,fpu0			[r-:	dc f0+r]				8086,FPU
+FDIVR		fpureg				[r:	d8 f8+r]				8086,FPU
+FDIVR		fpu0,fpureg			[-r:	d8 f8+r]				8086,FPU
+FDIVR		void				[	de f1]					8086,FPU,ND
+FDIVRP		fpureg				[r:	de f0+r]				8086,FPU
+FDIVRP		fpureg,fpu0			[r-:	de f0+r]				8086,FPU
+FDIVRP		void				[	de f1]					8086,FPU,ND
+FEMMS		void				[	0f 0e]					PENT,3DNOW
+FENI		void				[	wait db e0]				8086,FPU
+FFREE		fpureg				[r:	dd c0+r]				8086,FPU
+FFREE		void				[	dd c1]					8086,FPU
+FFREEP		fpureg				[r:	df c0+r]				286,FPU,UNDOC
+FFREEP		void				[	df c1]					286,FPU,UNDOC
+FIADD		mem32				[m:	da /0]					8086,FPU
+FIADD		mem16				[m:	de /0]					8086,FPU
+FICOM		mem32				[m:	da /2]					8086,FPU
+FICOM		mem16				[m:	de /2]					8086,FPU
+FICOMP		mem32				[m:	da /3]					8086,FPU
+FICOMP		mem16				[m:	de /3]					8086,FPU
+FIDIV		mem32				[m:	da /6]					8086,FPU
+FIDIV		mem16				[m:	de /6]					8086,FPU
+FIDIVR		mem32				[m:	da /7]					8086,FPU
+FIDIVR		mem16				[m:	de /7]					8086,FPU
+FILD		mem32				[m:	db /0]					8086,FPU
+FILD		mem16				[m:	df /0]					8086,FPU
+FILD		mem64				[m:	df /5]					8086,FPU
+FIMUL		mem32				[m:	da /1]					8086,FPU
+FIMUL		mem16				[m:	de /1]					8086,FPU
+FINCSTP		void				[	d9 f7]					8086,FPU
+FINIT		void				[	wait db e3]				8086,FPU
+FIST		mem32				[m:	db /2]					8086,FPU
+FIST		mem16				[m:	df /2]					8086,FPU
+FISTP		mem32				[m:	db /3]					8086,FPU
+FISTP		mem16				[m:	df /3]					8086,FPU
+FISTP		mem64				[m:	df /7]					8086,FPU
+FISTTP		mem16				[m:	df /1]					PRESCOTT,FPU
+FISTTP		mem32				[m:	db /1]					PRESCOTT,FPU
+FISTTP		mem64				[m:	dd /1]					PRESCOTT,FPU
+FISUB		mem32				[m:	da /4]					8086,FPU
+FISUB		mem16				[m:	de /4]					8086,FPU
+FISUBR		mem32				[m:	da /5]					8086,FPU
+FISUBR		mem16				[m:	de /5]					8086,FPU
+FLD		mem32				[m:	d9 /0]					8086,FPU
+FLD		mem64				[m:	dd /0]					8086,FPU
+FLD		mem80				[m:	db /5]					8086,FPU
+FLD		fpureg				[r:	d9 c0+r]				8086,FPU
+FLD		void				[	d9 c1]					8086,FPU,ND
+FLD1		void				[	d9 e8]					8086,FPU
+FLDCW		mem				[m:	d9 /5]					8086,FPU,SW
+FLDENV		mem				[m:	d9 /4]					8086,FPU
+FLDL2E		void				[	d9 ea]					8086,FPU
+FLDL2T		void				[	d9 e9]					8086,FPU
+FLDLG2		void				[	d9 ec]					8086,FPU
+FLDLN2		void				[	d9 ed]					8086,FPU
+FLDPI		void				[	d9 eb]					8086,FPU
+FLDZ		void				[	d9 ee]					8086,FPU
+FMUL		mem32				[m:	d8 /1]					8086,FPU
+FMUL		mem64				[m:	dc /1]					8086,FPU
+FMUL		fpureg|to			[r:	dc c8+r]				8086,FPU
+FMUL		fpureg,fpu0			[r-:	dc c8+r]				8086,FPU
+FMUL		fpureg				[r:	d8 c8+r]				8086,FPU
+FMUL		fpu0,fpureg			[-r:	d8 c8+r]				8086,FPU
+FMUL		void				[	de c9]					8086,FPU,ND
+FMULP		fpureg				[r:	de c8+r]				8086,FPU
+FMULP		fpureg,fpu0			[r-:	de c8+r]				8086,FPU
+FMULP		void				[	de c9]					8086,FPU,ND
+FNCLEX		void				[	db e2]					8086,FPU
+FNDISI		void				[	db e1]					8086,FPU
+FNENI		void				[	db e0]					8086,FPU
+FNINIT		void				[	db e3]					8086,FPU
+FNOP		void				[	d9 d0]					8086,FPU
+FNSAVE		mem				[m:	dd /6]					8086,FPU
+FNSTCW		mem				[m:	d9 /7]					8086,FPU,SW
+FNSTENV		mem				[m:	d9 /6]					8086,FPU
+FNSTSW		mem				[m:	dd /7]					8086,FPU,SW
+FNSTSW		reg_ax				[-:	df e0]					286,FPU
+FPATAN		void				[	d9 f3]					8086,FPU
+FPREM		void				[	d9 f8]					8086,FPU
+FPREM1		void				[	d9 f5]					386,FPU
+FPTAN		void				[	d9 f2]					8086,FPU
+FRNDINT		void				[	d9 fc]					8086,FPU
+FRSTOR		mem				[m:	dd /4]					8086,FPU
+FSAVE		mem				[m:	wait dd /6]				8086,FPU
+FSCALE		void				[	d9 fd]					8086,FPU
+FSETPM		void				[	db e4]					286,FPU
+FSIN		void				[	d9 fe]					386,FPU
+FSINCOS		void				[	d9 fb]					386,FPU
+FSQRT		void				[	d9 fa]					8086,FPU
+FST		mem32				[m:	d9 /2]					8086,FPU
+FST		mem64				[m:	dd /2]					8086,FPU
+FST		fpureg				[r:	dd d0+r]				8086,FPU
+FST		void				[	dd d1]					8086,FPU,ND
+FSTCW		mem				[m:	wait d9 /7]				8086,FPU,SW
+FSTENV		mem				[m:	wait d9 /6]				8086,FPU
+FSTP		mem32				[m:	d9 /3]					8086,FPU
+FSTP		mem64				[m:	dd /3]					8086,FPU
+FSTP		mem80				[m:	db /7]					8086,FPU
+FSTP		fpureg				[r:	dd d8+r]				8086,FPU
+FSTP		void				[	dd d9]					8086,FPU,ND
+FSTSW		mem				[m:	wait dd /7]				8086,FPU,SW
+FSTSW		reg_ax				[-:	wait df e0]				286,FPU
+FSUB		mem32				[m:	d8 /4]					8086,FPU
+FSUB		mem64				[m:	dc /4]					8086,FPU
+FSUB		fpureg|to			[r:	dc e8+r]				8086,FPU
+FSUB		fpureg,fpu0			[r-:	dc e8+r]				8086,FPU
+FSUB		fpureg				[r:	d8 e0+r]				8086,FPU
+FSUB		fpu0,fpureg			[-r:	d8 e0+r]				8086,FPU
+FSUB		void				[	de e9]					8086,FPU,ND
+FSUBP		fpureg				[r:	de e8+r]				8086,FPU
+FSUBP		fpureg,fpu0			[r-:	de e8+r]				8086,FPU
+FSUBP		void				[	de e9]					8086,FPU,ND
+FSUBR		mem32				[m:	d8 /5]					8086,FPU
+FSUBR		mem64				[m:	dc /5]					8086,FPU
+FSUBR		fpureg|to			[r:	dc e0+r]				8086,FPU
+FSUBR		fpureg,fpu0			[r-:	dc e0+r]				8086,FPU
+FSUBR		fpureg				[r:	d8 e8+r]				8086,FPU
+FSUBR		fpu0,fpureg			[-r:	d8 e8+r]				8086,FPU
+FSUBR		void				[	de e1]					8086,FPU,ND
+FSUBRP		fpureg				[r:	de e0+r]				8086,FPU
+FSUBRP		fpureg,fpu0			[r-:	de e0+r]				8086,FPU
+FSUBRP		void				[	de e1]					8086,FPU,ND
+FTST		void				[	d9 e4]					8086,FPU
+FUCOM		fpureg				[r:	dd e0+r]				386,FPU
+FUCOM		fpu0,fpureg			[-r:	dd e0+r]				386,FPU
+FUCOM		void				[	dd e1]					386,FPU,ND
+FUCOMI		fpureg				[r:	db e8+r]				P6,FPU
+FUCOMI		fpu0,fpureg			[-r:	db e8+r]				P6,FPU
+FUCOMI		void				[	db e9]					P6,FPU,ND
+FUCOMIP		fpureg				[r:	df e8+r]				P6,FPU
+FUCOMIP		fpu0,fpureg			[-r:	df e8+r]				P6,FPU
+FUCOMIP		void				[	df e9]					P6,FPU,ND
+FUCOMP		fpureg				[r:	dd e8+r]				386,FPU
+FUCOMP		fpu0,fpureg			[-r:	dd e8+r]				386,FPU
+FUCOMP		void				[	dd e9]					386,FPU,ND
+FUCOMPP		void				[	da e9]					386,FPU
+FXAM		void				[	d9 e5]					8086,FPU
+FXCH		fpureg				[r:	d9 c8+r]				8086,FPU
+FXCH		fpureg,fpu0			[r-:	d9 c8+r]				8086,FPU
+FXCH		fpu0,fpureg			[-r:	d9 c8+r]				8086,FPU
+FXCH		void				[	d9 c9]					8086,FPU,ND
+FXTRACT		void				[	d9 f4]					8086,FPU
+FYL2X		void				[	d9 f1]					8086,FPU
+FYL2XP1		void				[	d9 f9]					8086,FPU
+HLT		void				[	f4]					8086,PRIV
+IBTS		mem,reg16			[mr:	o16 0f a7 /r]				386,SW,UNDOC,ND,OBSOLETE
+IBTS		reg16,reg16			[mr:	o16 0f a7 /r]				386,UNDOC,ND,OBSOLETE
+IBTS		mem,reg32			[mr:	o32 0f a7 /r]				386,SD,UNDOC,ND,OBSOLETE
+IBTS		reg32,reg32			[mr:	o32 0f a7 /r]				386,UNDOC,ND,OBSOLETE
+ICEBP		void				[	f1]					386,ND
+IDIV		rm8				[m:	f6 /7]					8086
+IDIV		rm16				[m:	o16 f7 /7]				8086
+IDIV		rm32				[m:	o32 f7 /7]				386
+IDIV		rm64				[m:	o64 f7 /7]				X86_64,LONG
+IMUL		rm8				[m:	f6 /5]					8086
+IMUL		rm16				[m:	o16 f7 /5]				8086
+IMUL		rm32				[m:	o32 f7 /5]				386
+IMUL		rm64				[m:	o64 f7 /5]				X86_64,LONG
+IMUL		reg16,mem			[rm:	o16 0f af /r]				386,SM
+IMUL		reg16,reg16			[rm:	o16 0f af /r]				386
+IMUL		reg32,mem			[rm:	o32 0f af /r]				386,SM
+IMUL		reg32,reg32			[rm:	o32 0f af /r]				386
+IMUL		reg64,mem			[rm:	o64 0f af /r]				X86_64,LONG,SM
+IMUL		reg64,reg64			[rm:	o64 0f af /r]				X86_64,LONG
+IMUL		reg16,mem,imm8			[rmi:	o16 6b /r ib,s]				186,SM2
+IMUL		reg16,mem,sbyteword		[rmi:	o16 6b /r ib,s]				186,SM,ND
+IMUL		reg16,mem,imm16			[rmi:	o16 69 /r iw]				186,SM
+IMUL		reg16,mem,imm			[rmi:	o16 69 /r iw]				186,SM,ND
+IMUL		reg16,reg16,imm8		[rmi:	o16 6b /r ib,s]				186
+IMUL		reg16,reg16,sbyteword		[rmi:	o16 6b /r ib,s]				186,SM,ND
+IMUL		reg16,reg16,imm16		[rmi:	o16 69 /r iw]				186
+IMUL		reg16,reg16,imm			[rmi:	o16 69 /r iw]				186,SM,ND
+IMUL		reg32,mem,imm8			[rmi:	o32 6b /r ib,s]				386,SM2
+IMUL		reg32,mem,sbytedword		[rmi:	o32 6b /r ib,s]				386,SM,ND
+IMUL		reg32,mem,imm32			[rmi:	o32 69 /r id]				386,SM
+IMUL		reg32,mem,imm			[rmi:	o32 69 /r id]				386,SM,ND
+IMUL		reg32,reg32,imm8		[rmi:	o32 6b /r ib,s]				386
+IMUL		reg32,reg32,sbytedword		[rmi:	o32 6b /r ib,s]				386,SM,ND
+IMUL		reg32,reg32,imm32		[rmi:	o32 69 /r id]				386
+IMUL		reg32,reg32,imm			[rmi:	o32 69 /r id]				386,SM,ND
+IMUL		reg64,mem,imm8			[rmi:	o64 6b /r ib,s]				X86_64,LONG,SM2
+IMUL		reg64,mem,sbytedword		[rmi:	o64 6b /r ib,s]				X86_64,LONG,SM,ND
+IMUL		reg64,mem,imm32			[rmi:	o64 69 /r id]				X86_64,LONG,SM2
+IMUL		reg64,mem,imm			[rmi:	o64 69 /r id,s]				X86_64,LONG,SM,ND
+IMUL		reg64,reg64,imm8		[rmi:	o64 6b /r ib,s]				X86_64,LONG
+IMUL		reg64,reg64,sbytedword		[rmi:	o64 6b /r ib,s]				X86_64,LONG,SM,ND
+IMUL		reg64,reg64,imm32		[rmi:	o64 69 /r id]				X86_64,LONG
+IMUL		reg64,reg64,imm			[rmi:	o64 69 /r id,s]				X86_64,LONG,SM,ND
+IMUL		reg16,imm8			[r+mi:	o16 6b /r ib,s]				186
+IMUL		reg16,sbyteword			[r+mi:	o16 6b /r ib,s]				186,SM,ND
+IMUL		reg16,imm16			[r+mi:	o16 69 /r iw]				186
+IMUL		reg16,imm			[r+mi:	o16 69 /r iw]				186,SM,ND
+IMUL		reg32,imm8			[r+mi:	o32 6b /r ib,s]				386
+IMUL		reg32,sbytedword		[r+mi:	o32 6b /r ib,s]				386,SM,ND
+IMUL		reg32,imm32			[r+mi:	o32 69 /r id]				386
+IMUL		reg32,imm			[r+mi:	o32 69 /r id]				386,SM,ND
+IMUL		reg64,imm8			[r+mi:	o64 6b /r ib,s]				X86_64,LONG
+IMUL		reg64,sbytedword		[r+mi:	o64 6b /r ib,s]				X86_64,LONG,SM,ND
+IMUL		reg64,imm32			[r+mi:	o64 69 /r id,s]				X86_64,LONG
+IMUL		reg64,imm			[r+mi:	o64 69 /r id,s]				X86_64,LONG,SM,ND
+IN		reg_al,imm			[-i:	e4 ib,u]				8086,SB
+IN		reg_ax,imm			[-i:	o16 e5 ib,u]				8086,SB
+IN		reg_eax,imm			[-i:	o32 e5 ib,u]				386,SB
+IN		reg_al,reg_dx			[--:	ec]					8086
+IN		reg_ax,reg_dx			[--:	o16 ed]					8086
+IN		reg_eax,reg_dx			[--:	o32 ed]					386
+INC		reg16				[r:	o16 40+r]				8086,NOLONG
+INC		reg32				[r:	o32 40+r]				386,NOLONG
+INC		rm8				[m:	hle fe /0]				8086,LOCK
+INC		rm16				[m:	hle o16 ff /0]				8086,LOCK
+INC		rm32				[m:	hle o32 ff /0]				386,LOCK
+INC		rm64				[m:	hle o64 ff /0]				X86_64,LONG,LOCK
+INSB		void				[	6c]					186
+INSD		void				[	o32 6d]					386
+INSW		void				[	o16 6d]					186
+INT		imm				[i:	cd ib,u]				8086,SB
+INT01		void				[	f1]					386,ND
+INT1		void				[	f1]					386
+INT03		void				[	cc]					8086,ND
+INT3		void				[	cc]					8086
+INTO		void				[	ce]					8086,NOLONG
+INVD		void				[	0f 08]					486,PRIV
+INVPCID		reg32,mem128			[rm:	66 0f 38 82 /r]				FUTURE,INVPCID,PRIV,NOLONG
+INVPCID		reg64,mem128			[rm:	66 0f 38 82 /r]				FUTURE,INVPCID,PRIV,LONG
+INVLPG		mem				[m:	0f 01 /7]				486,PRIV
+INVLPGA		reg_ax,reg_ecx			[--:	a16 0f 01 df]				X86_64,AMD,NOLONG
+INVLPGA		reg_eax,reg_ecx			[--:	a32 0f 01 df]				X86_64,AMD
+INVLPGA		reg_rax,reg_ecx			[--:	o64nw a64 0f 01 df]			X86_64,LONG,AMD
+INVLPGA		void				[	0f 01 df]				X86_64,AMD
+IRET		void				[	odf cf]					8086
+IRETD		void				[	o32 cf]					386
+IRETQ		void				[	o64 cf]					X86_64,LONG
+IRETW		void				[	o16 cf]					8086
+JCXZ		imm				[i:	a16 e3 rel8]				8086,NOLONG
+JECXZ		imm				[i:	a32 e3 rel8]				386
+JRCXZ		imm				[i:	o64nw a64 e3 rel8]			X86_64,LONG
+JMP		imm|short			[i:	eb rel8]				8086
+JMP		imm				[i:	jmp8 eb rel8]				8086,ND
+JMP		imm				[i:	odf e9 rel]				8086,BND
+JMP		imm|near			[i:	odf e9 rel]				8086,ND,BND
+JMP		imm|far				[i:	odf ea iwd seg]				8086,ND,NOLONG
+; Call/jmp near imm/reg/mem is always 64-bit in long mode.
+JMP		imm16				[i:	o16 e9 rel]				8086,NOLONG,BND
+JMP		imm16|near			[i:	o16 e9 rel]				8086,ND,NOLONG,BND
+JMP		imm16|far			[i:	o16 ea iwd seg]				8086,ND,NOLONG
+JMP		imm32				[i:	o32 e9 rel]				386,NOLONG,BND
+JMP		imm32|near			[i:	o32 e9 rel]				386,ND,NOLONG,BND
+JMP		imm32|far			[i:	o32 ea iwd seg]				386,ND,NOLONG
+JMP		imm64				[i:	o64nw e9 rel]				X86_64,LONG,BND
+JMP		imm64|near			[i:	o64nw e9 rel]				X86_64,LONG,ND,BND
+JMP		imm:imm				[ji:	odf ea iwd iw]				8086,NOLONG
+JMP		imm16:imm			[ji:	o16 ea iw iw]				8086,NOLONG
+JMP		imm:imm16			[ji:	o16 ea iw iw]				8086,NOLONG
+JMP		imm32:imm			[ji:	o32 ea id iw]				386,NOLONG
+JMP		imm:imm32			[ji:	o32 ea id iw]				386,NOLONG
+JMP		mem|far				[m:	odf ff /5]				8086,NOLONG
+JMP		mem|far				[m:	o64 ff /5]				X86_64,LONG
+JMP		mem16|far			[m:	o16 ff /5]				8086
+JMP		mem32|far			[m:	o32 ff /5]				386
+JMP		mem64|far			[m:	o64 ff /5]				X86_64,LONG
+JMP		mem|near			[m:	odf ff /4]				8086,ND,BND
+JMP		rm16|near			[m:	o16 ff /4]				8086,NOLONG,ND,BND
+JMP		rm32|near			[m:	o32 ff /4]				386,NOLONG,ND,BND
+JMP		rm64|near			[m:	o64nw ff /4]				X86_64,LONG,ND,BND
+JMP		mem				[m:	odf ff /4]				8086,BND
+JMP		rm16				[m:	o16 ff /4]				8086,NOLONG,BND
+JMP		rm32				[m:	o32 ff /4]				386,NOLONG,BND
+JMP		rm64				[m:	o64nw ff /4]				X86_64,LONG,BND
+
+JMPE		imm				[i:	odf 0f b8 rel]				IA64
+JMPE		imm16				[i:	o16 0f b8 rel]				IA64
+JMPE		imm32				[i:	o32 0f b8 rel]				IA64
+JMPE		rm16				[m:	o16 0f 00 /6]				IA64
+JMPE		rm32				[m:	o32 0f 00 /6]				IA64
+LAHF		void				[	9f]					8086
+LAR		reg16,mem			[rm:	o16 0f 02 /r]				286,PROT,SW
+LAR		reg16,reg16			[rm:	o16 0f 02 /r]				286,PROT
+LAR		reg16,reg32			[rm:	o16 0f 02 /r]				386,PROT
+LAR		reg16,reg64			[rm:	o16 o64nw 0f 02 /r]			X86_64,LONG,PROT,ND
+LAR		reg32,mem			[rm:	o32 0f 02 /r]				386,PROT,SW
+LAR		reg32,reg16			[rm:	o32 0f 02 /r]				386,PROT
+LAR		reg32,reg32			[rm:	o32 0f 02 /r]				386,PROT
+LAR		reg32,reg64			[rm:	o32 o64nw 0f 02 /r]			X86_64,LONG,PROT,ND
+LAR		reg64,mem			[rm:	o64 0f 02 /r]				X86_64,LONG,PROT,SW
+LAR		reg64,reg16			[rm:	o64 0f 02 /r]				X86_64,LONG,PROT
+LAR		reg64,reg32			[rm:	o64 0f 02 /r]				X86_64,LONG,PROT
+LAR		reg64,reg64			[rm:	o64 0f 02 /r]				X86_64,LONG,PROT
+LDS		reg16,mem			[rm:	o16 c5 /r]				8086,NOLONG
+LDS		reg32,mem			[rm:	o32 c5 /r]				386,NOLONG
+LEA		reg16,mem			[rm:	o16 8d /r]				8086,ANYSIZE
+LEA		reg32,mem			[rm:	o32 8d /r]				386,ANYSIZE
+LEA		reg64,mem			[rm:	o64 8d /r]				X86_64,LONG,ANYSIZE
+LEA		reg16,imm			[rm:	o16 8d /r]				8086,ND,ANYSIZE
+LEA		reg32,imm			[rm:	o32 8d /r]				386,ND,ANYSIZE
+LEA		reg64,imm			[rm:	o64 8d /r]				X86_64,LONG,ND,ANYSIZE
+LEAVE		void				[	c9]					186
+LES		reg16,mem			[rm:	o16 c4 /r]				8086,NOLONG
+LES		reg32,mem			[rm:	o32 c4 /r]				386,NOLONG
+LFENCE		void				[	np 0f ae e8]				X86_64,LONG,AMD
+LFS		reg16,mem			[rm:	o16 0f b4 /r]				386
+LFS		reg32,mem			[rm:	o32 0f b4 /r]				386
+LFS		reg64,mem			[rm:	o64 0f b4 /r]				X86_64,LONG
+LGDT		mem				[m:	0f 01 /2]				286,PRIV
+LGS		reg16,mem			[rm:	o16 0f b5 /r]				386
+LGS		reg32,mem			[rm:	o32 0f b5 /r]				386
+LGS		reg64,mem			[rm:	o64 0f b5 /r]				X86_64,LONG
+LIDT		mem				[m:	0f 01 /3]				286,PRIV
+LLDT		mem				[m:	0f 00 /2]				286,PROT,PRIV
+LLDT		mem16				[m:	0f 00 /2]				286,PROT,PRIV
+LLDT		reg16				[m:	0f 00 /2]				286,PROT,PRIV
+LMSW		mem				[m:	0f 01 /6]				286,PRIV
+LMSW		mem16				[m:	0f 01 /6]				286,PRIV
+LMSW		reg16				[m:	0f 01 /6]				286,PRIV
+LOADALL		void				[	0f 07]					386,UNDOC,ND,OBSOLETE
+LOADALL286	void				[	0f 05]					286,UNDOC,ND,OBSOLETE
+LODSB		void				[	ac]					8086
+LODSD		void				[	o32 ad]					386
+LODSQ		void				[	o64 ad]					X86_64,LONG
+LODSW		void				[	o16 ad]					8086
+LOOP		imm				[i:	adf e2 rel8]				8086
+LOOP		imm,reg_cx			[i-:	a16 e2 rel8]				8086,NOLONG
+LOOP		imm,reg_ecx			[i-:	a32 e2 rel8]				386
+LOOP		imm,reg_rcx			[i-:	a64 e2 rel8]				X86_64,LONG
+LOOPE		imm				[i:	adf e1 rel8]				8086
+LOOPE		imm,reg_cx			[i-:	a16 e1 rel8]				8086,NOLONG
+LOOPE		imm,reg_ecx			[i-:	a32 e1 rel8]				386
+LOOPE		imm,reg_rcx			[i-:	a64 e1 rel8]				X86_64,LONG
+LOOPNE		imm				[i:	adf e0 rel8]				8086
+LOOPNE		imm,reg_cx			[i-:	a16 e0 rel8]				8086,NOLONG
+LOOPNE		imm,reg_ecx			[i-:	a32 e0 rel8]				386
+LOOPNE		imm,reg_rcx			[i-:	a64 e0 rel8]				X86_64,LONG
+LOOPNZ		imm				[i:	adf e0 rel8]				8086
+LOOPNZ		imm,reg_cx			[i-:	a16 e0 rel8]				8086,NOLONG
+LOOPNZ		imm,reg_ecx			[i-:	a32 e0 rel8]				386
+LOOPNZ		imm,reg_rcx			[i-:	a64 e0 rel8]				X86_64,LONG
+LOOPZ		imm				[i:	adf e1 rel8]				8086
+LOOPZ		imm,reg_cx			[i-:	a16 e1 rel8]				8086,NOLONG
+LOOPZ		imm,reg_ecx			[i-:	a32 e1 rel8]				386
+LOOPZ		imm,reg_rcx			[i-:	a64 e1 rel8]				X86_64,LONG
+LSL		reg16,mem			[rm:	o16 0f 03 /r]				286,PROT,SW
+LSL		reg16,reg16			[rm:	o16 0f 03 /r]				286,PROT
+LSL		reg16,reg32			[rm:	o16 0f 03 /r]				386,PROT
+LSL		reg16,reg64			[rm:	o16 o64nw 0f 03 /r]			X86_64,LONG,PROT,ND
+LSL		reg32,mem			[rm:	o32 0f 03 /r]				386,PROT,SW
+LSL		reg32,reg16			[rm:	o32 0f 03 /r]				386,PROT
+LSL		reg32,reg32			[rm:	o32 0f 03 /r]				386,PROT
+LSL		reg32,reg64			[rm:	o32 o64nw 0f 03 /r]			X86_64,LONG,PROT,ND
+LSL		reg64,mem			[rm:	o64 0f 03 /r]				X86_64,LONG,PROT,SW
+LSL		reg64,reg16			[rm:	o64 0f 03 /r]				X86_64,LONG,PROT
+LSL		reg64,reg32			[rm:	o64 0f 03 /r]				X86_64,LONG,PROT
+LSL		reg64,reg64			[rm:	o64 0f 03 /r]				X86_64,LONG,PROT
+LSS		reg16,mem			[rm:	o16 0f b2 /r]				386
+LSS		reg32,mem			[rm:	o32 0f b2 /r]				386
+LSS		reg64,mem			[rm:	o64 0f b2 /r]				X86_64,LONG
+LTR		mem				[m:	0f 00 /3]				286,PROT,PRIV
+LTR		mem16				[m:	0f 00 /3]				286,PROT,PRIV
+LTR		reg16				[m:	0f 00 /3]				286,PROT,PRIV
+MFENCE		void				[	np 0f ae f0]				X86_64,LONG,AMD
+MONITOR		void				[	0f 01 c8]				PRESCOTT
+MONITOR		reg_eax,reg_ecx,reg_edx		[---:	0f 01 c8]				PRESCOTT,NOLONG,ND
+MONITOR		reg_rax,reg_ecx,reg_edx		[---:	0f 01 c8]				X86_64,LONG,ND
+MONITORX	void				[	0f 01 fa]				AMD
+MONITORX	reg_rax,reg_ecx,reg_edx		[---:	0f 01 fa]				X86_64,LONG,AMD,ND
+MONITORX	reg_eax,reg_ecx,reg_edx		[---:	0f 01 fa]				AMD,ND
+MONITORX	reg_ax,reg_ecx,reg_edx		[---:	0f 01 fa]				AMD,ND
+MOV		mem,reg_sreg			[mr:	8c /r]					8086,SW
+MOV		reg16,reg_sreg			[mr:	o16 8c /r]				8086
+MOV		reg32,reg_sreg			[mr:	o32 8c /r]				386
+MOV		reg64,reg_sreg			[mr:	o64nw 8c /r]				X86_64,LONG,OPT,ND
+MOV		rm64,reg_sreg			[mr:	o64 8c /r]				X86_64,LONG
+MOV		reg_sreg,mem			[rm:	8e /r]					8086,SW
+MOV		reg_sreg,reg16			[rm:	8e /r]					8086,OPT,ND
+MOV		reg_sreg,reg32			[rm:	8e /r]					386,OPT,ND
+MOV		reg_sreg,reg64			[rm:	o64nw 8e /r]				X86_64,LONG,OPT,ND
+MOV		reg_sreg,reg16			[rm:	o16 8e /r]				8086
+MOV		reg_sreg,reg32			[rm:	o32 8e /r]				386
+MOV		reg_sreg,rm64			[rm:	o64 8e /r]				X86_64,LONG
+MOV		reg_al,mem_offs			[-i:	a0 iwdq]				8086,SM
+MOV		reg_ax,mem_offs			[-i:	o16 a1 iwdq]				8086,SM
+MOV		reg_eax,mem_offs		[-i:	o32 a1 iwdq]				386,SM
+MOV		reg_rax,mem_offs		[-i:	o64 a1 iwdq]				X86_64,LONG,SM
+MOV		mem_offs,reg_al			[i-:	a2 iwdq]				8086,SM,NOHLE
+MOV		mem_offs,reg_ax			[i-:	o16 a3 iwdq]				8086,SM,NOHLE
+MOV		mem_offs,reg_eax		[i-:	o32 a3 iwdq]				386,SM,NOHLE
+MOV		mem_offs,reg_rax		[i-:	o64 a3 iwdq]				X86_64,LONG,SM,NOHLE
+MOV		reg32,reg_creg			[mr:	rex.l 0f 20 /r]				386,PRIV,NOLONG
+MOV		reg64,reg_creg			[mr:	o64nw 0f 20 /r]				X86_64,LONG,PRIV
+MOV		reg_creg,reg32			[rm:	rex.l 0f 22 /r]				386,PRIV,NOLONG
+MOV		reg_creg,reg64			[rm:	o64nw 0f 22 /r]				X86_64,LONG,PRIV
+MOV		reg32,reg_dreg			[mr:	0f 21 /r]				386,PRIV,NOLONG
+MOV		reg64,reg_dreg			[mr:	o64nw 0f 21 /r]				X86_64,LONG,PRIV
+MOV		reg_dreg,reg32			[rm:	0f 23 /r]				386,PRIV,NOLONG
+MOV		reg_dreg,reg64			[rm:	o64nw 0f 23 /r]				X86_64,LONG,PRIV
+MOV		reg32,reg_treg			[mr:	0f 24 /r]				386,NOLONG,ND
+MOV		reg_treg,reg32			[rm:	0f 26 /r]				386,NOLONG,ND
+MOV		mem,reg8			[mr:	hlexr 88 /r]				8086,SM
+MOV		reg8,reg8			[mr:	88 /r]					8086
+MOV		mem,reg16			[mr:	hlexr o16 89 /r]			8086,SM
+MOV		reg16,reg16			[mr:	o16 89 /r]				8086
+MOV		mem,reg32			[mr:	hlexr o32 89 /r]			386,SM
+MOV		reg32,reg32			[mr:	o32 89 /r]				386
+MOV		mem,reg64			[mr:	hlexr o64 89 /r]			X86_64,LONG,SM
+MOV		reg64,reg64			[mr:	o64 89 /r]				X86_64,LONG
+MOV		reg8,mem			[rm:	8a /r]					8086,SM
+MOV		reg8,reg8			[rm:	8a /r]					8086
+MOV		reg16,mem			[rm:	o16 8b /r]				8086,SM
+MOV		reg16,reg16			[rm:	o16 8b /r]				8086
+MOV		reg32,mem			[rm:	o32 8b /r]				386,SM
+MOV		reg32,reg32			[rm:	o32 8b /r]				386
+MOV		reg64,mem			[rm:	o64 8b /r]				X86_64,LONG,SM
+MOV		reg64,reg64			[rm:	o64 8b /r]				X86_64,LONG
+MOV		reg8,imm			[ri:	b0+r ib]				8086,SM
+MOV		reg16,imm			[ri:	o16 b8+r iw]				8086,SM
+MOV		reg32,imm			[ri:	o32 b8+r id]				386,SM
+MOV		reg64,udword			[ri:	o64nw b8+r id]				X86_64,LONG,SM,OPT,ND
+MOV		reg64,sdword			[mi:	o64 c7 /0 id,s]				X86_64,LONG,SM,OPT,ND
+MOV		reg64,imm			[ri:	o64 b8+r iq]				X86_64,LONG,SM
+MOV		rm8,imm				[mi:	hlexr c6 /0 ib]				8086,SM
+MOV		rm16,imm			[mi:	hlexr o16 c7 /0 iw]			8086,SM
+MOV		rm32,imm			[mi:	hlexr o32 c7 /0 id]			386,SM
+MOV		rm64,imm			[mi:	hlexr o64 c7 /0 id,s]			X86_64,LONG,SM
+MOV		rm64,imm32			[mi:	hlexr o64 c7 /0 id,s]			X86_64,LONG
+MOV		mem,imm8			[mi:	hlexr c6 /0 ib]				8086,SM
+MOV		mem,imm16			[mi:	hlexr o16 c7 /0 iw]			8086,SM
+MOV		mem,imm32			[mi:	hlexr o32 c7 /0 id]			386,SM
+MOVD		mmxreg,rm32			[rm:	np 0f 6e /r]				PENT,MMX,SD
+MOVD		rm32,mmxreg			[mr:	np 0f 7e /r]				PENT,MMX,SD
+MOVD		mmxreg,rm64			[rm:	np o64 0f 6e /r]			X86_64,LONG,MMX,SX,ND
+MOVD		rm64,mmxreg			[mr:	np o64 0f 7e /r]			X86_64,LONG,MMX,SX,ND
+MOVQ		mmxreg,mmxrm			[rm:	np 0f 6f /r]				PENT,MMX,SQ
+MOVQ		mmxrm,mmxreg			[mr:	np 0f 7f /r]				PENT,MMX,SQ
+MOVQ		mmxreg,rm64			[rm:	np o64 0f 6e /r]			X86_64,LONG,MMX
+MOVQ		rm64,mmxreg			[mr:	np o64 0f 7e /r]			X86_64,LONG,MMX
+MOVSB		void				[	a4]					8086
+MOVSD		void				[	o32 a5]					386
+MOVSQ		void				[	o64 a5]					X86_64,LONG
+MOVSW		void				[	o16 a5]					8086
+MOVSX		reg16,mem			[rm:	o16 0f be /r]				386,SB
+MOVSX		reg16,reg8			[rm:	o16 0f be /r]				386
+MOVSX		reg32,rm8			[rm:	o32 0f be /r]				386
+MOVSX		reg32,rm16			[rm:	o32 0f bf /r]				386
+MOVSX		reg64,rm8			[rm:	o64 0f be /r]				X86_64,LONG
+MOVSX		reg64,rm16			[rm:	o64 0f bf /r]				X86_64,LONG
+MOVSXD		reg64,rm32			[rm:	o64 63 /r]				X86_64,LONG
+MOVSX		reg64,rm32			[rm:	o64 63 /r]				X86_64,LONG,ND
+MOVZX		reg16,mem			[rm:	o16 0f b6 /r]				386,SB
+MOVZX		reg16,reg8			[rm:	o16 0f b6 /r]				386
+MOVZX		reg32,rm8			[rm:	o32 0f b6 /r]				386
+MOVZX		reg32,rm16			[rm:	o32 0f b7 /r]				386
+MOVZX		reg64,rm8			[rm:	o64 0f b6 /r]				X86_64,LONG
+MOVZX		reg64,rm16			[rm:	o64 0f b7 /r]				X86_64,LONG
+MUL		rm8				[m:	f6 /4]					8086
+MUL		rm16				[m:	o16 f7 /4]				8086
+MUL		rm32				[m:	o32 f7 /4]				386
+MUL		rm64				[m:	o64 f7 /4]				X86_64,LONG
+MWAIT		void				[	0f 01 c9]				PRESCOTT
+MWAIT		reg_eax,reg_ecx			[--:	0f 01 c9]				PRESCOTT,ND
+MWAITX		void				[	0f 01 fb]				AMD
+MWAITX		reg_eax,reg_ecx			[--:	0f 01 fb]				AMD,ND
+NEG		rm8				[m:	hle f6 /3]				8086,LOCK
+NEG		rm16				[m:	hle o16 f7 /3]				8086,LOCK
+NEG		rm32				[m:	hle o32 f7 /3]				386,LOCK
+NEG		rm64				[m:	hle o64 f7 /3]				X86_64,LONG,LOCK
+NOP		void				[	norexb nof3 90]				8086
+NOP		rm16				[m:	o16 0f 1f /0]				P6
+NOP		rm32				[m:	o32 0f 1f /0]				P6
+NOP		rm64				[m:	o64 0f 1f /0]				X86_64,LONG
+NOT		rm8				[m:	hle f6 /2]				8086,LOCK
+NOT		rm16				[m:	hle o16 f7 /2]				8086,LOCK
+NOT		rm32				[m:	hle o32 f7 /2]				386,LOCK
+NOT		rm64				[m:	hle o64 f7 /2]				X86_64,LONG,LOCK
+OR		mem,reg8			[mr:	hle 08 /r]				8086,SM,LOCK
+OR		reg8,reg8			[mr:	08 /r]					8086
+OR		mem,reg16			[mr:	hle o16 09 /r]				8086,SM,LOCK
+OR		reg16,reg16			[mr:	o16 09 /r]				8086
+OR		mem,reg32			[mr:	hle o32 09 /r]				386,SM,LOCK
+OR		reg32,reg32			[mr:	o32 09 /r]				386
+OR		mem,reg64			[mr:	hle o64 09 /r]				X86_64,LONG,SM,LOCK
+OR		reg64,reg64			[mr:	o64 09 /r]				X86_64,LONG
+OR		reg8,mem			[rm:	0a /r]					8086,SM
+OR		reg8,reg8			[rm:	0a /r]					8086
+OR		reg16,mem			[rm:	o16 0b /r]				8086,SM
+OR		reg16,reg16			[rm:	o16 0b /r]				8086
+OR		reg32,mem			[rm:	o32 0b /r]				386,SM
+OR		reg32,reg32			[rm:	o32 0b /r]				386
+OR		reg64,mem			[rm:	o64 0b /r]				X86_64,LONG,SM
+OR		reg64,reg64			[rm:	o64 0b /r]				X86_64,LONG
+OR		rm16,imm8			[mi:	hle o16 83 /1 ib,s]			8086,LOCK
+OR		rm32,imm8			[mi:	hle o32 83 /1 ib,s]			386,LOCK
+OR		rm64,imm8			[mi:	hle o64 83 /1 ib,s]			X86_64,LONG,LOCK
+OR		reg_al,imm			[-i:	0c ib]					8086,SM
+OR		reg_ax,sbyteword		[mi:	o16 83 /1 ib,s]				8086,SM,ND
+OR		reg_ax,imm			[-i:	o16 0d iw]				8086,SM
+OR		reg_eax,sbytedword		[mi:	o32 83 /1 ib,s]				386,SM,ND
+OR		reg_eax,imm			[-i:	o32 0d id]				386,SM
+OR		reg_rax,sbytedword		[mi:	o64 83 /1 ib,s]				X86_64,LONG,SM,ND
+OR		reg_rax,imm			[-i:	o64 0d id,s]				X86_64,LONG,SM
+OR		rm8,imm				[mi:	hle 80 /1 ib]				8086,SM,LOCK
+OR		rm16,sbyteword			[mi:	hle o16 83 /1 ib,s]			8086,SM,LOCK,ND
+OR		rm16,imm			[mi:	hle o16 81 /1 iw]			8086,SM,LOCK
+OR		rm32,sbytedword			[mi:	hle o32 83 /1 ib,s]			386,SM,LOCK,ND
+OR		rm32,imm			[mi:	hle o32 81 /1 id]			386,SM,LOCK
+OR		rm64,sbytedword			[mi:	hle o64 83 /1 ib,s]			X86_64,LONG,SM,LOCK,ND
+OR		rm64,imm			[mi:	hle o64 81 /1 id,s]			X86_64,LONG,SM,LOCK
+OR		mem,imm8			[mi:	hle 80 /1 ib]				8086,SM,LOCK
+OR		mem,sbyteword16			[mi:	hle o16 83 /1 ib,s]			8086,SM,LOCK,ND
+OR		mem,imm16			[mi:	hle o16 81 /1 iw]			8086,SM,LOCK
+OR		mem,sbytedword32		[mi:	hle o32 83 /1 ib,s]			386,SM,LOCK,ND
+OR		mem,imm32			[mi:	hle o32 81 /1 id]			386,SM,LOCK
+OR		rm8,imm				[mi:	hle 82 /1 ib]				8086,SM,LOCK,ND,NOLONG
+OUT		imm,reg_al			[i-:	e6 ib,u]				8086,SB
+OUT		imm,reg_ax			[i-:	o16 e7 ib,u]				8086,SB
+OUT		imm,reg_eax			[i-:	o32 e7 ib,u]				386,SB
+OUT		reg_dx,reg_al			[--:	ee]					8086
+OUT		reg_dx,reg_ax			[--:	o16 ef]					8086
+OUT		reg_dx,reg_eax			[--:	o32 ef]					386
+OUTSB		void				[	6e]					186
+OUTSD		void				[	o32 6f]					386
+OUTSW		void				[	o16 6f]					186
+PACKSSDW	mmxreg,mmxrm			[rm:	np o64nw 0f 6b /r]			PENT,MMX,SQ
+PACKSSWB	mmxreg,mmxrm			[rm:	np o64nw 0f 63 /r]			PENT,MMX,SQ
+PACKUSWB	mmxreg,mmxrm			[rm:	np o64nw 0f 67 /r]			PENT,MMX,SQ
+PADDB		mmxreg,mmxrm			[rm:	np o64nw 0f fc /r]			PENT,MMX,SQ
+PADDD		mmxreg,mmxrm			[rm:	np o64nw 0f fe /r]			PENT,MMX,SQ
+PADDSB		mmxreg,mmxrm			[rm:	np o64nw 0f ec /r]			PENT,MMX,SQ
+PADDSIW		mmxreg,mmxrm			[rm:	o64nw 0f 51 /r]				PENT,MMX,SQ,CYRIX
+PADDSW		mmxreg,mmxrm			[rm:	np o64nw 0f ed /r]			PENT,MMX,SQ
+PADDUSB		mmxreg,mmxrm			[rm:	np o64nw 0f dc /r]			PENT,MMX,SQ
+PADDUSW		mmxreg,mmxrm			[rm:	np o64nw 0f dd /r]			PENT,MMX,SQ
+PADDW		mmxreg,mmxrm			[rm:	np o64nw 0f fd /r]			PENT,MMX,SQ
+PAND		mmxreg,mmxrm			[rm:	np o64nw 0f db /r]			PENT,MMX,SQ
+PANDN		mmxreg,mmxrm			[rm:	np o64nw 0f df /r]			PENT,MMX,SQ
+PAUSE		void				[	f3i 90]					8086
+PAVEB		mmxreg,mmxrm			[rm:	o64nw 0f 50 /r]				PENT,MMX,SQ,CYRIX
+PAVGUSB		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r bf]			PENT,3DNOW,SQ
+PCMPEQB		mmxreg,mmxrm			[rm:	np o64nw 0f 74 /r]			PENT,MMX,SQ
+PCMPEQD		mmxreg,mmxrm			[rm:	np o64nw 0f 76 /r]			PENT,MMX,SQ
+PCMPEQW		mmxreg,mmxrm			[rm:	np o64nw 0f 75 /r]			PENT,MMX,SQ
+PCMPGTB		mmxreg,mmxrm			[rm:	np o64nw 0f 64 /r]			PENT,MMX,SQ
+PCMPGTD		mmxreg,mmxrm			[rm:	np o64nw 0f 66 /r]			PENT,MMX,SQ
+PCMPGTW		mmxreg,mmxrm			[rm:	np o64nw 0f 65 /r]			PENT,MMX,SQ
+PDISTIB		mmxreg,mem			[rm:	0f 54 /r]				PENT,MMX,SM,CYRIX
+PF2ID		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 1d]			PENT,3DNOW,SQ
+PFACC		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r ae]			PENT,3DNOW,SQ
+PFADD		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 9e]			PENT,3DNOW,SQ
+PFCMPEQ		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r b0]			PENT,3DNOW,SQ
+PFCMPGE		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 90]			PENT,3DNOW,SQ
+PFCMPGT		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r a0]			PENT,3DNOW,SQ
+PFMAX		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r a4]			PENT,3DNOW,SQ
+PFMIN		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 94]			PENT,3DNOW,SQ
+PFMUL		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r b4]			PENT,3DNOW,SQ
+PFRCP		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 96]			PENT,3DNOW,SQ
+PFRCPIT1	mmxreg,mmxrm			[rm:	o64nw 0f 0f /r a6]			PENT,3DNOW,SQ
+PFRCPIT2	mmxreg,mmxrm			[rm:	o64nw 0f 0f /r b6]			PENT,3DNOW,SQ
+PFRSQIT1	mmxreg,mmxrm			[rm:	o64nw 0f 0f /r a7]			PENT,3DNOW,SQ
+PFRSQRT		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 97]			PENT,3DNOW,SQ
+PFSUB		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 9a]			PENT,3DNOW,SQ
+PFSUBR		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r aa]			PENT,3DNOW,SQ
+PI2FD		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 0d]			PENT,3DNOW,SQ
+PMACHRIW	mmxreg,mem			[rm:	0f 5e /r]				PENT,MMX,SM,CYRIX
+PMADDWD		mmxreg,mmxrm			[rm:	np o64nw 0f f5 /r]			PENT,MMX,SQ
+PMAGW		mmxreg,mmxrm			[rm:	o64nw 0f 52 /r]				PENT,MMX,SQ,CYRIX
+PMULHRIW	mmxreg,mmxrm			[rm:	o64nw 0f 5d /r]				PENT,MMX,SQ,CYRIX
+PMULHRWA	mmxreg,mmxrm			[rm:	o64nw 0f 0f /r b7]			PENT,3DNOW,SQ
+PMULHRWC	mmxreg,mmxrm			[rm:	o64nw 0f 59 /r]				PENT,MMX,SQ,CYRIX
+PMULHW		mmxreg,mmxrm			[rm:	np o64nw 0f e5 /r]			PENT,MMX,SQ
+PMULLW		mmxreg,mmxrm			[rm:	np o64nw 0f d5 /r]			PENT,MMX,SQ
+PMVGEZB		mmxreg,mem			[rm:	0f 5c /r]				PENT,MMX,SQ,CYRIX
+PMVLZB		mmxreg,mem			[rm:	0f 5b /r]				PENT,MMX,SQ,CYRIX
+PMVNZB		mmxreg,mem			[rm:	0f 5a /r]				PENT,MMX,SQ,CYRIX
+PMVZB		mmxreg,mem			[rm:	0f 58 /r]				PENT,MMX,SQ,CYRIX
+POP		reg16				[r:	o16 58+r]				8086
+POP		reg32				[r:	o32 58+r]				386,NOLONG
+POP		reg64				[r:	o64nw 58+r]				X86_64,LONG
+POP		rm16				[m:	o16 8f /0]				8086
+POP		rm32				[m:	o32 8f /0]				386,NOLONG
+POP		rm64				[m:	o64nw 8f /0]				X86_64,LONG
+POP		reg_es				[-:	07]					8086,NOLONG
+POP		reg_cs				[-:	0f]					8086,UNDOC,ND,OBSOLETE
+POP		reg_ss				[-:	17]					8086,NOLONG
+POP		reg_ds				[-:	1f]					8086,NOLONG
+POP		reg_fs				[-:	0f a1]					386
+POP		reg_gs				[-:	0f a9]					386
+POPA		void				[	odf 61]					186,NOLONG
+POPAD		void				[	o32 61]					386,NOLONG
+POPAW		void				[	o16 61]					186,NOLONG
+POPF		void				[	odf 9d]					8086
+POPFD		void				[	o32 9d]					386,NOLONG
+POPFQ		void				[	o32 9d]					X86_64,LONG
+POPFW		void				[	o16 9d]					8086
+POR		mmxreg,mmxrm			[rm:	np o64nw 0f eb /r]			PENT,MMX,SQ
+PREFETCH	mem				[m:	0f 0d /0]				PENT,3DNOW,SQ
+PREFETCHW	mem				[m:	0f 0d /1]				PENT,3DNOW,SQ
+PSLLD		mmxreg,mmxrm			[rm:	np o64nw 0f f2 /r]			PENT,MMX,SQ
+PSLLD		mmxreg,imm			[mi:	np 0f 72 /6 ib,u]			PENT,MMX
+PSLLQ		mmxreg,mmxrm			[rm:	np o64nw 0f f3 /r]			PENT,MMX,SQ
+PSLLQ		mmxreg,imm			[mi:	np 0f 73 /6 ib,u]			PENT,MMX
+PSLLW		mmxreg,mmxrm			[rm:	np o64nw 0f f1 /r]			PENT,MMX,SQ
+PSLLW		mmxreg,imm			[mi:	np 0f 71 /6 ib,u]			PENT,MMX
+PSRAD		mmxreg,mmxrm			[rm:	np o64nw 0f e2 /r]			PENT,MMX,SQ
+PSRAD		mmxreg,imm			[mi:	np 0f 72 /4 ib,u]			PENT,MMX
+PSRAW		mmxreg,mmxrm			[rm:	np o64nw 0f e1 /r]			PENT,MMX,SQ
+PSRAW		mmxreg,imm			[mi:	np 0f 71 /4 ib,u]			PENT,MMX
+PSRLD		mmxreg,mmxrm			[rm:	np o64nw 0f d2 /r]			PENT,MMX,SQ
+PSRLD		mmxreg,imm			[mi:	np 0f 72 /2 ib,u]			PENT,MMX
+PSRLQ		mmxreg,mmxrm			[rm:	np o64nw 0f d3 /r]			PENT,MMX,SQ
+PSRLQ		mmxreg,imm			[mi:	np 0f 73 /2 ib,u]			PENT,MMX
+PSRLW		mmxreg,mmxrm			[rm:	np o64nw 0f d1 /r]			PENT,MMX,SQ
+PSRLW		mmxreg,imm			[mi:	np 0f 71 /2 ib,u]			PENT,MMX
+PSUBB		mmxreg,mmxrm			[rm:	np o64nw 0f f8 /r]			PENT,MMX,SQ
+PSUBD		mmxreg,mmxrm			[rm:	np o64nw 0f fa /r]			PENT,MMX,SQ
+PSUBSB		mmxreg,mmxrm			[rm:	np o64nw 0f e8 /r]			PENT,MMX,SQ
+PSUBSIW		mmxreg,mmxrm			[rm:	o64nw 0f 55 /r]				PENT,MMX,SQ,CYRIX
+PSUBSW		mmxreg,mmxrm			[rm:	np o64nw 0f e9 /r]			PENT,MMX,SQ
+PSUBUSB		mmxreg,mmxrm			[rm:	np o64nw 0f d8 /r]			PENT,MMX,SQ
+PSUBUSW		mmxreg,mmxrm			[rm:	np o64nw 0f d9 /r]			PENT,MMX,SQ
+PSUBW		mmxreg,mmxrm			[rm:	np o64nw 0f f9 /r]			PENT,MMX,SQ
+PUNPCKHBW	mmxreg,mmxrm			[rm:	np o64nw 0f 68 /r]			PENT,MMX,SQ
+PUNPCKHDQ	mmxreg,mmxrm			[rm:	np o64nw 0f 6a /r]			PENT,MMX,SQ
+PUNPCKHWD	mmxreg,mmxrm			[rm:	np o64nw 0f 69 /r]			PENT,MMX,SQ
+PUNPCKLBW	mmxreg,mmxrm			[rm:	np o64nw 0f 60 /r]			PENT,MMX,SQ
+PUNPCKLDQ	mmxreg,mmxrm			[rm:	np o64nw 0f 62 /r]			PENT,MMX,SQ
+PUNPCKLWD	mmxreg,mmxrm			[rm:	np o64nw 0f 61 /r]			PENT,MMX,SQ
+PUSH		reg16				[r:	o16 50+r]				8086
+PUSH		reg32				[r:	o32 50+r]				386,NOLONG
+PUSH		reg64				[r:	o64nw 50+r]				X86_64,LONG
+PUSH		rm16				[m:	o16 ff /6]				8086
+PUSH		rm32				[m:	o32 ff /6]				386,NOLONG
+PUSH		rm64				[m:	o64nw ff /6]				X86_64,LONG
+PUSH		reg_es				[-:	06]					8086,NOLONG
+PUSH		reg_cs				[-:	0e]					8086,NOLONG
+PUSH		reg_ss				[-:	16]					8086,NOLONG
+PUSH		reg_ds				[-:	1e]					8086,NOLONG
+PUSH		reg_fs				[-:	0f a0]					386
+PUSH		reg_gs				[-:	0f a8]					386
+PUSH		imm8				[i:	6a ib,s]					186
+PUSH		sbyteword16			[i:	o16 6a ib,s]				186,AR0,SIZE,ND
+PUSH		imm16				[i:	o16 68 iw]				186,AR0,SIZE
+PUSH		sbytedword32			[i:	o32 6a ib,s]				386,NOLONG,AR0,SIZE,ND
+PUSH		imm32				[i:	o32 68 id]				386,NOLONG,AR0,SIZE
+PUSH		sbytedword32			[i:	o32 6a ib,s]				386,NOLONG,SD,ND
+PUSH		imm32				[i:	o32 68 id]				386,NOLONG,SD
+PUSH		sbytedword64			[i:	o64nw 6a ib,s]				X86_64,LONG,AR0,SIZE,ND
+PUSH		imm64				[i:	o64nw 68 id,s]				X86_64,LONG,AR0,SIZE
+PUSH		sbytedword32			[i:	o64nw 6a ib,s]				X86_64,LONG,AR0,SIZE,ND
+PUSH		imm32				[i:	o64nw 68 id,s]				X86_64,LONG,AR0,SIZE
+PUSHA		void				[	odf 60]					186,NOLONG
+PUSHAD		void				[	o32 60]					386,NOLONG
+PUSHAW		void				[	o16 60]					186,NOLONG
+PUSHF		void				[	odf 9c]					8086
+PUSHFD		void				[	o32 9c]					386,NOLONG
+PUSHFQ		void				[	o32 9c]					X86_64,LONG
+PUSHFW		void				[	o16 9c]					8086
+PXOR		mmxreg,mmxrm			[rm:	np o64nw 0f ef /r]			PENT,MMX,SQ
+RCL		rm8,unity			[m-:	d0 /2]					8086
+RCL		rm8,reg_cl			[m-:	d2 /2]					8086
+RCL		rm8,imm8			[mi:	c0 /2 ib,u]				186
+RCL		rm16,unity			[m-:	o16 d1 /2]				8086
+RCL		rm16,reg_cl			[m-:	o16 d3 /2]				8086
+RCL		rm16,imm8			[mi:	o16 c1 /2 ib,u]				186
+RCL		rm32,unity			[m-:	o32 d1 /2]				386
+RCL		rm32,reg_cl			[m-:	o32 d3 /2]				386
+RCL		rm32,imm8			[mi:	o32 c1 /2 ib,u]				386
+RCL		rm64,unity			[m-:	o64 d1 /2]				X86_64,LONG
+RCL		rm64,reg_cl			[m-:	o64 d3 /2]				X86_64,LONG
+RCL		rm64,imm8			[mi:	o64 c1 /2 ib,u]				X86_64,LONG
+RCR		rm8,unity			[m-:	d0 /3]					8086
+RCR		rm8,reg_cl			[m-:	d2 /3]					8086
+RCR		rm8,imm8			[mi:	c0 /3 ib,u]				186
+RCR		rm16,unity			[m-:	o16 d1 /3]				8086
+RCR		rm16,reg_cl			[m-:	o16 d3 /3]				8086
+RCR		rm16,imm8			[mi:	o16 c1 /3 ib,u]				186
+RCR		rm32,unity			[m-:	o32 d1 /3]				386
+RCR		rm32,reg_cl			[m-:	o32 d3 /3]				386
+RCR		rm32,imm8			[mi:	o32 c1 /3 ib,u]				386
+RCR		rm64,unity			[m-:	o64 d1 /3]				X86_64,LONG
+RCR		rm64,reg_cl			[m-:	o64 d3 /3]				X86_64,LONG
+RCR		rm64,imm8			[mi:	o64 c1 /3 ib,u]				X86_64,LONG
+RDSHR		rm32				[m:	o32 0f 36 /0]				P6,CYRIX,SMM
+RDMSR		void				[	0f 32]					PENT,PRIV
+RDPMC		void				[	0f 33]					P6
+RDTSC		void				[	0f 31]					PENT
+RDTSCP		void				[	0f 01 f9]				X86_64
+RET		void				[	c3]					8086,BND
+RET		imm				[i:	c2 iw]					8086,SW,BND
+RETF		void				[	cb]					8086
+RETF		imm				[i:	ca iw]					8086,SW
+RETN		void				[	c3]					8086,BND
+RETN		imm				[i:	c2 iw]					8086,SW,BND
+RETW		void				[	o16 c3]					8086,BND
+RETW		imm				[i:	c2 iw]					8086,SW,BND
+RETFW		void				[	o16 cb]					8086
+RETFW		imm				[i:	o16 ca iw]				8086,SW
+RETNW		void				[	o16 c3]					8086,BND
+RETNW		imm				[i:	o16 c2 iw]				8086,SW,BND
+RETD		void				[	o32 c3]					8086,BND,NOLONG
+RETD		imm				[i:	o32 c2 iw]				8086,SW,BND,NOLONG
+RETFD		void				[	o32 cb]					8086
+RETFD		imm				[i:	o32 ca iw]				8086,SW
+RETND		void				[	o32 c3]					8086,BND,NOLONG
+RETND		imm				[i:	o32 c2 iw]				8086,SW,BND,NOLONG
+RETQ		void				[	o64nw c3]				X86_64,LONG,BND
+RETQ		imm				[i:	o64nw c2 iw]				X86_64,LONG,SW,BND
+RETFQ		void				[	o64 cb]					X86_64,LONG
+RETFQ		imm				[i:	o64 ca iw]				X86_64,LONG,SW
+RETNQ		void				[	o64nw c3]				X86_64,LONG,BND
+RETNQ		imm				[i:	o64nw c2 iw]				X86_64,LONG,SW,BND
+
+ROL		rm8,unity			[m-:	d0 /0]					8086
+ROL		rm8,reg_cl			[m-:	d2 /0]					8086
+ROL		rm8,imm8			[mi:	c0 /0 ib,u]				186
+ROL		rm16,unity			[m-:	o16 d1 /0]				8086
+ROL		rm16,reg_cl			[m-:	o16 d3 /0]				8086
+ROL		rm16,imm8			[mi:	o16 c1 /0 ib,u]				186
+ROL		rm32,unity			[m-:	o32 d1 /0]				386
+ROL		rm32,reg_cl			[m-:	o32 d3 /0]				386
+ROL		rm32,imm8			[mi:	o32 c1 /0 ib,u]				386
+ROL		rm64,unity			[m-:	o64 d1 /0]				X86_64,LONG
+ROL		rm64,reg_cl			[m-:	o64 d3 /0]				X86_64,LONG
+ROL		rm64,imm8			[mi:	o64 c1 /0 ib,u]				X86_64,LONG
+ROR		rm8,unity			[m-:	d0 /1]					8086
+ROR		rm8,reg_cl			[m-:	d2 /1]					8086
+ROR		rm8,imm8			[mi:	c0 /1 ib,u]				186
+ROR		rm16,unity			[m-:	o16 d1 /1]				8086
+ROR		rm16,reg_cl			[m-:	o16 d3 /1]				8086
+ROR		rm16,imm8			[mi:	o16 c1 /1 ib,u]				186
+ROR		rm32,unity			[m-:	o32 d1 /1]				386
+ROR		rm32,reg_cl			[m-:	o32 d3 /1]				386
+ROR		rm32,imm8			[mi:	o32 c1 /1 ib,u]				386
+ROR		rm64,unity			[m-:	o64 d1 /1]				X86_64,LONG
+ROR		rm64,reg_cl			[m-:	o64 d3 /1]				X86_64,LONG
+ROR		rm64,imm8			[mi:	o64 c1 /1 ib,u]				X86_64,LONG
+RDM		void				[	0f 3a]					P6,CYRIX,ND
+RSDC		reg_sreg,mem80			[rm:	0f 79 /r]				486,CYRIX,SMM
+RSLDT		mem80				[m:	0f 7b /0]				486,CYRIX,SMM
+RSM		void				[	0f aa]					PENT,SMM
+RSTS		mem80				[m:	0f 7d /0]				486,CYRIX,SMM
+SAHF		void				[	9e]					8086
+SAL		rm8,unity			[m-:	d0 /4]					8086,ND
+SAL		rm8,reg_cl			[m-:	d2 /4]					8086,ND
+SAL		rm8,imm8			[mi:	c0 /4 ib,u]				186,ND
+SAL		rm16,unity			[m-:	o16 d1 /4]				8086,ND
+SAL		rm16,reg_cl			[m-:	o16 d3 /4]				8086,ND
+SAL		rm16,imm8			[mi:	o16 c1 /4 ib,u]				186,ND
+SAL		rm32,unity			[m-:	o32 d1 /4]				386,ND
+SAL		rm32,reg_cl			[m-:	o32 d3 /4]				386,ND
+SAL		rm32,imm8			[mi:	o32 c1 /4 ib,u]				386,ND
+SAL		rm64,unity			[m-:	o64 d1 /4]				X86_64,LONG,ND
+SAL		rm64,reg_cl			[m-:	o64 d3 /4]				X86_64,LONG,ND
+SAL		rm64,imm8			[mi:	o64 c1 /4 ib,u]				X86_64,LONG,ND
+SALC		void				[	d6]					8086,UNDOC
+SAR		rm8,unity			[m-:	d0 /7]					8086
+SAR		rm8,reg_cl			[m-:	d2 /7]					8086
+SAR		rm8,imm8			[mi:	c0 /7 ib,u]				186
+SAR		rm16,unity			[m-:	o16 d1 /7]				8086
+SAR		rm16,reg_cl			[m-:	o16 d3 /7]				8086
+SAR		rm16,imm8			[mi:	o16 c1 /7 ib,u]				186
+SAR		rm32,unity			[m-:	o32 d1 /7]				386
+SAR		rm32,reg_cl			[m-:	o32 d3 /7]				386
+SAR		rm32,imm8			[mi:	o32 c1 /7 ib,u]				386
+SAR		rm64,unity			[m-:	o64 d1 /7]				X86_64,LONG
+SAR		rm64,reg_cl			[m-:	o64 d3 /7]				X86_64,LONG
+SAR		rm64,imm8			[mi:	o64 c1 /7 ib,u]				X86_64,LONG
+SBB		mem,reg8			[mr:	hle 18 /r]				8086,SM,LOCK
+SBB		reg8,reg8			[mr:	18 /r]					8086
+SBB		mem,reg16			[mr:	hle o16 19 /r]				8086,SM,LOCK
+SBB		reg16,reg16			[mr:	o16 19 /r]				8086
+SBB		mem,reg32			[mr:	hle o32 19 /r]				386,SM,LOCK
+SBB		reg32,reg32			[mr:	o32 19 /r]				386
+SBB		mem,reg64			[mr:	hle o64 19 /r]				X86_64,LONG,SM,LOCK
+SBB		reg64,reg64			[mr:	o64 19 /r]				X86_64,LONG
+SBB		reg8,mem			[rm:	1a /r]					8086,SM
+SBB		reg8,reg8			[rm:	1a /r]					8086
+SBB		reg16,mem			[rm:	o16 1b /r]				8086,SM
+SBB		reg16,reg16			[rm:	o16 1b /r]				8086
+SBB		reg32,mem			[rm:	o32 1b /r]				386,SM
+SBB		reg32,reg32			[rm:	o32 1b /r]				386
+SBB		reg64,mem			[rm:	o64 1b /r]				X86_64,LONG,SM
+SBB		reg64,reg64			[rm:	o64 1b /r]				X86_64,LONG
+SBB		rm16,imm8			[mi:	hle o16 83 /3 ib,s]			8086,LOCK
+SBB		rm32,imm8			[mi:	hle o32 83 /3 ib,s]			386,LOCK
+SBB		rm64,imm8			[mi:	hle o64 83 /3 ib,s]			X86_64,LONG,LOCK
+SBB		reg_al,imm			[-i:	1c ib]					8086,SM
+SBB		reg_ax,sbyteword		[mi:	o16 83 /3 ib,s]				8086,SM,ND
+SBB		reg_ax,imm			[-i:	o16 1d iw]				8086,SM
+SBB		reg_eax,sbytedword		[mi:	o32 83 /3 ib,s]				386,SM,ND
+SBB		reg_eax,imm			[-i:	o32 1d id]				386,SM
+SBB		reg_rax,sbytedword		[mi:	o64 83 /3 ib,s]				X86_64,LONG,SM,ND
+SBB		reg_rax,imm			[-i:	o64 1d id,s]				X86_64,LONG,SM
+SBB		rm8,imm				[mi:	hle 80 /3 ib]				8086,SM,LOCK
+SBB		rm16,sbyteword			[mi:	hle o16 83 /3 ib,s]			8086,SM,LOCK,ND
+SBB		rm16,imm			[mi:	hle o16 81 /3 iw]			8086,SM,LOCK
+SBB		rm32,sbytedword			[mi:	hle o32 83 /3 ib,s]			386,SM,LOCK,ND
+SBB		rm32,imm			[mi:	hle o32 81 /3 id]			386,SM,LOCK
+SBB		rm64,sbytedword			[mi:	hle o64 83 /3 ib,s]			X86_64,LONG,SM,LOCK,ND
+SBB		rm64,imm			[mi:	hle o64 81 /3 id,s]			X86_64,LONG,SM,LOCK
+SBB		mem,imm8			[mi:	hle 80 /3 ib]				8086,SM,LOCK
+SBB		mem,sbyteword16			[mi:	hle o16 83 /3 ib,s]			8086,SM,LOCK,ND
+SBB		mem,imm16			[mi:	hle o16 81 /3 iw]			8086,SM,LOCK
+SBB		mem,sbytedword32		[mi:	hle o32 83 /3 ib,s]			386,SM,LOCK,ND
+SBB		mem,imm32			[mi:	hle o32 81 /3 id]			386,SM,LOCK
+SBB		rm8,imm				[mi:	hle 82 /3 ib]				8086,SM,LOCK,ND,NOLONG
+SCASB		void				[	repe ae]				8086
+SCASD		void				[	repe o32 af]				386
+SCASQ		void				[	repe o64 af]				X86_64,LONG
+SCASW		void				[	repe o16 af]				8086
+SFENCE		void				[	np 0f ae f8]				X86_64,LONG,AMD
+SGDT		mem				[m:	0f 01 /0]				286
+SHL		rm8,unity			[m-:	d0 /4]					8086
+SHL		rm8,reg_cl			[m-:	d2 /4]					8086
+SHL		rm8,imm8			[mi:	c0 /4 ib,u]				186
+SHL		rm16,unity			[m-:	o16 d1 /4]				8086
+SHL		rm16,reg_cl			[m-:	o16 d3 /4]				8086
+SHL		rm16,imm8			[mi:	o16 c1 /4 ib,u]				186
+SHL		rm32,unity			[m-:	o32 d1 /4]				386
+SHL		rm32,reg_cl			[m-:	o32 d3 /4]				386
+SHL		rm32,imm8			[mi:	o32 c1 /4 ib,u]				386
+SHL		rm64,unity			[m-:	o64 d1 /4]				X86_64,LONG
+SHL		rm64,reg_cl			[m-:	o64 d3 /4]				X86_64,LONG
+SHL		rm64,imm8			[mi:	o64 c1 /4 ib,u]				X86_64,LONG
+SHLD		mem,reg16,imm			[mri:	o16 0f a4 /r ib,u]			386,SM2,SB,AR2
+SHLD		reg16,reg16,imm			[mri:	o16 0f a4 /r ib,u]			386,SM2,SB,AR2
+SHLD		mem,reg32,imm			[mri:	o32 0f a4 /r ib,u]			386,SM2,SB,AR2
+SHLD		reg32,reg32,imm			[mri:	o32 0f a4 /r ib,u]			386,SM2,SB,AR2
+SHLD		mem,reg64,imm			[mri:	o64 0f a4 /r ib,u]			X86_64,LONG,SM2,SB,AR2
+SHLD		reg64,reg64,imm			[mri:	o64 0f a4 /r ib,u]			X86_64,LONG,SM2,SB,AR2
+SHLD		mem,reg16,reg_cl		[mr-:	o16 0f a5 /r]				386,SM
+SHLD		reg16,reg16,reg_cl		[mr-:	o16 0f a5 /r]				386
+SHLD		mem,reg32,reg_cl		[mr-:	o32 0f a5 /r]				386,SM
+SHLD		reg32,reg32,reg_cl		[mr-:	o32 0f a5 /r]				386
+SHLD		mem,reg64,reg_cl		[mr-:	o64 0f a5 /r]				X86_64,LONG,SM
+SHLD		reg64,reg64,reg_cl		[mr-:	o64 0f a5 /r]				X86_64,LONG
+SHR		rm8,unity			[m-:	d0 /5]					8086
+SHR		rm8,reg_cl			[m-:	d2 /5]					8086
+SHR		rm8,imm8			[mi:	c0 /5 ib,u]				186
+SHR		rm16,unity			[m-:	o16 d1 /5]				8086
+SHR		rm16,reg_cl			[m-:	o16 d3 /5]				8086
+SHR		rm16,imm8			[mi:	o16 c1 /5 ib,u]				186
+SHR		rm32,unity			[m-:	o32 d1 /5]				386
+SHR		rm32,reg_cl			[m-:	o32 d3 /5]				386
+SHR		rm32,imm8			[mi:	o32 c1 /5 ib,u]				386
+SHR		rm64,unity			[m-:	o64 d1 /5]				X86_64,LONG
+SHR		rm64,reg_cl			[m-:	o64 d3 /5]				X86_64,LONG
+SHR		rm64,imm8			[mi:	o64 c1 /5 ib,u]				X86_64,LONG
+SHRD		mem,reg16,imm			[mri:	o16 0f ac /r ib,u]			386,SM2,SB,AR2
+SHRD		reg16,reg16,imm			[mri:	o16 0f ac /r ib,u]			386,SM2,SB,AR2
+SHRD		mem,reg32,imm			[mri:	o32 0f ac /r ib,u]			386,SM2,SB,AR2
+SHRD		reg32,reg32,imm			[mri:	o32 0f ac /r ib,u]			386,SM2,SB,AR2
+SHRD		mem,reg64,imm			[mri:	o64 0f ac /r ib,u]			X86_64,LONG,SM2,SB,AR2
+SHRD		reg64,reg64,imm			[mri:	o64 0f ac /r ib,u]			X86_64,LONG,SM2,SB,AR2
+SHRD		mem,reg16,reg_cl		[mr-:	o16 0f ad /r]				386,SM
+SHRD		reg16,reg16,reg_cl		[mr-:	o16 0f ad /r]				386
+SHRD		mem,reg32,reg_cl		[mr-:	o32 0f ad /r]				386,SM
+SHRD		reg32,reg32,reg_cl		[mr-:	o32 0f ad /r]				386
+SHRD		mem,reg64,reg_cl		[mr-:	o64 0f ad /r]				X86_64,LONG,SM
+SHRD		reg64,reg64,reg_cl		[mr-:	o64 0f ad /r]				X86_64,LONG
+SIDT		mem				[m:	0f 01 /1]				286
+SLDT		mem				[m:	0f 00 /0]				286
+SLDT		mem16				[m:	0f 00 /0]				286
+SLDT		reg16				[m:	o16 0f 00 /0]				286
+SLDT		reg32				[m:	o32 0f 00 /0]				386
+SLDT		reg64				[m:	o64nw 0f 00 /0]				X86_64,LONG,ND
+SLDT		reg64				[m:	o64 0f 00 /0]				X86_64,LONG
+SKINIT		void				[	0f 01 de]				X86_64,LONG
+SMI		void				[	f1]					386,UNDOC
+SMINT		void				[	0f 38]					P6,CYRIX,ND
+; Older Cyrix chips had this; they had to move due to conflict with MMX
+SMINTOLD	void				[	0f 7e]					486,CYRIX,ND,OBSOLETE
+SMSW		mem				[m:	0f 01 /4]				286
+SMSW		mem16				[m:	0f 01 /4]				286
+SMSW		reg16				[m:	o16 0f 01 /4]				286
+SMSW		reg32				[m:	o32 0f 01 /4]				386
+SMSW		reg64				[m:	o64 0f 01 /4]				X86_64,LONG
+STC		void				[	f9]					8086
+STD		void				[	fd]					8086
+STI		void				[	fb]					8086
+STOSB		void				[	aa]					8086
+STOSD		void				[	o32 ab]					386
+STOSQ		void				[	o64 ab]					X86_64,LONG
+STOSW		void				[	o16 ab]					8086
+STR		mem				[m:	0f 00 /1]				286,PROT
+STR		mem16				[m:	0f 00 /1]				286,PROT
+STR		reg16				[m:	o16 0f 00 /1]				286,PROT
+STR		reg32				[m:	o32 0f 00 /1]				386,PROT
+STR		reg64				[m:	o64 0f 00 /1]				X86_64,LONG
+SUB		mem,reg8			[mr:	hle 28 /r]				8086,SM,LOCK
+SUB		reg8,reg8			[mr:	28 /r]					8086
+SUB		mem,reg16			[mr:	hle o16 29 /r]				8086,SM,LOCK
+SUB		reg16,reg16			[mr:	o16 29 /r]				8086
+SUB		mem,reg32			[mr:	hle o32 29 /r]				386,SM,LOCK
+SUB		reg32,reg32			[mr:	o32 29 /r]				386
+SUB		mem,reg64			[mr:	hle o64 29 /r]				X86_64,LONG,SM,LOCK
+SUB		reg64,reg64			[mr:	o64 29 /r]				X86_64,LONG
+SUB		reg8,mem			[rm:	2a /r]					8086,SM
+SUB		reg8,reg8			[rm:	2a /r]					8086
+SUB		reg16,mem			[rm:	o16 2b /r]				8086,SM
+SUB		reg16,reg16			[rm:	o16 2b /r]				8086
+SUB		reg32,mem			[rm:	o32 2b /r]				386,SM
+SUB		reg32,reg32			[rm:	o32 2b /r]				386
+SUB		reg64,mem			[rm:	o64 2b /r]				X86_64,LONG,SM
+SUB		reg64,reg64			[rm:	o64 2b /r]				X86_64,LONG
+SUB		rm16,imm8			[mi:	hle o16 83 /5 ib,s]			8086,LOCK
+SUB		rm32,imm8			[mi:	hle o32 83 /5 ib,s]			386,LOCK
+SUB		rm64,imm8			[mi:	hle o64 83 /5 ib,s]			X86_64,LONG,LOCK
+SUB		reg_al,imm			[-i:	2c ib]					8086,SM
+SUB		reg_ax,sbyteword		[mi:	o16 83 /5 ib,s]				8086,SM,ND
+SUB		reg_ax,imm			[-i:	o16 2d iw]				8086,SM
+SUB		reg_eax,sbytedword		[mi:	o32 83 /5 ib,s]				386,SM,ND
+SUB		reg_eax,imm			[-i:	o32 2d id]				386,SM
+SUB		reg_rax,sbytedword		[mi:	o64 83 /5 ib,s]				X86_64,LONG,SM,ND
+SUB		reg_rax,imm			[-i:	o64 2d id,s]				X86_64,LONG,SM
+SUB		rm8,imm				[mi:	hle 80 /5 ib]				8086,SM,LOCK
+SUB		rm16,sbyteword			[mi:	hle o16 83 /5 ib,s]			8086,SM,LOCK,ND
+SUB		rm16,imm			[mi:	hle o16 81 /5 iw]			8086,SM,LOCK
+SUB		rm32,sbytedword			[mi:	hle o32 83 /5 ib,s]			386,SM,LOCK,ND
+SUB		rm32,imm			[mi:	hle o32 81 /5 id]			386,SM,LOCK
+SUB		rm64,sbytedword			[mi:	hle o64 83 /5 ib,s]			X86_64,LONG,SM,LOCK,ND
+SUB		rm64,imm			[mi:	hle o64 81 /5 id,s]			X86_64,LONG,SM,LOCK
+SUB		mem,imm8			[mi:	hle 80 /5 ib]				8086,SM,LOCK
+SUB		mem,sbyteword16			[mi:	hle o16 83 /5 ib,s]			8086,SM,LOCK,ND
+SUB		mem,imm16			[mi:	hle o16 81 /5 iw]			8086,SM,LOCK
+SUB		mem,sbytedword32		[mi:	hle o32 83 /5 ib,s]			386,SM,LOCK,ND
+SUB		mem,imm32			[mi:	hle o32 81 /5 id]			386,SM,LOCK
+SUB		rm8,imm				[mi:	hle 82 /5 ib]				8086,SM,LOCK,ND,NOLONG
+SVDC		mem80,reg_sreg			[mr:	0f 78 /r]				486,CYRIX,SMM
+SVLDT		mem80				[m:	0f 7a /0]				486,CYRIX,SMM,ND
+SVTS		mem80				[m:	0f 7c /0]				486,CYRIX,SMM
+SWAPGS		void				[	0f 01 f8]				X86_64,LONG
+SYSCALL		void				[	0f 05]					P6,AMD
+SYSENTER	void				[	0f 34]					P6
+SYSEXIT		void				[	0f 35]					P6,PRIV
+SYSRET		void				[	0f 07]					P6,PRIV,AMD
+TEST		mem,reg8			[mr:	84 /r]					8086,SM
+TEST		reg8,reg8			[mr:	84 /r]					8086
+TEST		mem,reg16			[mr:	o16 85 /r]				8086,SM
+TEST		reg16,reg16			[mr:	o16 85 /r]				8086
+TEST		mem,reg32			[mr:	o32 85 /r]				386,SM
+TEST		reg32,reg32			[mr:	o32 85 /r]				386
+TEST		mem,reg64			[mr:	o64 85 /r]				X86_64,LONG,SM
+TEST		reg64,reg64			[mr:	o64 85 /r]				X86_64,LONG
+TEST		reg8,mem			[rm:	84 /r]					8086,SM
+TEST		reg16,mem			[rm:	o16 85 /r]				8086,SM
+TEST		reg32,mem			[rm:	o32 85 /r]				386,SM
+TEST		reg64,mem			[rm:	o64 85 /r]				X86_64,LONG,SM
+TEST		reg_al,imm			[-i:	a8 ib]					8086,SM
+TEST		reg_ax,imm			[-i:	o16 a9 iw]				8086,SM
+TEST		reg_eax,imm			[-i:	o32 a9 id]				386,SM
+TEST		reg_rax,imm			[-i:	o64 a9 id,s]				X86_64,LONG,SM
+TEST		rm8,imm				[mi:	f6 /0 ib]				8086,SM
+TEST		rm16,imm			[mi:	o16 f7 /0 iw]				8086,SM
+TEST		rm32,imm			[mi:	o32 f7 /0 id]				386,SM
+TEST		rm64,imm			[mi:	o64 f7 /0 id,s]				X86_64,LONG,SM
+TEST		mem,imm8			[mi:	f6 /0 ib]				8086,SM
+TEST		mem,imm16			[mi:	o16 f7 /0 iw]				8086,SM
+TEST		mem,imm32			[mi:	o32 f7 /0 id]				386,SM
+UD0		void				[	0f ff]					186,OBSOLETE
+UD0		reg16,rm16			[rm:	o16 0f ff /r]				186
+UD0		reg32,rm32			[rm:	o32 0f ff /r]				186
+UD0		reg64,rm64			[rm:	o64 0f ff /r]				186
+UD1		reg16,rm16			[rm:	o16 0f b9 /r]				186
+UD1		reg32,rm32			[rm:	o32 0f b9 /r]				186
+UD1		reg64,rm64			[rm:	o64 0f b9 /r]				186
+UD1		void				[	0f b9]					186,ND
+UD2B		void				[	0f b9]					186,ND
+UD2B		reg16,rm16			[rm:	o16 0f b9 /r]				186,ND
+UD2B		reg32,rm32			[rm:	o32 0f b9 /r]				186,ND
+UD2B		reg64,rm64			[rm:	o64 0f b9 /r]				186,ND
+UD2		void				[	0f 0b]					186
+UD2A		void				[	0f 0b]					186,ND
+UMOV		mem,reg8			[mr:	np 0f 10 /r]				386,UNDOC,SM,ND
+UMOV		reg8,reg8			[mr:	np 0f 10 /r]				386,UNDOC,ND
+UMOV		mem,reg16			[mr:	np o16 0f 11 /r]			386,UNDOC,SM,ND
+UMOV		reg16,reg16			[mr:	np o16 0f 11 /r]			386,UNDOC,ND
+UMOV		mem,reg32			[mr:	np o32 0f 11 /r]			386,UNDOC,SM,ND
+UMOV		reg32,reg32			[mr:	np o32 0f 11 /r]			386,UNDOC,ND
+UMOV		reg8,mem			[rm:	np 0f 12 /r]				386,UNDOC,SM,ND
+UMOV		reg8,reg8			[rm:	np 0f 12 /r]				386,UNDOC,ND
+UMOV		reg16,mem			[rm:	np o16 0f 13 /r]			386,UNDOC,SM,ND
+UMOV		reg16,reg16			[rm:	np o16 0f 13 /r]			386,UNDOC,ND
+UMOV		reg32,mem			[rm:	np o32 0f 13 /r]			386,UNDOC,SM,ND
+UMOV		reg32,reg32			[rm:	np o32 0f 13 /r]			386,UNDOC,ND
+VERR		mem				[m:	0f 00 /4]				286,PROT
+VERR		mem16				[m:	0f 00 /4]				286,PROT
+VERR		reg16				[m:	0f 00 /4]				286,PROT
+VERW		mem				[m:	0f 00 /5]				286,PROT
+VERW		mem16				[m:	0f 00 /5]				286,PROT
+VERW		reg16				[m:	0f 00 /5]				286,PROT
+FWAIT		void				[	wait]					8086
+WBINVD		void				[	0f 09]					486,PRIV
+WRSHR		rm32				[m:	o32 0f 37 /0]				P6,CYRIX,SMM
+WRMSR		void				[	0f 30]					PENT,PRIV
+XADD		mem,reg8			[mr:	hle 0f c0 /r]				486,SM,LOCK
+XADD		reg8,reg8			[mr:	0f c0 /r]				486
+XADD		mem,reg16			[mr:	hle o16 0f c1 /r]			486,SM,LOCK
+XADD		reg16,reg16			[mr:	o16 0f c1 /r]				486
+XADD		mem,reg32			[mr:	hle o32 0f c1 /r]			486,SM,LOCK
+XADD		reg32,reg32			[mr:	o32 0f c1 /r]				486
+XADD		mem,reg64			[mr:	hle o64 0f c1 /r]			X86_64,LONG,SM,LOCK
+XADD		reg64,reg64			[mr:	o64 0f c1 /r]				X86_64,LONG
+XBTS		reg16,mem			[rm:	o16 0f a6 /r]				386,SW,UNDOC,ND
+XBTS		reg16,reg16			[rm:	o16 0f a6 /r]				386,UNDOC,ND
+XBTS		reg32,mem			[rm:	o32 0f a6 /r]				386,SD,UNDOC,ND
+XBTS		reg32,reg32			[rm:	o32 0f a6 /r]				386,UNDOC,ND
+XCHG		reg_ax,reg16			[-r:	o16 90+r]				8086
+XCHG		reg_eax,reg32na			[-r:	o32 90+r]				386
+XCHG		reg_rax,reg64			[-r:	o64 90+r]				X86_64,LONG
+XCHG		reg16,reg_ax			[r-:	o16 90+r]				8086
+XCHG		reg32na,reg_eax			[r-:	o32 90+r]				386
+XCHG		reg64,reg_rax			[r-:	o64 90+r]				X86_64,LONG
+; This must be NOLONG since opcode 90 is NOP, and in 64-bit mode
+; "xchg eax,eax" is *not* a NOP.
+XCHG		reg_eax,reg_eax			[--:	o32 90]					386,NOLONG
+XCHG		reg8,mem			[rm:	hlenl 86 /r]				8086,SM,LOCK
+XCHG		reg8,reg8			[rm:	86 /r]					8086
+XCHG		reg16,mem			[rm:	hlenl o16 87 /r]			8086,SM,LOCK
+XCHG		reg16,reg16			[rm:	o16 87 /r]				8086
+XCHG		reg32,mem			[rm:	hlenl o32 87 /r]			386,SM,LOCK
+XCHG		reg32,reg32			[rm:	o32 87 /r]				386
+XCHG		reg64,mem			[rm:	hlenl o64 87 /r]			X86_64,LONG,SM,LOCK
+XCHG		reg64,reg64			[rm:	o64 87 /r]				X86_64,LONG
+XCHG		mem,reg8			[mr:	hlenl 86 /r]				8086,SM,LOCK
+XCHG		reg8,reg8			[mr:	86 /r]					8086
+XCHG		mem,reg16			[mr:	hlenl o16 87 /r]			8086,SM,LOCK
+XCHG		reg16,reg16			[mr:	o16 87 /r]				8086
+XCHG		mem,reg32			[mr:	hlenl o32 87 /r]			386,SM,LOCK
+XCHG		reg32,reg32			[mr:	o32 87 /r]				386
+XCHG		mem,reg64			[mr:	hlenl o64 87 /r]			X86_64,LONG,SM,LOCK
+XCHG		reg64,reg64			[mr:	o64 87 /r]				X86_64,LONG
+XLATB		void				[	d7]					8086
+XLAT		void				[	d7]					8086
+XOR		mem,reg8			[mr:	hle 30 /r]				8086,SM,LOCK
+XOR		reg8,reg8			[mr:	30 /r]					8086
+XOR		mem,reg16			[mr:	hle o16 31 /r]				8086,SM,LOCK
+XOR		reg16,reg16			[mr:	o16 31 /r]				8086
+XOR		mem,reg32			[mr:	hle o32 31 /r]				386,SM,LOCK
+XOR		reg32,reg32			[mr:	o32 31 /r]				386
+XOR		mem,reg64			[mr:	hle o64 31 /r]				X86_64,LONG,SM,LOCK
+XOR		reg64,reg64			[mr:	o64 31 /r]				X86_64,LONG
+XOR		reg8,mem			[rm:	32 /r]					8086,SM
+XOR		reg8,reg8			[rm:	32 /r]					8086
+XOR		reg16,mem			[rm:	o16 33 /r]				8086,SM
+XOR		reg16,reg16			[rm:	o16 33 /r]				8086
+XOR		reg32,mem			[rm:	o32 33 /r]				386,SM
+XOR		reg32,reg32			[rm:	o32 33 /r]				386
+XOR		reg64,mem			[rm:	o64 33 /r]				X86_64,LONG,SM
+XOR		reg64,reg64			[rm:	o64 33 /r]				X86_64,LONG
+XOR		rm16,imm8			[mi:	hle o16 83 /6 ib,s]			8086,LOCK
+XOR		rm32,imm8			[mi:	hle o32 83 /6 ib,s]			386,LOCK
+XOR		rm64,imm8			[mi:	hle o64 83 /6 ib,s]			X86_64,LONG,LOCK
+XOR		reg_al,imm			[-i:	34 ib]					8086,SM
+XOR		reg_ax,sbyteword		[mi:	o16 83 /6 ib,s]				8086,SM,ND
+XOR		reg_ax,imm			[-i:	o16 35 iw]				8086,SM
+XOR		reg_eax,sbytedword		[mi:	o32 83 /6 ib,s]				386,SM,ND
+XOR		reg_eax,imm			[-i:	o32 35 id]				386,SM
+XOR		reg_rax,sbytedword		[mi:	o64 83 /6 ib,s]				X86_64,LONG,SM,ND
+XOR		reg_rax,imm			[-i:	o64 35 id,s]				X86_64,LONG,SM
+XOR		rm8,imm				[mi:	hle 80 /6 ib]				8086,SM,LOCK
+XOR		rm16,sbyteword			[mi:	hle o16 83 /6 ib,s]			8086,SM,LOCK,ND
+XOR		rm16,imm			[mi:	hle o16 81 /6 iw]			8086,SM,LOCK
+XOR		rm32,sbytedword			[mi:	hle o32 83 /6 ib,s]			386,SM,LOCK,ND
+XOR		rm32,imm			[mi:	hle o32 81 /6 id]			386,SM,LOCK
+XOR		rm64,sbytedword			[mi:	hle o64 83 /6 ib,s]			X86_64,LONG,SM,LOCK,ND
+XOR		rm64,imm			[mi:	hle o64 81 /6 id,s]			X86_64,LONG,SM,LOCK
+XOR		mem,imm8			[mi:	hle 80 /6 ib]				8086,SM,LOCK
+XOR		mem,sbyteword16			[mi:	hle o16 83 /6 ib,s]			8086,SM,LOCK,ND
+XOR		mem,imm16			[mi:	hle o16 81 /6 iw]			8086,SM,LOCK
+XOR		mem,sbytedword32		[mi:	hle o32 83 /6 ib,s]			386,SM,LOCK,ND
+XOR		mem,imm32			[mi:	hle o32 81 /6 id]			386,SM,LOCK
+XOR		rm8,imm				[mi:	hle 82 /6 ib]				8086,SM,LOCK,ND,NOLONG
+CMOVcc		reg16,mem			[rm:	o16 0f 40+c /r]				P6,SM
+CMOVcc		reg16,reg16			[rm:	o16 0f 40+c /r]				P6
+CMOVcc		reg32,mem			[rm:	o32 0f 40+c /r]				P6,SM
+CMOVcc		reg32,reg32			[rm:	o32 0f 40+c /r]				P6
+CMOVcc		reg64,mem			[rm:	o64 0f 40+c /r]				X86_64,LONG,SM
+CMOVcc		reg64,reg64			[rm:	o64 0f 40+c /r]				X86_64,LONG
+Jcc		imm|near			[i:	odf 0f 80+c rel]			386,BND
+Jcc		imm16|near			[i:	o16 0f 80+c rel]			386,NOLONG,BND
+Jcc		imm32|near			[i:	o32 0f 80+c rel]			386,NOLONG,BND
+Jcc		imm64|near			[i:	o64nw 0f 80+c rel]			X86_64,LONG,BND
+Jcc		imm|short			[i:	70+c rel8]				8086,ND,BND
+Jcc		imm				[i:	jcc8 70+c rel8]				8086,ND,BND
+Jcc		imm				[i:	0f 80+c rel]				386,ND,BND
+Jcc		imm				[i:	71+c jlen e9 rel]			8086,ND,BND
+Jcc		imm				[i:	70+c rel8]				8086,BND
+
+SETcc		mem				[m:	0f 90+c /0]				386,SB
+SETcc		reg8				[m:	0f 90+c /0]				386
+
+;# Katmai Streaming SIMD instructions (SSE -- a.k.a. KNI, XMM, MMX2)
+ADDPS		xmmreg,xmmrm128			[rm:	np 0f 58 /r]				KATMAI,SSE
+ADDSS		xmmreg,xmmrm32			[rm:	f3 0f 58 /r]				KATMAI,SSE
+ANDNPS		xmmreg,xmmrm128			[rm:	np 0f 55 /r]				KATMAI,SSE
+ANDPS		xmmreg,xmmrm128			[rm:	np 0f 54 /r]				KATMAI,SSE
+CMPEQPS		xmmreg,xmmrm128			[rm:	np 0f c2 /r 00]				KATMAI,SSE
+CMPEQSS		xmmreg,xmmrm32			[rm:	f3 0f c2 /r 00]				KATMAI,SSE
+CMPLEPS		xmmreg,xmmrm128			[rm:	np 0f c2 /r 02]				KATMAI,SSE
+CMPLESS		xmmreg,xmmrm32			[rm:	f3 0f c2 /r 02]				KATMAI,SSE
+CMPLTPS		xmmreg,xmmrm128			[rm:	np 0f c2 /r 01]				KATMAI,SSE
+CMPLTSS		xmmreg,xmmrm32			[rm:	f3 0f c2 /r 01]				KATMAI,SSE
+CMPNEQPS	xmmreg,xmmrm128			[rm:	np 0f c2 /r 04]				KATMAI,SSE
+CMPNEQSS	xmmreg,xmmrm32			[rm:	f3 0f c2 /r 04]				KATMAI,SSE
+CMPNLEPS	xmmreg,xmmrm128			[rm:	np 0f c2 /r 06]				KATMAI,SSE
+CMPNLESS	xmmreg,xmmrm32			[rm:	f3 0f c2 /r 06]				KATMAI,SSE
+CMPNLTPS	xmmreg,xmmrm128			[rm:	np 0f c2 /r 05]				KATMAI,SSE
+CMPNLTSS	xmmreg,xmmrm32			[rm:	f3 0f c2 /r 05]				KATMAI,SSE
+CMPORDPS	xmmreg,xmmrm128			[rm:	np 0f c2 /r 07]				KATMAI,SSE
+CMPORDSS	xmmreg,xmmrm32			[rm:	f3 0f c2 /r 07]				KATMAI,SSE
+CMPUNORDPS	xmmreg,xmmrm128			[rm:	np 0f c2 /r 03]				KATMAI,SSE
+CMPUNORDSS	xmmreg,xmmrm32			[rm:	f3 0f c2 /r 03]				KATMAI,SSE
+; CMPPS/CMPSS must come after the specific ops; that way the disassembler will find the
+; specific ops first and only disassemble illegal ones as cmpps/cmpss.
+CMPPS		xmmreg,xmmrm128,imm8		[rmi:	np 0f c2 /r ib,u]			KATMAI,SSE
+CMPSS		xmmreg,xmmrm32,imm8		[rmi:	f3 0f c2 /r ib,u]			KATMAI,SSE
+COMISS		xmmreg,xmmrm32			[rm:	np 0f 2f /r]				KATMAI,SSE
+CVTPI2PS	xmmreg,mmxrm64			[rm:	np 0f 2a /r]				KATMAI,SSE,MMX
+CVTPS2PI	mmxreg,xmmrm64			[rm:	np 0f 2d /r]				KATMAI,SSE,MMX
+CVTSI2SS	xmmreg,mem			[rm:	f3 0f 2a /r]				KATMAI,SSE,SD,AR1,ND
+CVTSI2SS	xmmreg,rm32			[rm:	f3 0f 2a /r]				KATMAI,SSE,SD,AR1
+CVTSI2SS	xmmreg,rm64			[rm:	o64 f3 0f 2a /r]			X86_64,LONG,SSE,SQ,AR1
+CVTSS2SI	reg32,xmmreg			[rm:	f3 0f 2d /r]				KATMAI,SSE,SD,AR1
+CVTSS2SI	reg32,mem			[rm:	f3 0f 2d /r]				KATMAI,SSE,SD,AR1
+CVTSS2SI	reg64,xmmreg			[rm:	o64 f3 0f 2d /r]			X86_64,LONG,SSE,SD,AR1
+CVTSS2SI	reg64,mem			[rm:	o64 f3 0f 2d /r]			X86_64,LONG,SSE,SD,AR1
+CVTTPS2PI	mmxreg,xmmrm			[rm:	np 0f 2c /r]				KATMAI,SSE,MMX,SQ
+CVTTSS2SI	reg32,xmmrm			[rm:	f3 0f 2c /r]				KATMAI,SSE,SD,AR1
+CVTTSS2SI	reg64,xmmrm			[rm:	o64 f3 0f 2c /r]			X86_64,LONG,SSE,SD,AR1
+DIVPS		xmmreg,xmmrm128			[rm:	np 0f 5e /r]				KATMAI,SSE
+DIVSS		xmmreg,xmmrm32			[rm:	f3 0f 5e /r]				KATMAI,SSE
+LDMXCSR		mem32				[m:	np 0f ae /2]				KATMAI,SSE
+MAXPS		xmmreg,xmmrm128			[rm:	np 0f 5f /r]				KATMAI,SSE
+MAXSS		xmmreg,xmmrm32			[rm:	f3 0f 5f /r]				KATMAI,SSE
+MINPS		xmmreg,xmmrm128			[rm:	np 0f 5d /r]				KATMAI,SSE
+MINSS		xmmreg,xmmrm32			[rm:	f3 0f 5d /r]				KATMAI,SSE
+MOVAPS		xmmreg,xmmrm128			[rm:	np 0f 28 /r]				KATMAI,SSE
+MOVAPS		xmmrm128,xmmreg			[mr:	np 0f 29 /r]				KATMAI,SSE
+MOVHPS		xmmreg,mem64			[rm:	np 0f 16 /r]				KATMAI,SSE
+MOVHPS		mem64,xmmreg			[mr:	np 0f 17 /r]				KATMAI,SSE
+MOVLHPS		xmmreg,xmmreg			[rm:	np 0f 16 /r]				KATMAI,SSE
+MOVLPS		xmmreg,mem64			[rm:	np 0f 12 /r]				KATMAI,SSE
+MOVLPS		mem64,xmmreg			[mr:	np 0f 13 /r]				KATMAI,SSE
+MOVHLPS		xmmreg,xmmreg			[rm:	np 0f 12 /r]				KATMAI,SSE
+MOVMSKPS	reg32,xmmreg			[rm:	np 0f 50 /r]				KATMAI,SSE
+MOVMSKPS	reg64,xmmreg			[rm:	np o64 0f 50 /r]			X86_64,LONG,SSE
+MOVNTPS		mem128,xmmreg			[mr:	np 0f 2b /r]				KATMAI,SSE
+MOVSS		xmmreg,xmmrm32			[rm:	f3 0f 10 /r]				KATMAI,SSE
+MOVSS		xmmrm32,xmmreg			[mr:	f3 0f 11 /r]				KATMAI,SSE
+MOVUPS		xmmreg,xmmrm128			[rm:	np 0f 10 /r]				KATMAI,SSE
+MOVUPS		xmmrm128,xmmreg			[mr:	np 0f 11 /r]				KATMAI,SSE
+MULPS		xmmreg,xmmrm128			[rm:	np 0f 59 /r]				KATMAI,SSE
+MULSS		xmmreg,xmmrm32			[rm:	f3 0f 59 /r]				KATMAI,SSE
+ORPS		xmmreg,xmmrm128			[rm:	np 0f 56 /r]				KATMAI,SSE
+RCPPS		xmmreg,xmmrm128			[rm:	np 0f 53 /r]				KATMAI,SSE
+RCPSS		xmmreg,xmmrm32			[rm:	f3 0f 53 /r]				KATMAI,SSE
+RSQRTPS		xmmreg,xmmrm128			[rm:	np 0f 52 /r]				KATMAI,SSE
+RSQRTSS		xmmreg,xmmrm32			[rm:	f3 0f 52 /r]				KATMAI,SSE
+SHUFPS		xmmreg,xmmrm128,imm8		[rmi:	np 0f c6 /r ib,u]			KATMAI,SSE
+SQRTPS		xmmreg,xmmrm128			[rm:	np 0f 51 /r]				KATMAI,SSE
+SQRTSS		xmmreg,xmmrm32			[rm:	f3 0f 51 /r]				KATMAI,SSE
+STMXCSR		mem32				[m:	np 0f ae /3]				KATMAI,SSE
+SUBPS		xmmreg,xmmrm128			[rm:	np 0f 5c /r]				KATMAI,SSE
+SUBSS		xmmreg,xmmrm32			[rm:	f3 0f 5c /r]				KATMAI,SSE
+UCOMISS		xmmreg,xmmrm32			[rm:	np 0f 2e /r]				KATMAI,SSE
+UNPCKHPS	xmmreg,xmmrm128			[rm:	np 0f 15 /r]				KATMAI,SSE
+UNPCKLPS	xmmreg,xmmrm128			[rm:	np 0f 14 /r]				KATMAI,SSE
+XORPS		xmmreg,xmmrm128			[rm:	np 0f 57 /r]				KATMAI,SSE
+
+;# Introduced in Deschutes but necessary for SSE support
+FXRSTOR		mem				[m:	np 0f ae /1]				P6,SSE,FPU
+FXRSTOR64	mem				[m:	o64 np 0f ae /1]			X86_64,LONG,SSE,FPU
+FXSAVE		mem				[m:	np 0f ae /0]				P6,SSE,FPU
+FXSAVE64	mem				[m:	o64 np 0f ae /0]			X86_64,LONG,SSE,FPU
+
+;# XSAVE group (AVX and extended state)
+; Introduced in late Penryn ... we really need to clean up the handling
+; of CPU feature bits.
+XGETBV		void				[	0f 01 d0]				NEHALEM
+XSETBV		void				[	0f 01 d1]				NEHALEM,PRIV
+XSAVE		mem				[m:	np 0f ae /4]				NEHALEM
+XSAVE64		mem				[m:	o64 np 0f ae /4]			LONG,NEHALEM
+XSAVEC		mem				[m:	np 0f c7 /4]				FUTURE
+XSAVEC64	mem				[m:	o64 np 0f c7 /4]			LONG,FUTURE
+XSAVEOPT	mem				[m:	np 0f ae /6]				FUTURE
+XSAVEOPT64	mem				[m:	o64 np 0f ae /6]			LONG,FUTURE
+XSAVES		mem				[m:	np 0f c7 /5]				FUTURE
+XSAVES64	mem				[m:	o64 np 0f c7 /5]			LONG,FUTURE
+XRSTOR		mem				[m:	np 0f ae /5]				NEHALEM
+XRSTOR64	mem				[m:	o64 np 0f ae /5]			LONG,NEHALEM
+XRSTORS		mem				[m:	np 0f c7 /3]				FUTURE
+XRSTORS64	mem				[m:	o64 np 0f c7 /3]			LONG,FUTURE
+
+; These instructions are not SSE-specific; they are
+;# Generic memory operations
+; and work even if CR4.OSFXFR == 0
+PREFETCHNTA	mem8				[m:	0f 18 /0]				KATMAI,SB
+PREFETCHT0	mem8				[m:	0f 18 /1]				KATMAI,SB
+PREFETCHT1	mem8				[m:	0f 18 /2]				KATMAI,SB
+PREFETCHT2	mem8				[m:	0f 18 /3]				KATMAI,SB
+PREFETCHIT0	mem8				[m:	0f 18 /7]				FUTURE,PREFETCHI,SB
+PREFETCHIT1	mem8				[m:	0f 18 /6]				FUTURE,PREFETCHI,SB
+SFENCE		void				[	np 0f ae f8]				KATMAI
+
+;# New MMX instructions introduced in Katmai
+MASKMOVQ	mmxreg,mmxreg			[rm:	np 0f f7 /r]				KATMAI,MMX
+MOVNTQ		mem,mmxreg			[mr:	np 0f e7 /r]				KATMAI,MMX,SQ
+PAVGB		mmxreg,mmxrm			[rm:	np o64nw 0f e0 /r]			KATMAI,MMX,SQ
+PAVGW		mmxreg,mmxrm			[rm:	np o64nw 0f e3 /r]			KATMAI,MMX,SQ
+PEXTRW		reg32,mmxreg,imm		[rmi:	np 0f c5 /r ib,u]			KATMAI,MMX,SB,AR2
+; PINSRW is documented as using a reg32, but it's really using only 16 bit
+; -- accept either, but be truthful in disassembly
+PINSRW		mmxreg,mem,imm			[rmi:	np 0f c4 /r ib,u]			KATMAI,MMX,SB,AR2
+PINSRW		mmxreg,rm16,imm			[rmi:	np 0f c4 /r ib,u]			KATMAI,MMX,SB,AR2
+PINSRW		mmxreg,reg32,imm		[rmi:	np 0f c4 /r ib,u]			KATMAI,MMX,SB,AR2
+PMAXSW		mmxreg,mmxrm			[rm:	np o64nw 0f ee /r]			KATMAI,MMX,SQ
+PMAXUB		mmxreg,mmxrm			[rm:	np o64nw 0f de /r]			KATMAI,MMX,SQ
+PMINSW		mmxreg,mmxrm			[rm:	np o64nw 0f ea /r]			KATMAI,MMX,SQ
+PMINUB		mmxreg,mmxrm			[rm:	np o64nw 0f da /r]			KATMAI,MMX,SQ
+PMOVMSKB	reg32,mmxreg			[rm:	np 0f d7 /r]				KATMAI,MMX
+PMULHUW		mmxreg,mmxrm			[rm:	np o64nw 0f e4 /r]			KATMAI,MMX,SQ
+PSADBW		mmxreg,mmxrm			[rm:	np o64nw 0f f6 /r]			KATMAI,MMX,SQ
+PSHUFW		mmxreg,mmxrm,imm		[rmi:	np o64nw 0f 70 /r ib]			KATMAI,MMX,SM2,SB,AR2
+
+;# AMD Enhanced 3DNow! (Athlon) instructions
+PF2IW		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 1c]			PENT,3DNOW,SQ
+PFNACC		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 8a]			PENT,3DNOW,SQ
+PFPNACC		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 8e]			PENT,3DNOW,SQ
+PI2FW		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 0c]			PENT,3DNOW,SQ
+PSWAPD		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r bb]			PENT,3DNOW,SQ
+
+;# Willamette SSE2 Cacheability Instructions
+MASKMOVDQU	xmmreg,xmmreg			[rm:	66 0f f7 /r]				WILLAMETTE,SSE2
+; CLFLUSH needs its own feature flag implemented one day
+CLFLUSH		mem				[m:	np 0f ae /7]				WILLAMETTE,SSE2
+MOVNTDQ		mem,xmmreg			[mr:	66 0f e7 /r]				WILLAMETTE,SSE2,SO
+MOVNTI		mem,reg32			[mr:	np 0f c3 /r]				WILLAMETTE,SD
+MOVNTI		mem,reg64			[mr:	o64 np 0f c3 /r]			X86_64,LONG,SQ
+MOVNTPD		mem,xmmreg			[mr:	66 0f 2b /r]				WILLAMETTE,SSE2,SO
+LFENCE		void				[	np 0f ae e8]				WILLAMETTE,SSE2
+MFENCE		void				[	np 0f ae f0]				WILLAMETTE,SSE2
+
+;# Willamette MMX instructions (SSE2 SIMD Integer Instructions)
+MOVD		mem,xmmreg			[mr:	66 norexw 0f 7e /r]			WILLAMETTE,SSE2,SD
+MOVD		xmmreg,mem			[rm:	66 norexw 0f 6e /r]			WILLAMETTE,SSE2,SD
+MOVD		xmmreg,rm32			[rm:	66 norexw 0f 6e /r]			WILLAMETTE,SSE2
+MOVD		rm32,xmmreg			[mr:	66 norexw 0f 7e /r]			WILLAMETTE,SSE2
+MOVDQA		xmmreg,xmmrm128			[rm:	66 0f 6f /r]				WILLAMETTE,SSE2,SO
+MOVDQA		xmmrm128,xmmreg			[mr:	66 0f 7f /r]				WILLAMETTE,SSE2,SO
+MOVDQU		xmmreg,xmmrm128			[rm:	f3 0f 6f /r]				WILLAMETTE,SSE2,SO
+MOVDQU		xmmrm128,xmmreg			[mr:	f3 0f 7f /r]				WILLAMETTE,SSE2,SO
+MOVDQ2Q		mmxreg,xmmreg			[rm:	f2 0f d6 /r]				WILLAMETTE,SSE2
+MOVQ		xmmreg,xmmreg			[rm:	f3 0f 7e /r]				WILLAMETTE,SSE2
+MOVQ		xmmreg,xmmreg			[mr:	66 0f d6 /r]				WILLAMETTE,SSE2
+MOVQ		mem,xmmreg			[mr:	66 0f d6 /r]				WILLAMETTE,SSE2,SQ
+MOVQ		xmmreg,mem			[rm:	f3 0f 7e /r]				WILLAMETTE,SSE2,SQ
+MOVQ		xmmreg,rm64			[rm:	66 o64 0f 6e /r]			X86_64,LONG,SSE2
+MOVQ		rm64,xmmreg			[mr:	66 o64 0f 7e /r]			X86_64,LONG,SSE2
+MOVQ2DQ		xmmreg,mmxreg			[rm:	f3 0f d6 /r]				WILLAMETTE,SSE2
+PACKSSWB	xmmreg,xmmrm			[rm:	66 0f 63 /r]				WILLAMETTE,SSE2,SO
+PACKSSDW	xmmreg,xmmrm			[rm:	66 0f 6b /r]				WILLAMETTE,SSE2,SO
+PACKUSWB	xmmreg,xmmrm			[rm:	66 0f 67 /r]				WILLAMETTE,SSE2,SO
+PADDB		xmmreg,xmmrm			[rm:	66 0f fc /r]				WILLAMETTE,SSE2,SO
+PADDW		xmmreg,xmmrm			[rm:	66 0f fd /r]				WILLAMETTE,SSE2,SO
+PADDD		xmmreg,xmmrm			[rm:	66 0f fe /r]				WILLAMETTE,SSE2,SO
+PADDQ		mmxreg,mmxrm			[rm:	np 0f d4 /r]				WILLAMETTE,MMX,SQ
+PADDQ		xmmreg,xmmrm			[rm:	66 0f d4 /r]				WILLAMETTE,SSE2,SO
+PADDSB		xmmreg,xmmrm			[rm:	66 0f ec /r]				WILLAMETTE,SSE2,SO
+PADDSW		xmmreg,xmmrm			[rm:	66 0f ed /r]				WILLAMETTE,SSE2,SO
+PADDUSB		xmmreg,xmmrm			[rm:	66 0f dc /r]				WILLAMETTE,SSE2,SO
+PADDUSW		xmmreg,xmmrm			[rm:	66 0f dd /r]				WILLAMETTE,SSE2,SO
+PAND		xmmreg,xmmrm			[rm:	66 0f db /r]				WILLAMETTE,SSE2,SO
+PANDN		xmmreg,xmmrm			[rm:	66 0f df /r]				WILLAMETTE,SSE2,SO
+PAVGB		xmmreg,xmmrm			[rm:	66 0f e0 /r]				WILLAMETTE,SSE2,SO
+PAVGW		xmmreg,xmmrm			[rm:	66 0f e3 /r]				WILLAMETTE,SSE2,SO
+PCMPEQB		xmmreg,xmmrm			[rm:	66 0f 74 /r]				WILLAMETTE,SSE2,SO
+PCMPEQW		xmmreg,xmmrm			[rm:	66 0f 75 /r]				WILLAMETTE,SSE2,SO
+PCMPEQD		xmmreg,xmmrm			[rm:	66 0f 76 /r]				WILLAMETTE,SSE2,SO
+PCMPGTB		xmmreg,xmmrm			[rm:	66 0f 64 /r]				WILLAMETTE,SSE2,SO
+PCMPGTW		xmmreg,xmmrm			[rm:	66 0f 65 /r]				WILLAMETTE,SSE2,SO
+PCMPGTD		xmmreg,xmmrm			[rm:	66 0f 66 /r]				WILLAMETTE,SSE2,SO
+PEXTRW		reg32,xmmreg,imm		[rmi:	66 0f c5 /r ib,u]			WILLAMETTE,SSE2,SB,AR2
+PEXTRW		reg64,xmmreg,imm		[rmi:	66 0f c5 /r ib,u]			X86_64,LONG,SSE2,SB,AR2,ND
+PINSRW		xmmreg,reg16,imm		[rmi:	66 0f c4 /r ib,u]			WILLAMETTE,SSE2,SB,AR2
+PINSRW		xmmreg,reg32,imm		[rmi:	66 0f c4 /r ib,u]			WILLAMETTE,SSE2,SB,AR2,ND
+PINSRW		xmmreg,reg64,imm		[rmi:	66 0f c4 /r ib,u]			X86_64,LONG,SSE2,SB,AR2,ND
+PINSRW		xmmreg,mem,imm			[rmi:	66 0f c4 /r ib,u]			WILLAMETTE,SSE2,SB,AR2
+PINSRW		xmmreg,mem16,imm		[rmi:	66 0f c4 /r ib,u]			WILLAMETTE,SSE2,SB,AR2
+PMADDWD		xmmreg,xmmrm			[rm:	66 0f f5 /r]				WILLAMETTE,SSE2,SO
+PMAXSW		xmmreg,xmmrm			[rm:	66 0f ee /r]				WILLAMETTE,SSE2,SO
+PMAXUB		xmmreg,xmmrm			[rm:	66 0f de /r]				WILLAMETTE,SSE2,SO
+PMINSW		xmmreg,xmmrm			[rm:	66 0f ea /r]				WILLAMETTE,SSE2,SO
+PMINUB		xmmreg,xmmrm			[rm:	66 0f da /r]				WILLAMETTE,SSE2,SO
+PMOVMSKB	reg32,xmmreg			[rm:	66 0f d7 /r]				WILLAMETTE,SSE2
+PMULHUW		xmmreg,xmmrm			[rm:	66 0f e4 /r]				WILLAMETTE,SSE2,SO
+PMULHW		xmmreg,xmmrm			[rm:	66 0f e5 /r]				WILLAMETTE,SSE2,SO
+PMULLW		xmmreg,xmmrm			[rm:	66 0f d5 /r]				WILLAMETTE,SSE2,SO
+PMULUDQ		mmxreg,mmxrm			[rm:	np o64nw 0f f4 /r]			WILLAMETTE,SSE2,SO
+PMULUDQ		xmmreg,xmmrm			[rm:	66 0f f4 /r]				WILLAMETTE,SSE2,SO
+POR		xmmreg,xmmrm			[rm:	66 0f eb /r]				WILLAMETTE,SSE2,SO
+PSADBW		xmmreg,xmmrm			[rm:	66 0f f6 /r]				WILLAMETTE,SSE2,SO
+PSHUFD		xmmreg,xmmreg,imm		[rmi:	66 0f 70 /r ib]				WILLAMETTE,SSE2,SB,AR2
+PSHUFD		xmmreg,mem,imm			[rmi:	66 0f 70 /r ib]				WILLAMETTE,SSE2,SM2,SB,AR2
+PSHUFHW		xmmreg,xmmreg,imm		[rmi:	f3 0f 70 /r ib]				WILLAMETTE,SSE2,SB,AR2
+PSHUFHW		xmmreg,mem,imm			[rmi:	f3 0f 70 /r ib]				WILLAMETTE,SSE2,SM2,SB,AR2
+PSHUFLW		xmmreg,xmmreg,imm		[rmi:	f2 0f 70 /r ib]				WILLAMETTE,SSE2,SB,AR2
+PSHUFLW		xmmreg,mem,imm			[rmi:	f2 0f 70 /r ib]				WILLAMETTE,SSE2,SM2,SB,AR2
+PSLLDQ		xmmreg,imm			[mi:	66 0f 73 /7 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSLLW		xmmreg,xmmrm			[rm:	66 0f f1 /r]				WILLAMETTE,SSE2,SO
+PSLLW		xmmreg,imm			[mi:	66 0f 71 /6 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSLLD		xmmreg,xmmrm			[rm:	66 0f f2 /r]				WILLAMETTE,SSE2,SO
+PSLLD		xmmreg,imm			[mi:	66 0f 72 /6 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSLLQ		xmmreg,xmmrm			[rm:	66 0f f3 /r]				WILLAMETTE,SSE2,SO
+PSLLQ		xmmreg,imm			[mi:	66 0f 73 /6 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSRAW		xmmreg,xmmrm			[rm:	66 0f e1 /r]				WILLAMETTE,SSE2,SO
+PSRAW		xmmreg,imm			[mi:	66 0f 71 /4 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSRAD		xmmreg,xmmrm			[rm:	66 0f e2 /r]				WILLAMETTE,SSE2,SO
+PSRAD		xmmreg,imm			[mi:	66 0f 72 /4 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSRLDQ		xmmreg,imm			[mi:	66 0f 73 /3 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSRLW		xmmreg,xmmrm			[rm:	66 0f d1 /r]				WILLAMETTE,SSE2,SO
+PSRLW		xmmreg,imm			[mi:	66 0f 71 /2 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSRLD		xmmreg,xmmrm			[rm:	66 0f d2 /r]				WILLAMETTE,SSE2,SO
+PSRLD		xmmreg,imm			[mi:	66 0f 72 /2 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSRLQ		xmmreg,xmmrm			[rm:	66 0f d3 /r]				WILLAMETTE,SSE2,SO
+PSRLQ		xmmreg,imm			[mi:	66 0f 73 /2 ib,u]			WILLAMETTE,SSE2,SB,AR1
+PSUBB		xmmreg,xmmrm			[rm:	66 0f f8 /r]				WILLAMETTE,SSE2,SO
+PSUBW		xmmreg,xmmrm			[rm:	66 0f f9 /r]				WILLAMETTE,SSE2,SO
+PSUBD		xmmreg,xmmrm			[rm:	66 0f fa /r]				WILLAMETTE,SSE2,SO
+PSUBQ		mmxreg,mmxrm			[rm:	np o64nw 0f fb /r]			WILLAMETTE,SSE2,SO
+PSUBQ		xmmreg,xmmrm			[rm:	66 0f fb /r]				WILLAMETTE,SSE2,SO
+PSUBSB		xmmreg,xmmrm			[rm:	66 0f e8 /r]				WILLAMETTE,SSE2,SO
+PSUBSW		xmmreg,xmmrm			[rm:	66 0f e9 /r]				WILLAMETTE,SSE2,SO
+PSUBUSB		xmmreg,xmmrm			[rm:	66 0f d8 /r]				WILLAMETTE,SSE2,SO
+PSUBUSW		xmmreg,xmmrm			[rm:	66 0f d9 /r]				WILLAMETTE,SSE2,SO
+PUNPCKHBW	xmmreg,xmmrm			[rm:	66 0f 68 /r]				WILLAMETTE,SSE2,SO
+PUNPCKHWD	xmmreg,xmmrm			[rm:	66 0f 69 /r]				WILLAMETTE,SSE2,SO
+PUNPCKHDQ	xmmreg,xmmrm			[rm:	66 0f 6a /r]				WILLAMETTE,SSE2,SO
+PUNPCKHQDQ	xmmreg,xmmrm			[rm:	66 0f 6d /r]				WILLAMETTE,SSE2,SO
+PUNPCKLBW	xmmreg,xmmrm			[rm:	66 0f 60 /r]				WILLAMETTE,SSE2,SO
+PUNPCKLWD	xmmreg,xmmrm			[rm:	66 0f 61 /r]				WILLAMETTE,SSE2,SO
+PUNPCKLDQ	xmmreg,xmmrm			[rm:	66 0f 62 /r]				WILLAMETTE,SSE2,SO
+PUNPCKLQDQ	xmmreg,xmmrm			[rm:	66 0f 6c /r]				WILLAMETTE,SSE2,SO
+PXOR		xmmreg,xmmrm			[rm:	66 0f ef /r]				WILLAMETTE,SSE2,SO
+
+;# Willamette Streaming SIMD instructions (SSE2)
+ADDPD		xmmreg,xmmrm			[rm:	66 0f 58 /r]				WILLAMETTE,SSE2,SO
+ADDSD		xmmreg,xmmrm			[rm:	f2 0f 58 /r]				WILLAMETTE,SSE2,SQ
+ANDNPD		xmmreg,xmmrm			[rm:	66 0f 55 /r]				WILLAMETTE,SSE2,SO
+ANDPD		xmmreg,xmmrm			[rm:	66 0f 54 /r]				WILLAMETTE,SSE2,SO
+CMPEQPD		xmmreg,xmmrm			[rm:	66 0f c2 /r 00]				WILLAMETTE,SSE2,SO
+CMPEQSD		xmmreg,xmmrm			[rm:	f2 0f c2 /r 00]				WILLAMETTE,SSE2,SQ
+CMPLEPD		xmmreg,xmmrm			[rm:	66 0f c2 /r 02]				WILLAMETTE,SSE2,SO
+CMPLESD		xmmreg,xmmrm			[rm:	f2 0f c2 /r 02]				WILLAMETTE,SSE2,SQ
+CMPLTPD		xmmreg,xmmrm			[rm:	66 0f c2 /r 01]				WILLAMETTE,SSE2,SO
+CMPLTSD		xmmreg,xmmrm			[rm:	f2 0f c2 /r 01]				WILLAMETTE,SSE2,SQ
+CMPNEQPD	xmmreg,xmmrm			[rm:	66 0f c2 /r 04]				WILLAMETTE,SSE2,SO
+CMPNEQSD	xmmreg,xmmrm			[rm:	f2 0f c2 /r 04]				WILLAMETTE,SSE2,SQ
+CMPNLEPD	xmmreg,xmmrm			[rm:	66 0f c2 /r 06]				WILLAMETTE,SSE2,SO
+CMPNLESD	xmmreg,xmmrm			[rm:	f2 0f c2 /r 06]				WILLAMETTE,SSE2,SQ
+CMPNLTPD	xmmreg,xmmrm			[rm:	66 0f c2 /r 05]				WILLAMETTE,SSE2,SO
+CMPNLTSD	xmmreg,xmmrm			[rm:	f2 0f c2 /r 05]				WILLAMETTE,SSE2,SQ
+CMPORDPD	xmmreg,xmmrm			[rm:	66 0f c2 /r 07]				WILLAMETTE,SSE2,SO
+CMPORDSD	xmmreg,xmmrm			[rm:	f2 0f c2 /r 07]				WILLAMETTE,SSE2,SQ
+CMPUNORDPD	xmmreg,xmmrm			[rm:	66 0f c2 /r 03]				WILLAMETTE,SSE2,SO
+CMPUNORDSD	xmmreg,xmmrm			[rm:	f2 0f c2 /r 03]				WILLAMETTE,SSE2,SQ
+; CMPPD/CMPSD must come after the specific ops; that way the disassembler will find the
+; specific ops first and only disassemble illegal ones as cmppd/cmpsd.
+CMPPD		xmmreg,xmmrm128,imm8		[rmi:	66 0f c2 /r ib,u]			WILLAMETTE,SSE2
+CMPSD		xmmreg,xmmrm128,imm8		[rmi:	f2 0f c2 /r ib,u]			WILLAMETTE,SSE2
+COMISD		xmmreg,xmmrm64			[rm:	66 0f 2f /r]				WILLAMETTE,SSE2
+CVTDQ2PD	xmmreg,xmmrm			[rm:	f3 0f e6 /r]				WILLAMETTE,SSE2,SQ
+CVTDQ2PS	xmmreg,xmmrm			[rm:	np 0f 5b /r]				WILLAMETTE,SSE2,SO
+CVTPD2DQ	xmmreg,xmmrm			[rm:	f2 0f e6 /r]				WILLAMETTE,SSE2,SO
+CVTPD2PI	mmxreg,xmmrm			[rm:	66 0f 2d /r]				WILLAMETTE,SSE2,SO
+CVTPD2PS	xmmreg,xmmrm			[rm:	66 0f 5a /r]				WILLAMETTE,SSE2,SO
+CVTPI2PD	xmmreg,mmxrm			[rm:	66 0f 2a /r]				WILLAMETTE,SSE2,SQ
+CVTPS2DQ	xmmreg,xmmrm			[rm:	66 0f 5b /r]				WILLAMETTE,SSE2,SO
+CVTPS2PD	xmmreg,xmmrm			[rm:	np 0f 5a /r]				WILLAMETTE,SSE2,SQ
+CVTSD2SI	reg32,xmmreg			[rm:	norexw f2 0f 2d /r]			WILLAMETTE,SSE2,SQ,AR1
+CVTSD2SI	reg32,mem			[rm:	norexw f2 0f 2d /r]			WILLAMETTE,SSE2,SQ,AR1
+CVTSD2SI	reg64,xmmreg			[rm:	o64 f2 0f 2d /r]			X86_64,LONG,SSE2,SQ,AR1
+CVTSD2SI	reg64,mem			[rm:	o64 f2 0f 2d /r]			X86_64,LONG,SSE2,SQ,AR1
+CVTSD2SS	xmmreg,xmmrm			[rm:	f2 0f 5a /r]				WILLAMETTE,SSE2,SQ
+CVTSI2SD	xmmreg,mem			[rm:	f2 0f 2a /r]				WILLAMETTE,SSE2,SD,AR1,ND
+CVTSI2SD	xmmreg,rm32			[rm:	norexw f2 0f 2a /r]			WILLAMETTE,SSE2,SD,AR1
+CVTSI2SD	xmmreg,rm64			[rm:	o64 f2 0f 2a /r]			X86_64,LONG,SSE2,SQ,AR1
+CVTSS2SD	xmmreg,xmmrm			[rm:	f3 0f 5a /r]				WILLAMETTE,SSE2,SD
+CVTTPD2PI	mmxreg,xmmrm			[rm:	66 0f 2c /r]				WILLAMETTE,SSE2,SO
+CVTTPD2DQ	xmmreg,xmmrm			[rm:	66 0f e6 /r]				WILLAMETTE,SSE2,SO
+CVTTPS2DQ	xmmreg,xmmrm			[rm:	f3 0f 5b /r]				WILLAMETTE,SSE2,SO
+CVTTSD2SI	reg32,xmmreg			[rm:	norexw f2 0f 2c /r]			WILLAMETTE,SSE2,SQ,AR1
+CVTTSD2SI	reg32,mem			[rm:	norexw f2 0f 2c /r]			WILLAMETTE,SSE2,SQ,AR1
+CVTTSD2SI	reg64,xmmreg			[rm:	o64 f2 0f 2c /r]			X86_64,LONG,SSE2,SQ,AR1
+CVTTSD2SI	reg64,mem			[rm:	o64 f2 0f 2c /r]			X86_64,LONG,SSE2,SQ,AR1
+DIVPD		xmmreg,xmmrm			[rm:	66 0f 5e /r]				WILLAMETTE,SSE2,SO
+DIVSD		xmmreg,xmmrm			[rm:	f2 0f 5e /r]				WILLAMETTE,SSE2,SQ
+MAXPD		xmmreg,xmmrm			[rm:	66 0f 5f /r]				WILLAMETTE,SSE2,SO
+MAXSD		xmmreg,xmmrm			[rm:	f2 0f 5f /r]				WILLAMETTE,SSE2,SQ
+MINPD		xmmreg,xmmrm			[rm:	66 0f 5d /r]				WILLAMETTE,SSE2,SO
+MINSD		xmmreg,xmmrm			[rm:	f2 0f 5d /r]				WILLAMETTE,SSE2,SQ
+MOVAPD		xmmreg,xmmrm128			[rm:	66 0f 28 /r]				WILLAMETTE,SSE2
+MOVAPD		xmmrm128,xmmreg			[mr:	66 0f 29 /r]				WILLAMETTE,SSE2
+MOVHPD		mem64,xmmreg			[mr:	66 0f 17 /r]				WILLAMETTE,SSE2
+MOVHPD		xmmreg,mem64			[rm:	66 0f 16 /r]				WILLAMETTE,SSE2
+MOVLPD		mem64,xmmreg			[mr:	66 0f 13 /r]				WILLAMETTE,SSE2
+MOVLPD		xmmreg,mem64			[rm:	66 0f 12 /r]				WILLAMETTE,SSE2
+MOVMSKPD	reg32,xmmreg			[rm:	66 0f 50 /r]				WILLAMETTE,SSE2
+MOVMSKPD	reg64,xmmreg			[rm:	66 o64 0f 50 /r]			X86_64,LONG,SSE2
+MOVSD		xmmreg,xmmrm64			[rm:	f2 0f 10 /r]				WILLAMETTE,SSE2
+MOVSD		xmmrm64,xmmreg			[mr:	f2 0f 11 /r]				WILLAMETTE,SSE2
+MOVUPD		xmmreg,xmmrm128			[rm:	66 0f 10 /r]				WILLAMETTE,SSE2
+MOVUPD		xmmrm128,xmmreg			[mr:	66 0f 11 /r]				WILLAMETTE,SSE2
+MULPD		xmmreg,xmmrm128			[rm:	66 0f 59 /r]				WILLAMETTE,SSE2,SO
+MULSD		xmmreg,xmmrm64			[rm:	f2 0f 59 /r]				WILLAMETTE,SSE2,SQ
+ORPD		xmmreg,xmmrm128			[rm:	66 0f 56 /r]				WILLAMETTE,SSE2,SO
+SHUFPD		xmmreg,xmmrm128,imm8		[rmi:	66 0f c6 /r ib,u]			WILLAMETTE,SSE2
+SQRTPD		xmmreg,xmmrm128			[rm:	66 0f 51 /r]				WILLAMETTE,SSE2,SO
+SQRTSD		xmmreg,xmmrm64			[rm:	f2 0f 51 /r]				WILLAMETTE,SSE2
+SUBPD		xmmreg,xmmrm128			[rm:	66 0f 5c /r]				WILLAMETTE,SSE2,SO
+SUBSD		xmmreg,xmmrm64			[rm:	f2 0f 5c /r]				WILLAMETTE,SSE2
+UCOMISD		xmmreg,xmmrm64			[rm:	66 0f 2e /r]				WILLAMETTE,SSE2
+UNPCKHPD	xmmreg,xmmrm128			[rm:	66 0f 15 /r]				WILLAMETTE,SSE2
+UNPCKLPD	xmmreg,xmmrm128			[rm:	66 0f 14 /r]				WILLAMETTE,SSE2
+XORPD		xmmreg,xmmrm128			[rm:	66 0f 57 /r]				WILLAMETTE,SSE2
+
+;# Prescott New Instructions (SSE3)
+ADDSUBPD	xmmreg,xmmrm128			[rm:	66 0f d0 /r]				PRESCOTT,SSE3,SO
+ADDSUBPS	xmmreg,xmmrm128			[rm:	f2 0f d0 /r]				PRESCOTT,SSE3,SO
+HADDPD		xmmreg,xmmrm128			[rm:	66 0f 7c /r]				PRESCOTT,SSE3,SO
+HADDPS		xmmreg,xmmrm128			[rm:	f2 0f 7c /r]				PRESCOTT,SSE3,SO
+HSUBPD		xmmreg,xmmrm128			[rm:	66 0f 7d /r]				PRESCOTT,SSE3,SO
+HSUBPS		xmmreg,xmmrm128			[rm:	f2 0f 7d /r]				PRESCOTT,SSE3,SO
+LDDQU		xmmreg,mem128			[rm:	f2 0f f0 /r]				PRESCOTT,SSE3,SO
+MOVDDUP		xmmreg,xmmrm64			[rm:	f2 0f 12 /r]				PRESCOTT,SSE3,SQ
+MOVSHDUP	xmmreg,xmmrm128			[rm:	f3 0f 16 /r]				PRESCOTT,SSE3
+MOVSLDUP	xmmreg,xmmrm128			[rm:	f3 0f 12 /r]				PRESCOTT,SSE3
+
+;# VMX/SVM Instructions
+CLGI		void				[	0f 01 dd]				VMX,AMD
+STGI		void				[	0f 01 dc]				VMX,AMD
+VMCALL		void				[	0f 01 c1]				VMX
+VMCLEAR		mem				[m:	66 0f c7 /6]				VMX
+VMFUNC		void				[	0f 01 d4]				VMX
+VMLAUNCH	void				[	0f 01 c2]				VMX
+VMLOAD		void				[	0f 01 da]				VMX,AMD
+VMMCALL		void				[	0f 01 d9]				VMX,AMD
+VMPTRLD		mem				[m:	np 0f c7 /6]				VMX
+VMPTRST		mem				[m:	np 0f c7 /7]				VMX
+VMREAD		rm32,reg32			[mr:	np 0f 78 /r]				VMX,NOLONG,SD
+VMREAD		rm64,reg64			[mr:	o64nw np 0f 78 /r]			X86_64,LONG,VMX,SQ
+VMRESUME	void				[	0f 01 c3]				VMX
+VMRUN		void				[	0f 01 d8]				VMX,AMD
+VMSAVE		void				[	0f 01 db]				VMX,AMD
+VMWRITE		reg32,rm32			[rm:	np 0f 79 /r]				VMX,NOLONG,SD
+VMWRITE		reg64,rm64			[rm:	o64nw np 0f 79 /r]			X86_64,LONG,VMX,SQ
+VMXOFF		void				[	0f 01 c4]				VMX
+VMXON		mem				[m:	f3 0f c7 /6]				VMX
+;# Extended Page Tables VMX instructions
+INVEPT		reg32,mem			[rm: 66 0f 38 80 /r]				VMX,SO,NOLONG
+INVEPT		reg64,mem			[rm: o64nw 66 0f 38 80 /r]			VMX,SO,LONG
+INVVPID		reg32,mem			[rm: 66 0f 38 81 /r]				VMX,SO,NOLONG
+INVVPID		reg64,mem			[rm: o64nw 66 0f 38 81 /r]			VMX,SO,LONG
+;# SEV-SNP AMD instructions
+PVALIDATE	void				[       f2 0f 01 ff]				VMX,AMD
+RMPADJUST	void				[       f3 0f 01 fe]				VMX,AMD
+VMGEXIT		void				[       f2 0f 01 c1]				VMX,AMD
+VMGEXIT		void				[       f3 0f 01 c1]				VMX,AMD
+
+;# Tejas New Instructions (SSSE3)
+PABSB		mmxreg,mmxrm			[rm:	np 0f 38 1c /r]				SSSE3,MMX,SQ
+PABSB		xmmreg,xmmrm128			[rm:	66 0f 38 1c /r]				SSSE3
+PABSW		mmxreg,mmxrm			[rm:	np 0f 38 1d /r]				SSSE3,MMX,SQ
+PABSW		xmmreg,xmmrm128			[rm:	66 0f 38 1d /r]				SSSE3
+PABSD		mmxreg,mmxrm			[rm:	np 0f 38 1e /r]				SSSE3,MMX,SQ
+PABSD		xmmreg,xmmrm128			[rm:	66 0f 38 1e /r]				SSSE3
+PALIGNR		mmxreg,mmxrm,imm		[rmi:	np 0f 3a 0f /r ib,u]			SSSE3,MMX,SQ
+PALIGNR		xmmreg,xmmrm,imm		[rmi:	66 0f 3a 0f /r ib,u]			SSSE3
+PHADDW		mmxreg,mmxrm			[rm:	np 0f 38 01 /r]				SSSE3,MMX,SQ
+PHADDW		xmmreg,xmmrm128			[rm:	66 0f 38 01 /r]				SSSE3
+PHADDD		mmxreg,mmxrm			[rm:	np 0f 38 02 /r]				SSSE3,MMX,SQ
+PHADDD		xmmreg,xmmrm128			[rm:	66 0f 38 02 /r]				SSSE3
+PHADDSW		mmxreg,mmxrm			[rm:	np 0f 38 03 /r]				SSSE3,MMX,SQ
+PHADDSW		xmmreg,xmmrm128			[rm:	66 0f 38 03 /r]				SSSE3
+PHSUBW		mmxreg,mmxrm			[rm:	np 0f 38 05 /r]				SSSE3,MMX,SQ
+PHSUBW		xmmreg,xmmrm128			[rm:	66 0f 38 05 /r]				SSSE3
+PHSUBD		mmxreg,mmxrm			[rm:	np 0f 38 06 /r]				SSSE3,MMX,SQ
+PHSUBD		xmmreg,xmmrm128			[rm:	66 0f 38 06 /r]				SSSE3
+PHSUBSW		mmxreg,mmxrm			[rm:	np 0f 38 07 /r]				SSSE3,MMX,SQ
+PHSUBSW		xmmreg,xmmrm128			[rm:	66 0f 38 07 /r]				SSSE3
+PMADDUBSW	mmxreg,mmxrm			[rm:	np 0f 38 04 /r]				SSSE3,MMX,SQ
+PMADDUBSW	xmmreg,xmmrm128			[rm:	66 0f 38 04 /r]				SSSE3
+PMULHRSW	mmxreg,mmxrm			[rm:	np 0f 38 0b /r]				SSSE3,MMX,SQ
+PMULHRSW	xmmreg,xmmrm128			[rm:	66 0f 38 0b /r]				SSSE3
+PSHUFB		mmxreg,mmxrm			[rm:	np 0f 38 00 /r]				SSSE3,MMX,SQ
+PSHUFB		xmmreg,xmmrm128			[rm:	66 0f 38 00 /r]				SSSE3
+PSIGNB		mmxreg,mmxrm			[rm:	np 0f 38 08 /r]				SSSE3,MMX,SQ
+PSIGNB		xmmreg,xmmrm128			[rm:	66 0f 38 08 /r]				SSSE3
+PSIGNW		mmxreg,mmxrm			[rm:	np 0f 38 09 /r]				SSSE3,MMX,SQ
+PSIGNW		xmmreg,xmmrm128			[rm:	66 0f 38 09 /r]				SSSE3
+PSIGND		mmxreg,mmxrm			[rm:	np 0f 38 0a /r]				SSSE3,MMX,SQ
+PSIGND		xmmreg,xmmrm128			[rm:	66 0f 38 0a /r]				SSSE3
+
+;# AMD SSE4A
+EXTRQ		xmmreg,imm,imm			[mij:	66 0f 78 /0 ib,u ib,u]			SSE4A,AMD
+EXTRQ		xmmreg,xmmreg			[rm:	66 0f 79 /r]				SSE4A,AMD
+INSERTQ		xmmreg,xmmreg,imm,imm		[rmij:	f2 0f 78 /r ib,u ib,u]			SSE4A,AMD
+INSERTQ		xmmreg,xmmreg			[rm:	f2 0f 79 /r]				SSE4A,AMD
+MOVNTSD		mem64,xmmreg			[mr:	f2 0f 2b /r]				SSE4A,AMD,SQ
+MOVNTSS		mem32,xmmreg			[mr:	f3 0f 2b /r]				SSE4A,AMD,SD
+
+;# New instructions in Barcelona
+LZCNT		reg16,rm16			[rm:	o16 f3i 0f bd /r]			P6,AMD
+LZCNT		reg32,rm32			[rm:	o32 f3i 0f bd /r]			P6,AMD
+LZCNT		reg64,rm64			[rm:	o64 f3i 0f bd /r]			X86_64,LONG,AMD
+
+;# Penryn New Instructions (SSE4.1)
+BLENDPD		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 0d /r ib,u]			SSE41
+BLENDPS		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 0c /r ib,u]			SSE41
+BLENDVPD	xmmreg,xmmrm128,xmm0		[rm-:	66 0f 38 15 /r]				SSE41
+BLENDVPD	xmmreg,xmmrm128			[rm:	66 0f 38 15 /r]				SSE41
+BLENDVPS	xmmreg,xmmrm128,xmm0		[rm-:	66 0f 38 14 /r]				SSE41
+BLENDVPS	xmmreg,xmmrm128			[rm:	66 0f 38 14 /r]				SSE41
+DPPD		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 41 /r ib,u]			SSE41
+DPPS		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 40 /r ib,u]			SSE41
+EXTRACTPS	rm32,xmmreg,imm8		[mri:	66 0f 3a 17 /r ib,u]			SSE41
+EXTRACTPS	reg64,xmmreg,imm8		[mri:	o64 66 0f 3a 17 /r ib,u]		SSE41,X86_64,LONG
+INSERTPS	xmmreg,xmmrm32,imm8		[rmi:	66 0f 3a 21 /r ib,u]			SSE41
+MOVNTDQA	xmmreg,mem128			[rm:	66 0f 38 2a /r]				SSE41
+MPSADBW		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 42 /r ib,u]			SSE41
+PACKUSDW	xmmreg,xmmrm128			[rm:	66 0f 38 2b /r]				SSE41
+PBLENDVB	xmmreg,xmmrm,xmm0		[rm-:	66 0f 38 10 /r]				SSE41
+PBLENDVB	xmmreg,xmmrm128			[rm:	66 0f 38 10 /r]				SSE41
+PBLENDW		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 0e /r ib,u]			SSE41
+PCMPEQQ		xmmreg,xmmrm128			[rm:	66 0f 38 29 /r]				SSE41
+PEXTRB		reg32,xmmreg,imm8		[mri:	66 0f 3a 14 /r ib,u]			SSE41
+PEXTRB		mem8,xmmreg,imm8		[mri:	66 0f 3a 14 /r ib,u]			SSE41
+PEXTRB		reg64,xmmreg,imm8		[mri:	o64nw 66 0f 3a 14 /r ib,u]		SSE41,X86_64,LONG
+PEXTRD		rm32,xmmreg,imm8		[mri:	norexw 66 0f 3a 16 /r ib,u]		SSE41
+PEXTRQ		rm64,xmmreg,imm8		[mri:	o64 66 0f 3a 16 /r ib,u]		SSE41,X86_64,LONG
+PEXTRW		reg32,xmmreg,imm8		[mri:	66 0f 3a 15 /r ib,u]			SSE41
+PEXTRW		mem16,xmmreg,imm8		[mri:	66 0f 3a 15 /r ib,u]			SSE41
+PEXTRW		reg64,xmmreg,imm8		[mri:	o64 66 0f 3a 15 /r ib,u]		SSE41,X86_64,LONG
+PHMINPOSUW	xmmreg,xmmrm128			[rm:	66 0f 38 41 /r]				SSE41
+PINSRB		xmmreg,mem,imm8			[rmi:	66 0f 3a 20 /r ib,u]			SSE41,SB,AR2
+PINSRB		xmmreg,rm8,imm8			[rmi:	nohi 66 0f 3a 20 /r ib,u]		SSE41,SB,AR2
+PINSRB		xmmreg,reg32,imm8		[rmi:	66 0f 3a 20 /r ib,u]			SSE41,SB,AR2
+PINSRD		xmmreg,rm32,imm8		[rmi:	norexw 66 0f 3a 22 /r ib,u]		SSE41,SB,AR2
+PINSRQ		xmmreg,rm64,imm8		[rmi:	o64 66 0f 3a 22 /r ib,u]		SSE41,X86_64,LONG,SB,AR2
+PMAXSB		xmmreg,xmmrm128			[rm:	66 0f 38 3c /r]				SSE41
+PMAXSD		xmmreg,xmmrm128			[rm:	66 0f 38 3d /r]				SSE41
+PMAXUD		xmmreg,xmmrm128			[rm:	66 0f 38 3f /r]				SSE41
+PMAXUW		xmmreg,xmmrm128			[rm:	66 0f 38 3e /r]				SSE41
+PMINSB		xmmreg,xmmrm128			[rm:	66 0f 38 38 /r]				SSE41
+PMINSD		xmmreg,xmmrm128			[rm:	66 0f 38 39 /r]				SSE41
+PMINUD		xmmreg,xmmrm128			[rm:	66 0f 38 3b /r]				SSE41
+PMINUW		xmmreg,xmmrm128			[rm:	66 0f 38 3a /r]				SSE41
+PMOVSXBW	xmmreg,xmmrm64			[rm:	66 0f 38 20 /r]				SSE41,SQ
+PMOVSXBD	xmmreg,xmmrm32			[rm:	66 0f 38 21 /r]				SSE41,SD
+PMOVSXBQ	xmmreg,xmmrm16			[rm:	66 0f 38 22 /r]				SSE41,SW
+PMOVSXWD	xmmreg,xmmrm64			[rm:	66 0f 38 23 /r]				SSE41,SQ
+PMOVSXWQ	xmmreg,xmmrm32			[rm:	66 0f 38 24 /r]				SSE41,SD
+PMOVSXDQ	xmmreg,xmmrm64			[rm:	66 0f 38 25 /r]				SSE41,SQ
+PMOVZXBW	xmmreg,xmmrm64			[rm:	66 0f 38 30 /r]				SSE41,SQ
+PMOVZXBD	xmmreg,xmmrm32			[rm:	66 0f 38 31 /r]				SSE41,SD
+PMOVZXBQ	xmmreg,xmmrm16			[rm:	66 0f 38 32 /r]				SSE41,SW
+PMOVZXWD	xmmreg,xmmrm64			[rm:	66 0f 38 33 /r]				SSE41,SQ
+PMOVZXWQ	xmmreg,xmmrm32			[rm:	66 0f 38 34 /r]				SSE41,SD
+PMOVZXDQ	xmmreg,xmmrm64			[rm:	66 0f 38 35 /r]				SSE41,SQ
+PMULDQ		xmmreg,xmmrm128			[rm:	66 0f 38 28 /r]				SSE41
+PMULLD		xmmreg,xmmrm128			[rm:	66 0f 38 40 /r]				SSE41
+PTEST		xmmreg,xmmrm128			[rm:	66 0f 38 17 /r]				SSE41
+ROUNDPD		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 09 /r ib,u]			SSE41
+ROUNDPS		xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 08 /r ib,u]			SSE41
+ROUNDSD		xmmreg,xmmrm64,imm8		[rmi:	66 0f 3a 0b /r ib,u]			SSE41
+ROUNDSS		xmmreg,xmmrm32,imm8		[rmi:	66 0f 3a 0a /r ib,u]			SSE41
+
+;# Nehalem New Instructions (SSE4.2)
+CRC32		reg32,rm8			[rm:	f2i 0f 38 f0 /r]			SSE42
+CRC32		reg32,rm16			[rm:	o16 f2i 0f 38 f1 /r]			SSE42
+CRC32		reg32,rm32			[rm:	o32 f2i 0f 38 f1 /r]			SSE42
+CRC32		reg64,rm8			[rm:	o64 f2i 0f 38 f0 /r]			SSE42,X86_64,LONG
+CRC32		reg64,rm64			[rm:	o64 f2i 0f 38 f1 /r]			SSE42,X86_64,LONG
+PCMPESTRI	xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 61 /r ib,u]			SSE42
+PCMPESTRM	xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 60 /r ib,u]			SSE42
+PCMPISTRI	xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 63 /r ib,u]			SSE42
+PCMPISTRM	xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 62 /r ib,u]			SSE42
+PCMPGTQ		xmmreg,xmmrm128			[rm:	66 0f 38 37 /r]				SSE42
+POPCNT		reg16,rm16			[rm:	o16 f3i 0f b8 /r]			NEHALEM,SW
+POPCNT		reg32,rm32			[rm:	o32 f3i 0f b8 /r]			NEHALEM,SD
+POPCNT		reg64,rm64			[rm:	o64 f3i 0f b8 /r]			NEHALEM,SQ,LONG
+
+;# Intel SMX
+GETSEC		void				[	0f 37]					KATMAI
+
+;# Geode (Cyrix) 3DNow! additions
+PFRCPV		mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 86]			PENT,3DNOW,SQ,CYRIX
+PFRSQRTV	mmxreg,mmxrm			[rm:	o64nw 0f 0f /r 87]			PENT,3DNOW,SQ,CYRIX
+
+;# Intel new instructions in ???
+; Is NEHALEM right here?
+MOVBE		reg16,mem16			[rm:	o16 norep 0f 38 f0 /r]			NEHALEM,SM
+MOVBE		reg32,mem32			[rm:	o32 norep 0f 38 f0 /r]			NEHALEM,SM
+MOVBE		reg64,mem64			[rm:	o64 norep 0f 38 f0 /r]			NEHALEM,SM
+MOVBE		mem16,reg16			[mr:	o16 norep 0f 38 f1 /r]			NEHALEM,SM
+MOVBE		mem32,reg32			[mr:	o32 norep 0f 38 f1 /r]			NEHALEM,SM
+MOVBE		mem64,reg64			[mr:	o64 norep 0f 38 f1 /r]			NEHALEM,SM
+
+;# Intel AES instructions
+AESENC		xmmreg,xmmrm128			[rm:	66 0f 38 dc /r]				SSE,WESTMERE
+AESENCLAST	xmmreg,xmmrm128			[rm:	66 0f 38 dd /r]				SSE,WESTMERE
+AESDEC		xmmreg,xmmrm128			[rm:	66 0f 38 de /r]				SSE,WESTMERE
+AESDECLAST	xmmreg,xmmrm128			[rm:	66 0f 38 df /r]				SSE,WESTMERE
+AESIMC		xmmreg,xmmrm128			[rm:	66 0f 38 db /r]				SSE,WESTMERE
+AESKEYGENASSIST	xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a df /r ib]			SSE,WESTMERE
+
+;# Intel AVX AES instructions
+VAESENC		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 dc /r]		AVX,SANDYBRIDGE
+VAESENCLAST	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 dd /r]		AVX,SANDYBRIDGE
+VAESDEC		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 de /r]		AVX,SANDYBRIDGE
+VAESDECLAST	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 df /r]		AVX,SANDYBRIDGE
+VAESIMC		xmmreg,xmmrm128			[rm:	vex.128.66.0f38 db /r]			AVX,SANDYBRIDGE
+VAESKEYGENASSIST xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a df /r ib]		AVX,SANDYBRIDGE
+
+;# Intel instruction extension based on pub number 319433-030 dated October 2017
+
+; Intel VAES instructions
+VAESENC		ymmreg,ymmreg*,ymmrm256		[rvm:   vex.nds.256.66.0f38.wig dc /r]		VAES,FUTURE
+VAESENCLAST	ymmreg,ymmreg*,ymmrm256		[rvm:   vex.nds.256.66.0f38.wig dd /r]		VAES,FUTURE
+VAESDEC		ymmreg,ymmreg*,ymmrm256		[rvm:   vex.nds.256.66.0f38.wig de /r]		VAES,FUTURE
+VAESDECLAST	ymmreg,ymmreg*,ymmrm256		[rvm:   vex.nds.256.66.0f38.wig df /r]		VAES,FUTURE
+
+; Intel VAES + AVX512VL instructions
+VAESENC		xmmreg,xmmreg*,xmmrm128		[rvm:fv: evex.nds.128.66.0f38.wig dc /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESENC		ymmreg,ymmreg*,ymmrm256		[rvm:fv: evex.nds.256.66.0f38.wig dc /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESENCLAST	xmmreg,xmmreg*,xmmrm128		[rvm:fv: evex.nds.128.66.0f38.wig dd /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESENCLAST	ymmreg,ymmreg*,ymmrm256		[rvm:fv: evex.nds.256.66.0f38.wig dd /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESDEC		xmmreg,xmmreg*,xmmrm128		[rvm:fv: evex.nds.128.66.0f38.wig de /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESDEC		ymmreg,ymmreg*,ymmrm256		[rvm:fv: evex.nds.256.66.0f38.wig de /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESDECLAST	xmmreg,xmmreg*,xmmrm128		[rvm:fv: evex.nds.128.66.0f38.wig df /r]	AVX512VL,AVX512,VAES,FUTURE
+VAESDECLAST	ymmreg,ymmreg*,ymmrm256		[rvm:fv: evex.nds.256.66.0f38.wig df /r]	AVX512VL,AVX512,VAES,FUTURE
+
+; Intel VAES + AVX512F instructions
+VAESENC		zmmreg,zmmreg*,zmmrm512		[rvm:fv: evex.nds.512.66.0f38.wig dc /r]	AVX512,VAES,FUTURE
+VAESENCLAST	zmmreg,zmmreg*,zmmrm512		[rvm:fv: evex.nds.512.66.0f38.wig dd /r]	AVX512,VAES,FUTURE
+VAESDEC		zmmreg,zmmreg*,zmmrm512		[rvm:fv: evex.nds.512.66.0f38.wig de /r]	AVX512,VAES,FUTURE
+VAESDECLAST	zmmreg,zmmreg*,zmmrm512		[rvm:fv: evex.nds.512.66.0f38.wig df /r]	AVX512,VAES,FUTURE
+
+;# Intel AVX instructions
+VADDPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 58 /r]		AVX,SANDYBRIDGE
+VADDPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 58 /r]		AVX,SANDYBRIDGE
+VADDPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 58 /r]			AVX,SANDYBRIDGE
+VADDPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 58 /r]			AVX,SANDYBRIDGE
+VADDSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 58 /r]		AVX,SANDYBRIDGE
+VADDSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 58 /r]		AVX,SANDYBRIDGE
+VADDSUBPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d0 /r]		AVX,SANDYBRIDGE
+VADDSUBPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f d0 /r]		AVX,SANDYBRIDGE
+VADDSUBPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.f2.0f d0 /r]		AVX,SANDYBRIDGE
+VADDSUBPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.f2.0f d0 /r]		AVX,SANDYBRIDGE
+VANDPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 54 /r]		AVX,SANDYBRIDGE
+VANDPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 54 /r]		AVX,SANDYBRIDGE
+VANDPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 54 /r]			AVX,SANDYBRIDGE
+VANDPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 54 /r]			AVX,SANDYBRIDGE
+VANDNPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 55 /r]		AVX,SANDYBRIDGE
+VANDNPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 55 /r]		AVX,SANDYBRIDGE
+VANDNPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 55 /r]			AVX,SANDYBRIDGE
+VANDNPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 55 /r]			AVX,SANDYBRIDGE
+VBLENDPD	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 0d /r ib]		AVX,SANDYBRIDGE
+VBLENDPD	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a 0d /r ib]		AVX,SANDYBRIDGE
+VBLENDPS	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 0c /r ib]		AVX,SANDYBRIDGE
+VBLENDPS	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a 0c /r ib]		AVX,SANDYBRIDGE
+VBLENDVPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.nds.128.66.0f3a.w0 4b /r /is4]	AVX,SANDYBRIDGE
+VBLENDVPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.nds.256.66.0f3a.w0 4b /r /is4]	AVX,SANDYBRIDGE
+VBLENDVPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.nds.128.66.0f3a.w0 4a /r /is4]	AVX,SANDYBRIDGE
+VBLENDVPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.nds.256.66.0f3a.w0 4a /r /is4]	AVX,SANDYBRIDGE
+VBROADCASTSS	xmmreg,mem32			[rm:	vex.128.66.0f38.w0 18 /r]		AVX,SANDYBRIDGE
+VBROADCASTSS	ymmreg,mem32			[rm:	vex.256.66.0f38.w0 18 /r]		AVX,SANDYBRIDGE
+VBROADCASTSD	ymmreg,mem64			[rm:	vex.256.66.0f38.w0 19 /r]		AVX,SANDYBRIDGE
+VBROADCASTF128	ymmreg,mem128			[rm:	vex.256.66.0f38.w0 1a /r]		AVX,SANDYBRIDGE
+; Specific aliases first, then the generic version, to keep the disassembler happy...
+VCMPEQ_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQ_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 00]		AVX,SANDYBRIDGE
+VCMPEQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 00]		AVX,SANDYBRIDGE
+VCMPLT_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLT_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLTPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLTPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLE_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLE_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLEPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLEPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPUNORD_QPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORD_QPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORDPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORDPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPNEQ_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQ_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNLT_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLT_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLTPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLTPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLE_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLE_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLEPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLEPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPORD_QPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORD_QPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORDPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORDPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPEQ_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 08]		AVX,SANDYBRIDGE
+VCMPEQ_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 08]		AVX,SANDYBRIDGE
+VCMPNGE_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGE_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGEPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGEPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGT_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGT_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGTPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGTPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPFALSE_OQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSE_OQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSEPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSEPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPNEQ_OQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0c]		AVX,SANDYBRIDGE
+VCMPNEQ_OQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0c]		AVX,SANDYBRIDGE
+VCMPGE_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGE_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGEPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGEPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGT_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGT_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGTPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGTPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPTRUE_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUE_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUEPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUEPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPEQ_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQ_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPLT_OQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 11]		AVX,SANDYBRIDGE
+VCMPLT_OQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 11]		AVX,SANDYBRIDGE
+VCMPLE_OQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 12]		AVX,SANDYBRIDGE
+VCMPLE_OQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 12]		AVX,SANDYBRIDGE
+VCMPUNORD_SPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 13]		AVX,SANDYBRIDGE
+VCMPUNORD_SPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 13]		AVX,SANDYBRIDGE
+VCMPNEQ_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 14]		AVX,SANDYBRIDGE
+VCMPNEQ_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 14]		AVX,SANDYBRIDGE
+VCMPNLT_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 15]		AVX,SANDYBRIDGE
+VCMPNLT_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 15]		AVX,SANDYBRIDGE
+VCMPNLE_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 16]		AVX,SANDYBRIDGE
+VCMPNLE_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 16]		AVX,SANDYBRIDGE
+VCMPORD_SPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 17]		AVX,SANDYBRIDGE
+VCMPORD_SPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 17]		AVX,SANDYBRIDGE
+VCMPEQ_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 18]		AVX,SANDYBRIDGE
+VCMPEQ_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 18]		AVX,SANDYBRIDGE
+VCMPNGE_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 19]		AVX,SANDYBRIDGE
+VCMPNGE_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 19]		AVX,SANDYBRIDGE
+VCMPNGT_UQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 1a]		AVX,SANDYBRIDGE
+VCMPNGT_UQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 1a]		AVX,SANDYBRIDGE
+VCMPFALSE_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 1b]		AVX,SANDYBRIDGE
+VCMPFALSE_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 1b]		AVX,SANDYBRIDGE
+VCMPNEQ_OSPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 1c]		AVX,SANDYBRIDGE
+VCMPNEQ_OSPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 1c]		AVX,SANDYBRIDGE
+VCMPGE_OQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 1d]		AVX,SANDYBRIDGE
+VCMPGE_OQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 1d]		AVX,SANDYBRIDGE
+VCMPGT_OQPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 1e]		AVX,SANDYBRIDGE
+VCMPGT_OQPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 1e]		AVX,SANDYBRIDGE
+VCMPTRUE_USPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f c2 /r 1f]		AVX,SANDYBRIDGE
+VCMPTRUE_USPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f c2 /r 1f]		AVX,SANDYBRIDGE
+VCMPPD		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f c2 /r ib]		AVX,SANDYBRIDGE
+VCMPPD		ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f c2 /r ib]		AVX,SANDYBRIDGE
+; Specific aliases first, then the generic version, to keep the disassembler happy...
+VCMPEQ_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQ_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 00]		AVX,SANDYBRIDGE
+VCMPEQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 00]		AVX,SANDYBRIDGE
+VCMPLT_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLT_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLTPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLTPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLE_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLE_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLEPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLEPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPUNORD_QPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORD_QPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORDPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORDPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPNEQ_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQ_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNLT_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLT_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLTPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLTPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLE_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLE_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLEPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLEPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPORD_QPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORD_QPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORDPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORDPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPEQ_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 08]		AVX,SANDYBRIDGE
+VCMPEQ_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 08]		AVX,SANDYBRIDGE
+VCMPNGE_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGE_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGEPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGEPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGT_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGT_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGTPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGTPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPFALSE_OQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSE_OQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSEPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSEPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPNEQ_OQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0c]		AVX,SANDYBRIDGE
+VCMPNEQ_OQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0c]		AVX,SANDYBRIDGE
+VCMPGE_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGE_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGEPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGEPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGT_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGT_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGTPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGTPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPTRUE_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUE_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUEPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUEPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPEQ_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQ_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPLT_OQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 11]		AVX,SANDYBRIDGE
+VCMPLT_OQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 11]		AVX,SANDYBRIDGE
+VCMPLE_OQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 12]		AVX,SANDYBRIDGE
+VCMPLE_OQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 12]		AVX,SANDYBRIDGE
+VCMPUNORD_SPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 13]		AVX,SANDYBRIDGE
+VCMPUNORD_SPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 13]		AVX,SANDYBRIDGE
+VCMPNEQ_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 14]		AVX,SANDYBRIDGE
+VCMPNEQ_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 14]		AVX,SANDYBRIDGE
+VCMPNLT_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 15]		AVX,SANDYBRIDGE
+VCMPNLT_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 15]		AVX,SANDYBRIDGE
+VCMPNLE_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 16]		AVX,SANDYBRIDGE
+VCMPNLE_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 16]		AVX,SANDYBRIDGE
+VCMPORD_SPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 17]		AVX,SANDYBRIDGE
+VCMPORD_SPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 17]		AVX,SANDYBRIDGE
+VCMPEQ_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 18]		AVX,SANDYBRIDGE
+VCMPEQ_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 18]		AVX,SANDYBRIDGE
+VCMPNGE_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 19]		AVX,SANDYBRIDGE
+VCMPNGE_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 19]		AVX,SANDYBRIDGE
+VCMPNGT_UQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 1a]		AVX,SANDYBRIDGE
+VCMPNGT_UQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 1a]		AVX,SANDYBRIDGE
+VCMPFALSE_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 1b]		AVX,SANDYBRIDGE
+VCMPFALSE_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 1b]		AVX,SANDYBRIDGE
+VCMPNEQ_OSPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 1c]		AVX,SANDYBRIDGE
+VCMPNEQ_OSPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 1c]		AVX,SANDYBRIDGE
+VCMPGE_OQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 1d]		AVX,SANDYBRIDGE
+VCMPGE_OQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 1d]		AVX,SANDYBRIDGE
+VCMPGT_OQPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 1e]		AVX,SANDYBRIDGE
+VCMPGT_OQPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 1e]		AVX,SANDYBRIDGE
+VCMPTRUE_USPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f c2 /r 1f]		AVX,SANDYBRIDGE
+VCMPTRUE_USPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f c2 /r 1f]		AVX,SANDYBRIDGE
+VCMPPS		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.0f c2 /r ib]		AVX,SANDYBRIDGE
+VCMPPS		ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.0f c2 /r ib]		AVX,SANDYBRIDGE
+; Specific aliases first, then the generic version, to keep the disassembler happy...
+VCMPEQ_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 00]		AVX,SANDYBRIDGE
+VCMPLT_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLTSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLE_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLESD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPUNORD_QSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORDSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPNEQ_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNLT_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLTSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLE_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLESD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPORD_QSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORDSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPEQ_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 08]		AVX,SANDYBRIDGE
+VCMPNGE_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGESD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGT_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGTSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPFALSE_OQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSESD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPNEQ_OQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0c]		AVX,SANDYBRIDGE
+VCMPGE_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGESD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGT_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGTSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPTRUE_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUESD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPEQ_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPLT_OQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 11]		AVX,SANDYBRIDGE
+VCMPLE_OQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 12]		AVX,SANDYBRIDGE
+VCMPUNORD_SSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 13]		AVX,SANDYBRIDGE
+VCMPNEQ_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 14]		AVX,SANDYBRIDGE
+VCMPNLT_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 15]		AVX,SANDYBRIDGE
+VCMPNLE_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 16]		AVX,SANDYBRIDGE
+VCMPORD_SSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 17]		AVX,SANDYBRIDGE
+VCMPEQ_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 18]		AVX,SANDYBRIDGE
+VCMPNGE_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 19]		AVX,SANDYBRIDGE
+VCMPNGT_UQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 1a]		AVX,SANDYBRIDGE
+VCMPFALSE_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 1b]		AVX,SANDYBRIDGE
+VCMPNEQ_OSSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 1c]		AVX,SANDYBRIDGE
+VCMPGE_OQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 1d]		AVX,SANDYBRIDGE
+VCMPGT_OQSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 1e]		AVX,SANDYBRIDGE
+VCMPTRUE_USSD	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f c2 /r 1f]		AVX,SANDYBRIDGE
+VCMPSD		xmmreg,xmmreg*,xmmrm64,imm8	[rvmi:	vex.nds.lig.f2.0f c2 /r ib]		AVX,SANDYBRIDGE
+; Specific aliases first, then the generic version, to keep the disassembler happy...
+VCMPEQ_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPEQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 00]		AVX,SANDYBRIDGE
+VCMPLT_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLTSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 01]		AVX,SANDYBRIDGE
+VCMPLE_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPLESS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 02]		AVX,SANDYBRIDGE
+VCMPUNORD_QSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPUNORDSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 03]		AVX,SANDYBRIDGE
+VCMPNEQ_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNEQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 04]		AVX,SANDYBRIDGE
+VCMPNLT_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLTSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 05]		AVX,SANDYBRIDGE
+VCMPNLE_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPNLESS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 06]		AVX,SANDYBRIDGE
+VCMPORD_QSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPORDSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 07]		AVX,SANDYBRIDGE
+VCMPEQ_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 08]		AVX,SANDYBRIDGE
+VCMPNGE_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGESS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 09]		AVX,SANDYBRIDGE
+VCMPNGT_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPNGTSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0a]		AVX,SANDYBRIDGE
+VCMPFALSE_OQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPFALSESS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0b]		AVX,SANDYBRIDGE
+VCMPNEQ_OQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0c]		AVX,SANDYBRIDGE
+VCMPGE_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGESS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0d]		AVX,SANDYBRIDGE
+VCMPGT_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPGTSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0e]		AVX,SANDYBRIDGE
+VCMPTRUE_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPTRUESS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 0f]		AVX,SANDYBRIDGE
+VCMPEQ_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 10]		AVX,SANDYBRIDGE
+VCMPLT_OQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 11]		AVX,SANDYBRIDGE
+VCMPLE_OQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 12]		AVX,SANDYBRIDGE
+VCMPUNORD_SSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 13]		AVX,SANDYBRIDGE
+VCMPNEQ_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 14]		AVX,SANDYBRIDGE
+VCMPNLT_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 15]		AVX,SANDYBRIDGE
+VCMPNLE_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 16]		AVX,SANDYBRIDGE
+VCMPORD_SSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 17]		AVX,SANDYBRIDGE
+VCMPEQ_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 18]		AVX,SANDYBRIDGE
+VCMPNGE_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 19]		AVX,SANDYBRIDGE
+VCMPNGT_UQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 1a]		AVX,SANDYBRIDGE
+VCMPFALSE_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 1b]		AVX,SANDYBRIDGE
+VCMPNEQ_OSSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 1c]		AVX,SANDYBRIDGE
+VCMPGE_OQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 1d]		AVX,SANDYBRIDGE
+VCMPGT_OQSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 1e]		AVX,SANDYBRIDGE
+VCMPTRUE_USSS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f3.0f c2 /r 1f]		AVX,SANDYBRIDGE
+VCMPSS		xmmreg,xmmreg*,xmmrm64,imm8	[rvmi:	vex.nds.lig.f3.0f c2 /r ib]		AVX,SANDYBRIDGE
+VCOMISD		xmmreg,xmmrm64			[rm:	vex.lig.66.0f 2f /r]			AVX,SANDYBRIDGE
+VCOMISS		xmmreg,xmmrm32			[rm:	vex.lig.0f 2f /r]			AVX,SANDYBRIDGE
+VCVTDQ2PD	xmmreg,xmmrm64			[rm:	vex.128.f3.0f e6 /r]			AVX,SANDYBRIDGE
+VCVTDQ2PD	ymmreg,xmmrm128			[rm:	vex.256.f3.0f e6 /r]			AVX,SANDYBRIDGE
+VCVTDQ2PS	xmmreg,xmmrm128			[rm:	vex.128.0f 5b /r]			AVX,SANDYBRIDGE
+VCVTDQ2PS	ymmreg,ymmrm256			[rm:	vex.256.0f 5b /r]			AVX,SANDYBRIDGE
+VCVTPD2DQ	xmmreg,xmmreg			[rm:	vex.128.f2.0f e6 /r]			AVX,SANDYBRIDGE
+VCVTPD2DQ	xmmreg,mem128			[rm:	vex.128.f2.0f e6 /r]			AVX,SANDYBRIDGE,SO
+VCVTPD2DQ	xmmreg,ymmreg			[rm:	vex.256.f2.0f e6 /r]			AVX,SANDYBRIDGE
+VCVTPD2DQ	xmmreg,mem256			[rm:	vex.256.f2.0f e6 /r]			AVX,SANDYBRIDGE,SY
+VCVTPD2PS	xmmreg,xmmreg			[rm:	vex.128.66.0f 5a /r]			AVX,SANDYBRIDGE
+VCVTPD2PS	xmmreg,mem128			[rm:	vex.128.66.0f 5a /r]			AVX,SANDYBRIDGE,SO
+VCVTPD2PS	xmmreg,ymmreg			[rm:	vex.256.66.0f 5a /r]			AVX,SANDYBRIDGE
+VCVTPD2PS	xmmreg,mem256			[rm:	vex.256.66.0f 5a /r]			AVX,SANDYBRIDGE,SY
+VCVTPS2DQ	xmmreg,xmmrm128			[rm:	vex.128.66.0f 5b /r]			AVX,SANDYBRIDGE
+VCVTPS2DQ	ymmreg,ymmrm256			[rm:	vex.256.66.0f 5b /r]			AVX,SANDYBRIDGE
+VCVTPS2PD	xmmreg,xmmrm64			[rm:	vex.128.0f 5a /r]			AVX,SANDYBRIDGE
+VCVTPS2PD	ymmreg,xmmrm128			[rm:	vex.256.0f 5a /r]			AVX,SANDYBRIDGE
+VCVTSD2SI	reg32,xmmrm64			[rm:	vex.lig.f2.0f.w0 2d /r]			AVX,SANDYBRIDGE
+VCVTSD2SI	reg64,xmmrm64			[rm:	vex.lig.f2.0f.w1 2d /r]			AVX,SANDYBRIDGE,LONG
+VCVTSD2SS	xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 5a /r]		AVX,SANDYBRIDGE
+VCVTSI2SD	xmmreg,xmmreg*,rm32		[rvm:	vex.nds.lig.f2.0f.w0 2a /r]		AVX,SANDYBRIDGE,SD
+VCVTSI2SD	xmmreg,xmmreg*,mem32		[rvm:	vex.nds.lig.f2.0f.w0 2a /r]		AVX,SANDYBRIDGE,ND,SD
+VCVTSI2SD	xmmreg,xmmreg*,rm64		[rvm:	vex.nds.lig.f2.0f.w1 2a /r]		AVX,SANDYBRIDGE,LONG,SQ
+VCVTSI2SS	xmmreg,xmmreg*,rm32		[rvm:	vex.nds.lig.f3.0f.w0 2a /r]		AVX,SANDYBRIDGE,SD
+VCVTSI2SS	xmmreg,xmmreg*,mem32		[rvm:	vex.nds.lig.f3.0f.w0 2a /r]		AVX,SANDYBRIDGE,ND,SD
+VCVTSI2SS	xmmreg,xmmreg*,rm64		[rvm:	vex.nds.lig.f3.0f.w1 2a /r]		AVX,SANDYBRIDGE,LONG,SQ
+VCVTSS2SD	xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 5a /r]		AVX,SANDYBRIDGE
+VCVTSS2SI	reg32,xmmrm32			[rm:	vex.lig.f3.0f.w0 2d /r]			AVX,SANDYBRIDGE
+VCVTSS2SI	reg64,xmmrm32			[rm:	vex.lig.f3.0f.w1 2d /r]			AVX,SANDYBRIDGE,LONG
+VCVTTPD2DQ	xmmreg,xmmreg			[rm:	vex.128.66.0f e6 /r]			AVX,SANDYBRIDGE
+VCVTTPD2DQ	xmmreg,mem128			[rm:	vex.128.66.0f e6 /r]			AVX,SANDYBRIDGE,SO
+VCVTTPD2DQ	xmmreg,ymmreg			[rm:	vex.256.66.0f e6 /r]			AVX,SANDYBRIDGE
+VCVTTPD2DQ	xmmreg,mem256			[rm:	vex.256.66.0f e6 /r]			AVX,SANDYBRIDGE,SY
+VCVTTPS2DQ	xmmreg,xmmrm128			[rm:	vex.128.f3.0f 5b /r]			AVX,SANDYBRIDGE
+VCVTTPS2DQ	ymmreg,ymmrm256			[rm:	vex.256.f3.0f 5b /r]			AVX,SANDYBRIDGE
+VCVTTSD2SI	reg32,xmmrm64			[rm:	vex.lig.f2.0f.w0 2c /r]			AVX,SANDYBRIDGE
+VCVTTSD2SI	reg64,xmmrm64			[rm:	vex.lig.f2.0f.w1 2c /r]			AVX,SANDYBRIDGE,LONG
+VCVTTSS2SI	reg32,xmmrm32			[rm:	vex.lig.f3.0f.w0 2c /r]			AVX,SANDYBRIDGE
+VCVTTSS2SI	reg64,xmmrm32			[rm:	vex.lig.f3.0f.w1 2c /r]			AVX,SANDYBRIDGE,LONG
+VDIVPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 5e /r]		AVX,SANDYBRIDGE
+VDIVPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 5e /r]		AVX,SANDYBRIDGE
+VDIVPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 5e /r]			AVX,SANDYBRIDGE
+VDIVPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 5e /r]			AVX,SANDYBRIDGE
+VDIVSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 5e /r]		AVX,SANDYBRIDGE
+VDIVSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 5e /r]		AVX,SANDYBRIDGE
+VDPPD		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 41 /r ib]		AVX,SANDYBRIDGE
+VDPPS		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 40 /r ib]		AVX,SANDYBRIDGE
+VDPPS		ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a 40 /r ib]		AVX,SANDYBRIDGE
+VEXTRACTF128	xmmrm128,ymmreg,imm8		[mri:	vex.256.66.0f3a.w0 19 /r ib]		AVX,SANDYBRIDGE
+VEXTRACTPS	rm32,xmmreg,imm8		[mri:	vex.128.66.0f3a 17 /r ib]		AVX,SANDYBRIDGE
+VHADDPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 7c /r]		AVX,SANDYBRIDGE
+VHADDPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 7c /r]		AVX,SANDYBRIDGE
+VHADDPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.f2.0f 7c /r]		AVX,SANDYBRIDGE
+VHADDPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.f2.0f 7c /r]		AVX,SANDYBRIDGE
+VHSUBPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 7d /r]		AVX,SANDYBRIDGE
+VHSUBPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 7d /r]		AVX,SANDYBRIDGE
+VHSUBPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.f2.0f 7d /r]		AVX,SANDYBRIDGE
+VHSUBPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.f2.0f 7d /r]		AVX,SANDYBRIDGE
+VINSERTF128	ymmreg,ymmreg*,xmmrm128,imm8	[rvmi:	vex.nds.256.66.0f3a.w0 18 /r ib]	AVX,SANDYBRIDGE
+VINSERTPS	xmmreg,xmmreg*,xmmrm32,imm8	[rvmi:	vex.nds.128.66.0f3a 21 /r ib]		AVX,SANDYBRIDGE
+VLDDQU		xmmreg,mem128			[rm:	vex.128.f2.0f f0 /r]			AVX,SANDYBRIDGE
+VLDQQU		ymmreg,mem256			[rm:	vex.256.f2.0f f0 /r]			AVX,SANDYBRIDGE
+VLDDQU		ymmreg,mem256			[rm:	vex.256.f2.0f f0 /r]			AVX,SANDYBRIDGE
+VLDMXCSR	mem32				[m:	vex.lz.0f ae /2]			AVX,SANDYBRIDGE
+VMASKMOVDQU	xmmreg,xmmreg			[rm:	vex.128.66.0f f7 /r]			AVX,SANDYBRIDGE
+VMASKMOVPS	xmmreg,xmmreg,mem128		[rvm:	vex.nds.128.66.0f38.w0 2c /r]		AVX,SANDYBRIDGE
+VMASKMOVPS	ymmreg,ymmreg,mem256		[rvm:	vex.nds.256.66.0f38.w0 2c /r]		AVX,SANDYBRIDGE
+VMASKMOVPS	mem128,xmmreg,xmmreg		[mvr:	vex.nds.128.66.0f38.w0 2e /r]		AVX,SANDYBRIDGE,SO
+VMASKMOVPS	mem256,ymmreg,ymmreg		[mvr:	vex.nds.256.66.0f38.w0 2e /r]		AVX,SANDYBRIDGE,SY
+VMASKMOVPD	xmmreg,xmmreg,mem128		[rvm:	vex.nds.128.66.0f38.w0 2d /r]		AVX,SANDYBRIDGE
+VMASKMOVPD	ymmreg,ymmreg,mem256		[rvm:	vex.nds.256.66.0f38.w0 2d /r]		AVX,SANDYBRIDGE
+VMASKMOVPD	mem128,xmmreg,xmmreg		[mvr:	vex.nds.128.66.0f38.w0 2f /r]		AVX,SANDYBRIDGE
+VMASKMOVPD	mem256,ymmreg,ymmreg		[mvr:	vex.nds.256.66.0f38.w0 2f /r]		AVX,SANDYBRIDGE
+VMAXPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 5f /r]		AVX,SANDYBRIDGE
+VMAXPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 5f /r]		AVX,SANDYBRIDGE
+VMAXPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 5f /r]			AVX,SANDYBRIDGE
+VMAXPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 5f /r]			AVX,SANDYBRIDGE
+VMAXSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 5f /r]		AVX,SANDYBRIDGE
+VMAXSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 5f /r]		AVX,SANDYBRIDGE
+VMINPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 5d /r]		AVX,SANDYBRIDGE
+VMINPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 5d /r]		AVX,SANDYBRIDGE
+VMINPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 5d /r]			AVX,SANDYBRIDGE
+VMINPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 5d /r]			AVX,SANDYBRIDGE
+VMINSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 5d /r]		AVX,SANDYBRIDGE
+VMINSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 5d /r]		AVX,SANDYBRIDGE
+VMOVAPD		xmmreg,xmmrm128			[rm:	vex.128.66.0f 28 /r]			AVX,SANDYBRIDGE
+VMOVAPD		xmmrm128,xmmreg			[mr:	vex.128.66.0f 29 /r]			AVX,SANDYBRIDGE
+VMOVAPD		ymmreg,ymmrm256			[rm:	vex.256.66.0f 28 /r]			AVX,SANDYBRIDGE
+VMOVAPD		ymmrm256,ymmreg			[mr:	vex.256.66.0f 29 /r]			AVX,SANDYBRIDGE
+VMOVAPS		xmmreg,xmmrm128			[rm:	vex.128.0f 28 /r]			AVX,SANDYBRIDGE
+VMOVAPS		xmmrm128,xmmreg			[mr:	vex.128.0f 29 /r]			AVX,SANDYBRIDGE
+VMOVAPS		ymmreg,ymmrm256			[rm:	vex.256.0f 28 /r]			AVX,SANDYBRIDGE
+VMOVAPS		ymmrm256,ymmreg			[mr:	vex.256.0f 29 /r]			AVX,SANDYBRIDGE
+VMOVD		xmmreg,rm32			[rm:	vex.128.66.0f.w0 6e /r]			AVX,SANDYBRIDGE
+VMOVD		rm32,xmmreg			[mr:	vex.128.66.0f.w0 7e /r]			AVX,SANDYBRIDGE
+VMOVQ		xmmreg,xmmrm64			[rm:	vex.128.f3.0f 7e /r]			AVX,SANDYBRIDGE,SQ
+VMOVQ		xmmrm64,xmmreg			[mr:	vex.128.66.0f d6 /r]			AVX,SANDYBRIDGE,SQ
+VMOVQ		xmmreg,rm64			[rm:	vex.128.66.0f.w1 6e /r]			AVX,SANDYBRIDGE,LONG,SQ
+VMOVQ		rm64,xmmreg			[mr:	vex.128.66.0f.w1 7e /r]			AVX,SANDYBRIDGE,LONG,SQ
+VMOVDDUP	xmmreg,xmmrm64			[rm:	vex.128.f2.0f 12 /r]			AVX,SANDYBRIDGE
+VMOVDDUP	ymmreg,ymmrm256			[rm:	vex.256.f2.0f 12 /r]			AVX,SANDYBRIDGE
+VMOVDQA		xmmreg,xmmrm128			[rm:	vex.128.66.0f 6f /r]			AVX,SANDYBRIDGE
+VMOVDQA		xmmrm128,xmmreg			[mr:	vex.128.66.0f 7f /r]			AVX,SANDYBRIDGE
+; These are officially documented as VMOVDQA, but VMOVQQA seems more logical to me...
+VMOVQQA		ymmreg,ymmrm256			[rm:	vex.256.66.0f 6f /r]			AVX,SANDYBRIDGE
+VMOVQQA		ymmrm256,ymmreg			[mr:	vex.256.66.0f 7f /r]			AVX,SANDYBRIDGE
+VMOVDQA		ymmreg,ymmrm256			[rm:	vex.256.66.0f 6f /r]			AVX,SANDYBRIDGE
+VMOVDQA		ymmrm256,ymmreg			[mr:	vex.256.66.0f 7f /r]			AVX,SANDYBRIDGE
+VMOVDQU		xmmreg,xmmrm128			[rm:	vex.128.f3.0f 6f /r]			AVX,SANDYBRIDGE
+VMOVDQU		xmmrm128,xmmreg			[mr:	vex.128.f3.0f 7f /r]			AVX,SANDYBRIDGE
+; These are officially documented as VMOVDQU, but VMOVQQU seems more logical to me...
+VMOVQQU		ymmreg,ymmrm256			[rm:	vex.256.f3.0f 6f /r]			AVX,SANDYBRIDGE
+VMOVQQU		ymmrm256,ymmreg			[mr:	vex.256.f3.0f 7f /r]			AVX,SANDYBRIDGE
+VMOVDQU		ymmreg,ymmrm256			[rm:	vex.256.f3.0f 6f /r]			AVX,SANDYBRIDGE
+VMOVDQU		ymmrm256,ymmreg			[mr:	vex.256.f3.0f 7f /r]			AVX,SANDYBRIDGE
+VMOVHLPS	xmmreg,xmmreg*,xmmreg		[rvm:	vex.nds.128.0f 12 /r]			AVX,SANDYBRIDGE
+VMOVHPD		xmmreg,xmmreg*,mem64		[rvm:	vex.nds.128.66.0f 16 /r]		AVX,SANDYBRIDGE
+VMOVHPD		mem64,xmmreg			[mr:	vex.128.66.0f 17 /r]			AVX,SANDYBRIDGE
+VMOVHPS		xmmreg,xmmreg*,mem64		[rvm:	vex.nds.128.0f 16 /r]			AVX,SANDYBRIDGE
+VMOVHPS		mem64,xmmreg			[mr:	vex.128.0f 17 /r]			AVX,SANDYBRIDGE
+VMOVLHPS	xmmreg,xmmreg*,xmmreg		[rvm:	vex.nds.128.0f 16 /r]			AVX,SANDYBRIDGE
+VMOVLPD		xmmreg,xmmreg*,mem64		[rvm:	vex.nds.128.66.0f 12 /r]		AVX,SANDYBRIDGE
+VMOVLPD		mem64,xmmreg			[mr:	vex.128.66.0f 13 /r]			AVX,SANDYBRIDGE
+VMOVLPS		xmmreg,xmmreg*,mem64		[rvm:	vex.nds.128.0f 12 /r]			AVX,SANDYBRIDGE
+VMOVLPS		mem64,xmmreg			[mr:	vex.128.0f 13 /r]			AVX,SANDYBRIDGE
+VMOVMSKPD	reg64,xmmreg			[rm:	vex.128.66.0f 50 /r]			AVX,SANDYBRIDGE,LONG
+VMOVMSKPD	reg32,xmmreg			[rm:	vex.128.66.0f 50 /r]			AVX,SANDYBRIDGE
+VMOVMSKPD	reg64,ymmreg			[rm:	vex.256.66.0f 50 /r]			AVX,SANDYBRIDGE,LONG
+VMOVMSKPD	reg32,ymmreg			[rm:	vex.256.66.0f 50 /r]			AVX,SANDYBRIDGE
+VMOVMSKPS	reg64,xmmreg			[rm:	vex.128.0f 50 /r]			AVX,SANDYBRIDGE,LONG
+VMOVMSKPS	reg32,xmmreg			[rm:	vex.128.0f 50 /r]			AVX,SANDYBRIDGE
+VMOVMSKPS	reg64,ymmreg			[rm:	vex.256.0f 50 /r]			AVX,SANDYBRIDGE,LONG
+VMOVMSKPS	reg32,ymmreg			[rm:	vex.256.0f 50 /r]			AVX,SANDYBRIDGE
+VMOVNTDQ	mem128,xmmreg			[mr:	vex.128.66.0f e7 /r]			AVX,SANDYBRIDGE
+; Officially VMOVNTDQ, but VMOVNTQQ seems more logical to me...
+VMOVNTQQ	mem256,ymmreg			[mr:	vex.256.66.0f e7 /r]			AVX,SANDYBRIDGE
+VMOVNTDQ	mem256,ymmreg			[mr:	vex.256.66.0f e7 /r]			AVX,SANDYBRIDGE
+VMOVNTDQA	xmmreg,mem128			[rm:	vex.128.66.0f38 2a /r]			AVX,SANDYBRIDGE
+VMOVNTPD	mem128,xmmreg			[mr:	vex.128.66.0f 2b /r]			AVX,SANDYBRIDGE
+VMOVNTPD	mem256,ymmreg			[mr:	vex.256.66.0f 2b /r]			AVX,SANDYBRIDGE
+VMOVNTPS	mem128,xmmreg			[mr:	vex.128.0f 2b /r]			AVX,SANDYBRIDGE
+VMOVNTPS	mem256,ymmreg			[mr:	vex.256.0f 2b /r]			AVX,SANDYBRIDGE
+VMOVSD		xmmreg,xmmreg*,xmmreg		[rvm:	vex.nds.lig.f2.0f 10 /r]		AVX,SANDYBRIDGE
+VMOVSD		xmmreg,mem64			[rm:	vex.lig.f2.0f 10 /r]			AVX,SANDYBRIDGE
+VMOVSD		xmmreg,xmmreg*,xmmreg		[mvr:	vex.nds.lig.f2.0f 11 /r]		AVX,SANDYBRIDGE
+VMOVSD		mem64,xmmreg			[mr:	vex.lig.f2.0f 11 /r]			AVX,SANDYBRIDGE
+VMOVSHDUP	xmmreg,xmmrm128			[rm:	vex.128.f3.0f 16 /r]			AVX,SANDYBRIDGE
+VMOVSHDUP	ymmreg,ymmrm256			[rm:	vex.256.f3.0f 16 /r]			AVX,SANDYBRIDGE
+VMOVSLDUP	xmmreg,xmmrm128			[rm:	vex.128.f3.0f 12 /r]			AVX,SANDYBRIDGE
+VMOVSLDUP	ymmreg,ymmrm256			[rm:	vex.256.f3.0f 12 /r]			AVX,SANDYBRIDGE
+VMOVSS		xmmreg,xmmreg*,xmmreg		[rvm:	vex.nds.lig.f3.0f 10 /r]		AVX,SANDYBRIDGE
+VMOVSS		xmmreg,mem32			[rm:	vex.lig.f3.0f 10 /r]			AVX,SANDYBRIDGE
+VMOVSS		xmmreg,xmmreg*,xmmreg		[mvr:	vex.nds.lig.f3.0f 11 /r]		AVX,SANDYBRIDGE
+VMOVSS		mem32,xmmreg			[mr:	vex.lig.f3.0f 11 /r]			AVX,SANDYBRIDGE
+VMOVUPD		xmmreg,xmmrm128			[rm:	vex.128.66.0f 10 /r]			AVX,SANDYBRIDGE
+VMOVUPD		xmmrm128,xmmreg			[mr:	vex.128.66.0f 11 /r]			AVX,SANDYBRIDGE
+VMOVUPD		ymmreg,ymmrm256			[rm:	vex.256.66.0f 10 /r]			AVX,SANDYBRIDGE
+VMOVUPD		ymmrm256,ymmreg			[mr:	vex.256.66.0f 11 /r]			AVX,SANDYBRIDGE
+VMOVUPS		xmmreg,xmmrm128			[rm:	vex.128.0f 10 /r]			AVX,SANDYBRIDGE
+VMOVUPS		xmmrm128,xmmreg			[mr:	vex.128.0f 11 /r]			AVX,SANDYBRIDGE
+VMOVUPS		ymmreg,ymmrm256			[rm:	vex.256.0f 10 /r]			AVX,SANDYBRIDGE
+VMOVUPS		ymmrm256,ymmreg			[mr:	vex.256.0f 11 /r]			AVX,SANDYBRIDGE
+VMPSADBW	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 42 /r ib]		AVX,SANDYBRIDGE
+VMULPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 59 /r]		AVX,SANDYBRIDGE
+VMULPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 59 /r]		AVX,SANDYBRIDGE
+VMULPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 59 /r]			AVX,SANDYBRIDGE
+VMULPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 59 /r]			AVX,SANDYBRIDGE
+VMULSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 59 /r]		AVX,SANDYBRIDGE
+VMULSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 59 /r]		AVX,SANDYBRIDGE
+VORPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 56 /r]		AVX,SANDYBRIDGE
+VORPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 56 /r]		AVX,SANDYBRIDGE
+VORPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 56 /r]			AVX,SANDYBRIDGE
+VORPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 56 /r]			AVX,SANDYBRIDGE
+VPABSB		xmmreg,xmmrm128			[rm:	vex.128.66.0f38 1c /r]			AVX,SANDYBRIDGE
+VPABSW		xmmreg,xmmrm128			[rm:	vex.128.66.0f38 1d /r]			AVX,SANDYBRIDGE
+VPABSD		xmmreg,xmmrm128			[rm:	vex.128.66.0f38 1e /r]			AVX,SANDYBRIDGE
+VPACKSSWB	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 63 /r]		AVX,SANDYBRIDGE
+VPACKSSDW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 6b /r]		AVX,SANDYBRIDGE
+VPACKUSWB	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 67 /r]		AVX,SANDYBRIDGE
+VPACKUSDW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 2b /r]		AVX,SANDYBRIDGE
+VPADDB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f fc /r]		AVX,SANDYBRIDGE
+VPADDW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f fd /r]		AVX,SANDYBRIDGE
+VPADDD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f fe /r]		AVX,SANDYBRIDGE
+VPADDQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d4 /r]		AVX,SANDYBRIDGE
+VPADDSB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f ec /r]		AVX,SANDYBRIDGE
+VPADDSW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f ed /r]		AVX,SANDYBRIDGE
+VPADDUSB	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f dc /r]		AVX,SANDYBRIDGE
+VPADDUSW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f dd /r]		AVX,SANDYBRIDGE
+VPALIGNR	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 0f /r ib]		AVX,SANDYBRIDGE
+VPAND		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f db /r]		AVX,SANDYBRIDGE
+VPANDN		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f df /r]		AVX,SANDYBRIDGE
+VPAVGB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e0 /r]		AVX,SANDYBRIDGE
+VPAVGW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e3 /r]		AVX,SANDYBRIDGE
+VPBLENDVB	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.nds.128.66.0f3a.w0 4c /r /is4]	AVX,SANDYBRIDGE
+VPBLENDW	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 0e /r ib]		AVX,SANDYBRIDGE
+VPCMPESTRI	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a 61 /r ib]		AVX,SANDYBRIDGE
+VPCMPESTRM	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a 60 /r ib]		AVX,SANDYBRIDGE
+VPCMPISTRI	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a 63 /r ib]		AVX,SANDYBRIDGE
+VPCMPISTRM	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a 62 /r ib]		AVX,SANDYBRIDGE
+VPCMPEQB	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 74 /r]		AVX,SANDYBRIDGE
+VPCMPEQW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 75 /r]		AVX,SANDYBRIDGE
+VPCMPEQD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 76 /r]		AVX,SANDYBRIDGE
+VPCMPEQQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 29 /r]		AVX,SANDYBRIDGE
+VPCMPGTB	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 64 /r]		AVX,SANDYBRIDGE
+VPCMPGTW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 65 /r]		AVX,SANDYBRIDGE
+VPCMPGTD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 66 /r]		AVX,SANDYBRIDGE
+VPCMPGTQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 37 /r]		AVX,SANDYBRIDGE
+VPERMILPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w0 0d /r]		AVX,SANDYBRIDGE
+VPERMILPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 0d /r]		AVX,SANDYBRIDGE
+VPERMILPD	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a.w0 05 /r ib]		AVX,SANDYBRIDGE
+VPERMILPD	ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f3a.w0 05 /r ib]		AVX,SANDYBRIDGE
+VPERMILPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w0 0c /r]		AVX,SANDYBRIDGE
+VPERMILPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 0c /r]		AVX,SANDYBRIDGE
+VPERMILPS	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a.w0 04 /r ib]		AVX,SANDYBRIDGE
+VPERMILPS	ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f3a.w0 04 /r ib]		AVX,SANDYBRIDGE
+VPERM2F128	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a.w0 06 /r ib]	AVX,SANDYBRIDGE
+VPEXTRB		reg64,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 14 /r ib]		AVX,SANDYBRIDGE,LONG
+VPEXTRB		reg32,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 14 /r ib]		AVX,SANDYBRIDGE
+VPEXTRB		mem8,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 14 /r ib]		AVX,SANDYBRIDGE
+VPEXTRW		reg64,xmmreg,imm8		[rmi:	vex.128.66.0f.w0 c5 /r ib]		AVX,SANDYBRIDGE,LONG
+VPEXTRW		reg32,xmmreg,imm8		[rmi:	vex.128.66.0f.w0 c5 /r ib]		AVX,SANDYBRIDGE
+VPEXTRW		reg64,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 15 /r ib]		AVX,SANDYBRIDGE,LONG
+VPEXTRW		reg32,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 15 /r ib]		AVX,SANDYBRIDGE
+VPEXTRW		mem16,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 15 /r ib]		AVX,SANDYBRIDGE
+VPEXTRD		reg64,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 16 /r ib]		AVX,SANDYBRIDGE,LONG
+VPEXTRD		rm32,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 16 /r ib]		AVX,SANDYBRIDGE
+VPEXTRQ		rm64,xmmreg,imm8		[mri:	vex.128.66.0f3a.w1 16 /r ib]		AVX,SANDYBRIDGE,LONG
+VPHADDW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 01 /r]		AVX,SANDYBRIDGE
+VPHADDD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 02 /r]		AVX,SANDYBRIDGE
+VPHADDSW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 03 /r]		AVX,SANDYBRIDGE
+VPHMINPOSUW	xmmreg,xmmrm128			[rm:	vex.128.66.0f38 41 /r]			AVX,SANDYBRIDGE
+VPHSUBW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 05 /r]		AVX,SANDYBRIDGE
+VPHSUBD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 06 /r]		AVX,SANDYBRIDGE
+VPHSUBSW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 07 /r]		AVX,SANDYBRIDGE
+VPINSRB		xmmreg,xmmreg*,mem8,imm8	[rvmi:	vex.nds.128.66.0f3a 20 /r ib]		AVX,SANDYBRIDGE
+VPINSRB		xmmreg,xmmreg*,rm8,imm8		[rvmi:	vex.nds.128.66.0f3a 20 /r ib]		AVX,SANDYBRIDGE
+VPINSRB		xmmreg,xmmreg*,reg32,imm8	[rvmi:	vex.nds.128.66.0f3a 20 /r ib]		AVX,SANDYBRIDGE
+VPINSRW		xmmreg,xmmreg*,mem16,imm8	[rvmi:	vex.nds.128.66.0f c4 /r ib]		AVX,SANDYBRIDGE
+VPINSRW		xmmreg,xmmreg*,rm16,imm8	[rvmi:	vex.nds.128.66.0f c4 /r ib]		AVX,SANDYBRIDGE
+VPINSRW		xmmreg,xmmreg*,reg32,imm8	[rvmi:	vex.nds.128.66.0f c4 /r ib]		AVX,SANDYBRIDGE
+VPINSRD		xmmreg,xmmreg*,mem32,imm8	[rvmi:	vex.nds.128.66.0f3a.w0 22 /r ib]	AVX,SANDYBRIDGE
+VPINSRD		xmmreg,xmmreg*,rm32,imm8	[rvmi:	vex.nds.128.66.0f3a.w0 22 /r ib]	AVX,SANDYBRIDGE
+VPINSRQ		xmmreg,xmmreg*,mem64,imm8	[rvmi:	vex.nds.128.66.0f3a.w1 22 /r ib]	AVX,SANDYBRIDGE,LONG
+VPINSRQ		xmmreg,xmmreg*,rm64,imm8	[rvmi:	vex.nds.128.66.0f3a.w1 22 /r ib]	AVX,SANDYBRIDGE,LONG
+VPMADDWD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f5 /r]		AVX,SANDYBRIDGE
+VPMADDUBSW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 04 /r]		AVX,SANDYBRIDGE
+VPMAXSB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 3c /r]		AVX,SANDYBRIDGE
+VPMAXSW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f ee /r]		AVX,SANDYBRIDGE
+VPMAXSD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 3d /r]		AVX,SANDYBRIDGE
+VPMAXUB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f de /r]		AVX,SANDYBRIDGE
+VPMAXUW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 3e /r]		AVX,SANDYBRIDGE
+VPMAXUD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 3f /r]		AVX,SANDYBRIDGE
+VPMINSB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 38 /r]		AVX,SANDYBRIDGE
+VPMINSW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f ea /r]		AVX,SANDYBRIDGE
+VPMINSD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 39 /r]		AVX,SANDYBRIDGE
+VPMINUB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f da /r]		AVX,SANDYBRIDGE
+VPMINUW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 3a /r]		AVX,SANDYBRIDGE
+VPMINUD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 3b /r]		AVX,SANDYBRIDGE
+VPMOVMSKB	reg64,xmmreg			[rm:	vex.128.66.0f d7 /r]			AVX,SANDYBRIDGE,LONG
+VPMOVMSKB	reg32,xmmreg			[rm:	vex.128.66.0f d7 /r]			AVX,SANDYBRIDGE
+VPMOVSXBW	xmmreg,xmmrm64			[rm:	vex.128.66.0f38 20 /r]			AVX,SANDYBRIDGE
+VPMOVSXBD	xmmreg,xmmrm32			[rm:	vex.128.66.0f38 21 /r]			AVX,SANDYBRIDGE
+VPMOVSXBQ	xmmreg,xmmrm16			[rm:	vex.128.66.0f38 22 /r]			AVX,SANDYBRIDGE
+VPMOVSXWD	xmmreg,xmmrm64			[rm:	vex.128.66.0f38 23 /r]			AVX,SANDYBRIDGE
+VPMOVSXWQ	xmmreg,xmmrm32			[rm:	vex.128.66.0f38 24 /r]			AVX,SANDYBRIDGE
+VPMOVSXDQ	xmmreg,xmmrm64			[rm:	vex.128.66.0f38 25 /r]			AVX,SANDYBRIDGE
+VPMOVZXBW	xmmreg,xmmrm64			[rm:	vex.128.66.0f38 30 /r]			AVX,SANDYBRIDGE
+VPMOVZXBD	xmmreg,xmmrm32			[rm:	vex.128.66.0f38 31 /r]			AVX,SANDYBRIDGE
+VPMOVZXBQ	xmmreg,xmmrm16			[rm:	vex.128.66.0f38 32 /r]			AVX,SANDYBRIDGE
+VPMOVZXWD	xmmreg,xmmrm64			[rm:	vex.128.66.0f38 33 /r]			AVX,SANDYBRIDGE
+VPMOVZXWQ	xmmreg,xmmrm32			[rm:	vex.128.66.0f38 34 /r]			AVX,SANDYBRIDGE
+VPMOVZXDQ	xmmreg,xmmrm64			[rm:	vex.128.66.0f38 35 /r]			AVX,SANDYBRIDGE
+VPMULHUW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e4 /r]		AVX,SANDYBRIDGE
+VPMULHRSW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 0b /r]		AVX,SANDYBRIDGE
+VPMULHW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e5 /r]		AVX,SANDYBRIDGE
+VPMULLW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d5 /r]		AVX,SANDYBRIDGE
+VPMULLD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 40 /r]		AVX,SANDYBRIDGE
+VPMULUDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f4 /r]		AVX,SANDYBRIDGE
+VPMULDQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 28 /r]		AVX,SANDYBRIDGE
+VPOR		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f eb /r]		AVX,SANDYBRIDGE
+VPSADBW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f6 /r]		AVX,SANDYBRIDGE
+VPSHUFB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 00 /r]		AVX,SANDYBRIDGE
+VPSHUFD		xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f 70 /r ib]			AVX,SANDYBRIDGE
+VPSHUFHW	xmmreg,xmmrm128,imm8		[rmi:	vex.128.f3.0f 70 /r ib]			AVX,SANDYBRIDGE
+VPSHUFLW	xmmreg,xmmrm128,imm8		[rmi:	vex.128.f2.0f 70 /r ib]			AVX,SANDYBRIDGE
+VPSIGNB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 08 /r]		AVX,SANDYBRIDGE
+VPSIGNW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 09 /r]		AVX,SANDYBRIDGE
+VPSIGND		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38 0a /r]		AVX,SANDYBRIDGE
+VPSLLDQ		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 73 /7 ib]		AVX,SANDYBRIDGE
+VPSRLDQ		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 73 /3 ib]		AVX,SANDYBRIDGE
+VPSLLW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f1 /r]		AVX,SANDYBRIDGE
+VPSLLW		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 71 /6 ib]		AVX,SANDYBRIDGE
+VPSLLD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f2 /r]		AVX,SANDYBRIDGE
+VPSLLD		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 72 /6 ib]		AVX,SANDYBRIDGE
+VPSLLQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f3 /r]		AVX,SANDYBRIDGE
+VPSLLQ		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 73 /6 ib]		AVX,SANDYBRIDGE
+VPSRAW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e1 /r]		AVX,SANDYBRIDGE
+VPSRAW		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 71 /4 ib]		AVX,SANDYBRIDGE
+VPSRAD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e2 /r]		AVX,SANDYBRIDGE
+VPSRAD		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 72 /4 ib]		AVX,SANDYBRIDGE
+VPSRLW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d1 /r]		AVX,SANDYBRIDGE
+VPSRLW		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 71 /2 ib]		AVX,SANDYBRIDGE
+VPSRLD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d2 /r]		AVX,SANDYBRIDGE
+VPSRLD		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 72 /2 ib]		AVX,SANDYBRIDGE
+VPSRLQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d3 /r]		AVX,SANDYBRIDGE
+VPSRLQ		xmmreg,xmmreg*,imm8		[vmi:	vex.ndd.128.66.0f 73 /2 ib]		AVX,SANDYBRIDGE
+VPTEST		xmmreg,xmmrm128			[rm:	vex.128.66.0f38 17 /r]			AVX,SANDYBRIDGE
+VPTEST		ymmreg,ymmrm256			[rm:	vex.256.66.0f38 17 /r]			AVX,SANDYBRIDGE
+VPSUBB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f8 /r]		AVX,SANDYBRIDGE
+VPSUBW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f f9 /r]		AVX,SANDYBRIDGE
+VPSUBD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f fa /r]		AVX,SANDYBRIDGE
+VPSUBQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f fb /r]		AVX,SANDYBRIDGE
+VPSUBSB		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e8 /r]		AVX,SANDYBRIDGE
+VPSUBSW		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f e9 /r]		AVX,SANDYBRIDGE
+VPSUBUSB	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d8 /r]		AVX,SANDYBRIDGE
+VPSUBUSW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f d9 /r]		AVX,SANDYBRIDGE
+VPUNPCKHBW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 68 /r]		AVX,SANDYBRIDGE
+VPUNPCKHWD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 69 /r]		AVX,SANDYBRIDGE
+VPUNPCKHDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 6a /r]		AVX,SANDYBRIDGE
+VPUNPCKHQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 6d /r]		AVX,SANDYBRIDGE
+VPUNPCKLBW	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 60 /r]		AVX,SANDYBRIDGE
+VPUNPCKLWD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 61 /r]		AVX,SANDYBRIDGE
+VPUNPCKLDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 62 /r]		AVX,SANDYBRIDGE
+VPUNPCKLQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 6c /r]		AVX,SANDYBRIDGE
+VPXOR		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f ef /r]		AVX,SANDYBRIDGE
+VRCPPS		xmmreg,xmmrm128			[rm:	vex.128.0f 53 /r]			AVX,SANDYBRIDGE
+VRCPPS		ymmreg,ymmrm256			[rm:	vex.256.0f 53 /r]			AVX,SANDYBRIDGE
+VRCPSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 53 /r]		AVX,SANDYBRIDGE
+VRSQRTPS	xmmreg,xmmrm128			[rm:	vex.128.0f 52 /r]			AVX,SANDYBRIDGE
+VRSQRTPS	ymmreg,ymmrm256			[rm:	vex.256.0f 52 /r]			AVX,SANDYBRIDGE
+VRSQRTSS	xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 52 /r]		AVX,SANDYBRIDGE
+VROUNDPD	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a 09 /r ib]		AVX,SANDYBRIDGE
+VROUNDPD	ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f3a 09 /r ib]		AVX,SANDYBRIDGE
+VROUNDPS	xmmreg,xmmrm128,imm8		[rmi:	vex.128.66.0f3a 08 /r ib]		AVX,SANDYBRIDGE
+VROUNDPS	ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f3a 08 /r ib]		AVX,SANDYBRIDGE
+VROUNDSD	xmmreg,xmmreg*,xmmrm64,imm8	[rvmi:	vex.nds.128.66.0f3a 0b /r ib]		AVX,SANDYBRIDGE
+VROUNDSS	xmmreg,xmmreg*,xmmrm32,imm8	[rvmi:	vex.nds.128.66.0f3a 0a /r ib]		AVX,SANDYBRIDGE
+VSHUFPD		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f c6 /r ib]		AVX,SANDYBRIDGE
+VSHUFPD		ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f c6 /r ib]		AVX,SANDYBRIDGE
+VSHUFPS		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.0f c6 /r ib]		AVX,SANDYBRIDGE
+VSHUFPS		ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.0f c6 /r ib]		AVX,SANDYBRIDGE
+VSQRTPD		xmmreg,xmmrm128			[rm:	vex.128.66.0f 51 /r]			AVX,SANDYBRIDGE
+VSQRTPD		ymmreg,ymmrm256			[rm:	vex.256.66.0f 51 /r]			AVX,SANDYBRIDGE
+VSQRTPS		xmmreg,xmmrm128			[rm:	vex.128.0f 51 /r]			AVX,SANDYBRIDGE
+VSQRTPS		ymmreg,ymmrm256			[rm:	vex.256.0f 51 /r]			AVX,SANDYBRIDGE
+VSQRTSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 51 /r]		AVX,SANDYBRIDGE
+VSQRTSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 51 /r]		AVX,SANDYBRIDGE
+VSTMXCSR	mem32				[m:	vex.128.0f ae /3]			AVX,SANDYBRIDGE
+VSUBPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 5c /r]		AVX,SANDYBRIDGE
+VSUBPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 5c /r]		AVX,SANDYBRIDGE
+VSUBPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 5c /r]			AVX,SANDYBRIDGE
+VSUBPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 5c /r]			AVX,SANDYBRIDGE
+VSUBSD		xmmreg,xmmreg*,xmmrm64		[rvm:	vex.nds.lig.f2.0f 5c /r]		AVX,SANDYBRIDGE
+VSUBSS		xmmreg,xmmreg*,xmmrm32		[rvm:	vex.nds.lig.f3.0f 5c /r]		AVX,SANDYBRIDGE
+VTESTPS		xmmreg,xmmrm128			[rm:	vex.128.66.0f38.w0 0e /r]		AVX,SANDYBRIDGE
+VTESTPS		ymmreg,ymmrm256			[rm:	vex.256.66.0f38.w0 0e /r]		AVX,SANDYBRIDGE
+VTESTPD		xmmreg,xmmrm128			[rm:	vex.128.66.0f38.w0 0f /r]		AVX,SANDYBRIDGE
+VTESTPD		ymmreg,ymmrm256			[rm:	vex.256.66.0f38.w0 0f /r]		AVX,SANDYBRIDGE
+VUCOMISD	xmmreg,xmmrm64			[rm:	vex.lig.66.0f 2e /r]			AVX,SANDYBRIDGE
+VUCOMISS	xmmreg,xmmrm32			[rm:	vex.lig.0f 2e /r]			AVX,SANDYBRIDGE
+VUNPCKHPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 15 /r]		AVX,SANDYBRIDGE
+VUNPCKHPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 15 /r]		AVX,SANDYBRIDGE
+VUNPCKHPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 15 /r]			AVX,SANDYBRIDGE
+VUNPCKHPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 15 /r]			AVX,SANDYBRIDGE
+VUNPCKLPD	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 14 /r]		AVX,SANDYBRIDGE
+VUNPCKLPD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 14 /r]		AVX,SANDYBRIDGE
+VUNPCKLPS	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 14 /r]			AVX,SANDYBRIDGE
+VUNPCKLPS	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 14 /r]			AVX,SANDYBRIDGE
+VXORPD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f 57 /r]		AVX,SANDYBRIDGE
+VXORPD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 57 /r]		AVX,SANDYBRIDGE
+VXORPS		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.0f 57 /r]			AVX,SANDYBRIDGE
+VXORPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.0f 57 /r]			AVX,SANDYBRIDGE
+VZEROALL	void				[	vex.256.0f.w0 77]			AVX,SANDYBRIDGE
+VZEROUPPER	void				[	vex.128.0f.w0 77]			AVX,SANDYBRIDGE
+
+;# Intel Carry-Less Multiplication instructions (CLMUL)
+PCLMULLQLQDQ	xmmreg,xmmrm128			[rm:	66 0f 3a 44 /r 00]			SSE,WESTMERE
+PCLMULHQLQDQ	xmmreg,xmmrm128			[rm:	66 0f 3a 44 /r 01]			SSE,WESTMERE
+PCLMULLQHQDQ	xmmreg,xmmrm128			[rm:	66 0f 3a 44 /r 10]			SSE,WESTMERE
+PCLMULHQHQDQ	xmmreg,xmmrm128			[rm:	66 0f 3a 44 /r 11]			SSE,WESTMERE
+PCLMULQDQ	xmmreg,xmmrm128,imm8		[rmi:	66 0f 3a 44 /r ib]			SSE,WESTMERE
+
+;# Intel AVX Carry-Less Multiplication instructions (CLMUL)
+VPCLMULLQLQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f3a 44 /r 00]		AVX,SANDYBRIDGE
+VPCLMULHQLQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f3a 44 /r 01]		AVX,SANDYBRIDGE
+VPCLMULLQHQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f3a 44 /r 10]		AVX,SANDYBRIDGE
+VPCLMULHQHQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f3a 44 /r 11]		AVX,SANDYBRIDGE
+VPCLMULQDQ	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a 44 /r ib]		AVX,SANDYBRIDGE
+
+; Intel VPCLMULQDQ instructions
+VPCLMULLQLQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  vex.nds.256.66.0f3a.wig 44 /r 00]	VPCLMULQDQ,FUTURE
+VPCLMULHQLQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  vex.nds.256.66.0f3a.wig 44 /r 01]	VPCLMULQDQ,FUTURE
+VPCLMULLQHQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  vex.nds.256.66.0f3a.wig 44 /r 10]	VPCLMULQDQ,FUTURE
+VPCLMULHQHQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  vex.nds.256.66.0f3a.wig 44 /r 11]	VPCLMULQDQ,FUTURE
+VPCLMULQDQ	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:fv: vex.nds.256.66.0f3a.wig 44 /r ib]	VPCLMULQDQ,FUTURE
+
+; Intel VPCLMULQDQ + AVX512VL instructions
+VPCLMULLQLQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:fv:  evex.nds.128.66.0f3a.wig 44 /r 00]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULHQLQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:fv:  evex.nds.128.66.0f3a.wig 44 /r 01]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULLQHQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:fv:  evex.nds.128.66.0f3a.wig 44 /r 10]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULHQHQDQ	xmmreg,xmmreg*,xmmrm128		[rvm:fv:  evex.nds.128.66.0f3a.wig 44 /r 11]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULQDQ	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:fv: evex.nds.128.66.0f3a.wig 44 /r ib]	AVX512VL,VPCLMULQDQ,FUTURE
+
+VPCLMULLQLQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  evex.nds.256.66.0f3a.wig 44 /r 00]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULHQLQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  evex.nds.256.66.0f3a.wig 44 /r 01]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULLQHQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  evex.nds.256.66.0f3a.wig 44 /r 10]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULHQHQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:fv:  evex.nds.256.66.0f3a.wig 44 /r 11]	AVX512VL,VPCLMULQDQ,FUTURE
+VPCLMULQDQ	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:fv: evex.nds.256.66.0f3a.wig 44 /r ib]	AVX512VL,VPCLMULQDQ,FUTURE
+
+; Intel VPCLMULQDQ + AVX512F instructions
+VPCLMULLQLQDQ	zmmreg,zmmreg*,zmmrm512		[rvm:fv:  evex.nds.512.66.0f3a.wig 44 /r 00]	AVX512,VPCLMULQDQ,FUTURE
+VPCLMULHQLQDQ	zmmreg,zmmreg*,zmmrm512		[rvm:fv:  evex.nds.512.66.0f3a.wig 44 /r 01]	AVX512,VPCLMULQDQ,FUTURE
+VPCLMULLQHQDQ	zmmreg,zmmreg*,zmmrm512		[rvm:fv:  evex.nds.512.66.0f3a.wig 44 /r 10]	AVX512,VPCLMULQDQ,FUTURE
+VPCLMULHQHQDQ	zmmreg,zmmreg*,zmmrm512		[rvm:fv:  evex.nds.512.66.0f3a.wig 44 /r 11]	AVX512,VPCLMULQDQ,FUTURE
+VPCLMULQDQ	zmmreg,zmmreg*,zmmrm512,imm8	[rvmi:fv: evex.nds.512.66.0f3a.wig 44 /r ib]	AVX512,VPCLMULQDQ,FUTURE
+
+;# Intel Fused Multiply-Add instructions (FMA)
+VFMADD132PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 98 /r]		FMA,FUTURE
+VFMADD132PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 98 /r]		FMA,FUTURE
+VFMADD132PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 98 /r]		FMA,FUTURE
+VFMADD132PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 98 /r]		FMA,FUTURE
+VFMADD312PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 98 /r]		FMA,FUTURE
+VFMADD312PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 98 /r]		FMA,FUTURE
+VFMADD312PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 98 /r]		FMA,FUTURE
+VFMADD312PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 98 /r]		FMA,FUTURE
+VFMADD213PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 a8 /r]		FMA,FUTURE
+VFMADD213PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 a8 /r]		FMA,FUTURE
+VFMADD213PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 a8 /r]		FMA,FUTURE
+VFMADD213PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 a8 /r]		FMA,FUTURE
+VFMADD123PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 a8 /r]		FMA,FUTURE
+VFMADD123PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 a8 /r]		FMA,FUTURE
+VFMADD123PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 a8 /r]		FMA,FUTURE
+VFMADD123PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 a8 /r]		FMA,FUTURE
+VFMADD231PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 b8 /r]		FMA,FUTURE
+VFMADD231PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 b8 /r]		FMA,FUTURE
+VFMADD231PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 b8 /r]		FMA,FUTURE
+VFMADD231PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 b8 /r]		FMA,FUTURE
+VFMADD321PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 b8 /r]		FMA,FUTURE
+VFMADD321PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 b8 /r]		FMA,FUTURE
+VFMADD321PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 b8 /r]		FMA,FUTURE
+VFMADD321PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 b8 /r]		FMA,FUTURE
+VFMADDSUB132PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 96 /r]		FMA,FUTURE
+VFMADDSUB132PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 96 /r]		FMA,FUTURE
+VFMADDSUB132PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 96 /r]		FMA,FUTURE
+VFMADDSUB132PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 96 /r]		FMA,FUTURE
+VFMADDSUB312PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 96 /r]		FMA,FUTURE
+VFMADDSUB312PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 96 /r]		FMA,FUTURE
+VFMADDSUB312PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 96 /r]		FMA,FUTURE
+VFMADDSUB312PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 96 /r]		FMA,FUTURE
+VFMADDSUB213PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 a6 /r]		FMA,FUTURE
+VFMADDSUB213PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 a6 /r]		FMA,FUTURE
+VFMADDSUB213PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 a6 /r]		FMA,FUTURE
+VFMADDSUB213PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 a6 /r]		FMA,FUTURE
+VFMADDSUB123PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 a6 /r]		FMA,FUTURE
+VFMADDSUB123PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 a6 /r]		FMA,FUTURE
+VFMADDSUB123PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 a6 /r]		FMA,FUTURE
+VFMADDSUB123PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 a6 /r]		FMA,FUTURE
+VFMADDSUB231PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 b6 /r]		FMA,FUTURE
+VFMADDSUB231PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 b6 /r]		FMA,FUTURE
+VFMADDSUB231PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 b6 /r]		FMA,FUTURE
+VFMADDSUB231PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 b6 /r]		FMA,FUTURE
+VFMADDSUB321PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 b6 /r]		FMA,FUTURE
+VFMADDSUB321PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 b6 /r]		FMA,FUTURE
+VFMADDSUB321PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 b6 /r]		FMA,FUTURE
+VFMADDSUB321PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 b6 /r]		FMA,FUTURE
+VFMSUB132PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 9a /r]		FMA,FUTURE
+VFMSUB132PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 9a /r]		FMA,FUTURE
+VFMSUB132PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 9a /r]		FMA,FUTURE
+VFMSUB132PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 9a /r]		FMA,FUTURE
+VFMSUB312PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 9a /r]		FMA,FUTURE
+VFMSUB312PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 9a /r]		FMA,FUTURE
+VFMSUB312PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 9a /r]		FMA,FUTURE
+VFMSUB312PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 9a /r]		FMA,FUTURE
+VFMSUB213PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 aa /r]		FMA,FUTURE
+VFMSUB213PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 aa /r]		FMA,FUTURE
+VFMSUB213PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 aa /r]		FMA,FUTURE
+VFMSUB213PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 aa /r]		FMA,FUTURE
+VFMSUB123PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 aa /r]		FMA,FUTURE
+VFMSUB123PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 aa /r]		FMA,FUTURE
+VFMSUB123PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 aa /r]		FMA,FUTURE
+VFMSUB123PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 aa /r]		FMA,FUTURE
+VFMSUB231PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 ba /r]		FMA,FUTURE
+VFMSUB231PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 ba /r]		FMA,FUTURE
+VFMSUB231PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 ba /r]		FMA,FUTURE
+VFMSUB231PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 ba /r]		FMA,FUTURE
+VFMSUB321PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 ba /r]		FMA,FUTURE
+VFMSUB321PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 ba /r]		FMA,FUTURE
+VFMSUB321PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 ba /r]		FMA,FUTURE
+VFMSUB321PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 ba /r]		FMA,FUTURE
+VFMSUBADD132PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 97 /r]		FMA,FUTURE
+VFMSUBADD132PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 97 /r]		FMA,FUTURE
+VFMSUBADD132PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 97 /r]		FMA,FUTURE
+VFMSUBADD132PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 97 /r]		FMA,FUTURE
+VFMSUBADD312PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 97 /r]		FMA,FUTURE
+VFMSUBADD312PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 97 /r]		FMA,FUTURE
+VFMSUBADD312PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 97 /r]		FMA,FUTURE
+VFMSUBADD312PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 97 /r]		FMA,FUTURE
+VFMSUBADD213PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 a7 /r]		FMA,FUTURE
+VFMSUBADD213PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 a7 /r]		FMA,FUTURE
+VFMSUBADD213PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 a7 /r]		FMA,FUTURE
+VFMSUBADD213PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 a7 /r]		FMA,FUTURE
+VFMSUBADD123PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 a7 /r]		FMA,FUTURE
+VFMSUBADD123PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 a7 /r]		FMA,FUTURE
+VFMSUBADD123PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 a7 /r]		FMA,FUTURE
+VFMSUBADD123PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 a7 /r]		FMA,FUTURE
+VFMSUBADD231PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 b7 /r]		FMA,FUTURE
+VFMSUBADD231PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 b7 /r]		FMA,FUTURE
+VFMSUBADD231PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 b7 /r]		FMA,FUTURE
+VFMSUBADD231PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 b7 /r]		FMA,FUTURE
+VFMSUBADD321PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 b7 /r]		FMA,FUTURE
+VFMSUBADD321PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 b7 /r]		FMA,FUTURE
+VFMSUBADD321PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 b7 /r]		FMA,FUTURE
+VFMSUBADD321PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 b7 /r]		FMA,FUTURE
+VFNMADD132PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 9c /r]		FMA,FUTURE
+VFNMADD132PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 9c /r]		FMA,FUTURE
+VFNMADD132PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 9c /r]		FMA,FUTURE
+VFNMADD132PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 9c /r]		FMA,FUTURE
+VFNMADD312PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 9c /r]		FMA,FUTURE
+VFNMADD312PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 9c /r]		FMA,FUTURE
+VFNMADD312PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 9c /r]		FMA,FUTURE
+VFNMADD312PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 9c /r]		FMA,FUTURE
+VFNMADD213PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 ac /r]		FMA,FUTURE
+VFNMADD213PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 ac /r]		FMA,FUTURE
+VFNMADD213PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 ac /r]		FMA,FUTURE
+VFNMADD213PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 ac /r]		FMA,FUTURE
+VFNMADD123PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 ac /r]		FMA,FUTURE
+VFNMADD123PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 ac /r]		FMA,FUTURE
+VFNMADD123PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 ac /r]		FMA,FUTURE
+VFNMADD123PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 ac /r]		FMA,FUTURE
+VFNMADD231PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 bc /r]		FMA,FUTURE
+VFNMADD231PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 bc /r]		FMA,FUTURE
+VFNMADD231PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 bc /r]		FMA,FUTURE
+VFNMADD231PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 bc /r]		FMA,FUTURE
+VFNMADD321PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 bc /r]		FMA,FUTURE
+VFNMADD321PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 bc /r]		FMA,FUTURE
+VFNMADD321PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 bc /r]		FMA,FUTURE
+VFNMADD321PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 bc /r]		FMA,FUTURE
+VFNMSUB132PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 9e /r]		FMA,FUTURE
+VFNMSUB132PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 9e /r]		FMA,FUTURE
+VFNMSUB132PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 9e /r]		FMA,FUTURE
+VFNMSUB132PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 9e /r]		FMA,FUTURE
+VFNMSUB312PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 9e /r]		FMA,FUTURE
+VFNMSUB312PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 9e /r]		FMA,FUTURE
+VFNMSUB312PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 9e /r]		FMA,FUTURE
+VFNMSUB312PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 9e /r]		FMA,FUTURE
+VFNMSUB213PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 ae /r]		FMA,FUTURE
+VFNMSUB213PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 ae /r]		FMA,FUTURE
+VFNMSUB213PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 ae /r]		FMA,FUTURE
+VFNMSUB213PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 ae /r]		FMA,FUTURE
+VFNMSUB123PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 ae /r]		FMA,FUTURE
+VFNMSUB123PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 ae /r]		FMA,FUTURE
+VFNMSUB123PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 ae /r]		FMA,FUTURE
+VFNMSUB123PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 ae /r]		FMA,FUTURE
+VFNMSUB231PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 be /r]		FMA,FUTURE
+VFNMSUB231PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 be /r]		FMA,FUTURE
+VFNMSUB231PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 be /r]		FMA,FUTURE
+VFNMSUB231PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 be /r]		FMA,FUTURE
+VFNMSUB321PS	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w0 be /r]		FMA,FUTURE
+VFNMSUB321PS	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w0 be /r]		FMA,FUTURE
+VFNMSUB321PD	xmmreg,xmmreg,xmmrm128		[rvm:	vex.dds.128.66.0f38.w1 be /r]		FMA,FUTURE
+VFNMSUB321PD	ymmreg,ymmreg,ymmrm256		[rvm:	vex.dds.256.66.0f38.w1 be /r]		FMA,FUTURE
+VFMADD132SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 99 /r]		FMA,FUTURE
+VFMADD132SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 99 /r]		FMA,FUTURE
+VFMADD312SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 99 /r]		FMA,FUTURE
+VFMADD312SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 99 /r]		FMA,FUTURE
+VFMADD213SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 a9 /r]		FMA,FUTURE
+VFMADD213SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 a9 /r]		FMA,FUTURE
+VFMADD123SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 a9 /r]		FMA,FUTURE
+VFMADD123SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 a9 /r]		FMA,FUTURE
+VFMADD231SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 b9 /r]		FMA,FUTURE
+VFMADD231SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 b9 /r]		FMA,FUTURE
+VFMADD321SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 b9 /r]		FMA,FUTURE
+VFMADD321SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 b9 /r]		FMA,FUTURE
+VFMSUB132SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 9b /r]		FMA,FUTURE
+VFMSUB132SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 9b /r]		FMA,FUTURE
+VFMSUB312SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 9b /r]		FMA,FUTURE
+VFMSUB312SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 9b /r]		FMA,FUTURE
+VFMSUB213SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 ab /r]		FMA,FUTURE
+VFMSUB213SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 ab /r]		FMA,FUTURE
+VFMSUB123SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 ab /r]		FMA,FUTURE
+VFMSUB123SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 ab /r]		FMA,FUTURE
+VFMSUB231SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 bb /r]		FMA,FUTURE
+VFMSUB231SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 bb /r]		FMA,FUTURE
+VFMSUB321SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 bb /r]		FMA,FUTURE
+VFMSUB321SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 bb /r]		FMA,FUTURE
+VFNMADD132SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 9d /r]		FMA,FUTURE
+VFNMADD132SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 9d /r]		FMA,FUTURE
+VFNMADD312SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 9d /r]		FMA,FUTURE
+VFNMADD312SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 9d /r]		FMA,FUTURE
+VFNMADD213SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 ad /r]		FMA,FUTURE
+VFNMADD213SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 ad /r]		FMA,FUTURE
+VFNMADD123SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 ad /r]		FMA,FUTURE
+VFNMADD123SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 ad /r]		FMA,FUTURE
+VFNMADD231SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 bd /r]		FMA,FUTURE
+VFNMADD231SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 bd /r]		FMA,FUTURE
+VFNMADD321SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 bd /r]		FMA,FUTURE
+VFNMADD321SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 bd /r]		FMA,FUTURE
+VFNMSUB132SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 9f /r]		FMA,FUTURE
+VFNMSUB132SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 9f /r]		FMA,FUTURE
+VFNMSUB312SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 9f /r]		FMA,FUTURE
+VFNMSUB312SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 9f /r]		FMA,FUTURE
+VFNMSUB213SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 af /r]		FMA,FUTURE
+VFNMSUB213SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 af /r]		FMA,FUTURE
+VFNMSUB123SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 af /r]		FMA,FUTURE
+VFNMSUB123SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 af /r]		FMA,FUTURE
+VFNMSUB231SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 bf /r]		FMA,FUTURE
+VFNMSUB231SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 bf /r]		FMA,FUTURE
+VFNMSUB321SS	xmmreg,xmmreg,xmmrm32		[rvm:	vex.dds.128.66.0f38.w0 bf /r]		FMA,FUTURE
+VFNMSUB321SD	xmmreg,xmmreg,xmmrm64		[rvm:	vex.dds.128.66.0f38.w1 bf /r]		FMA,FUTURE
+
+;# Intel post-32 nm processor instructions
+;
+; Per AVX spec revision 7, document 319433-007
+RDFSBASE	reg32				[m:	norexw f3 0f ae /0]			LONG,FUTURE
+RDFSBASE	reg64				[m:	o64 f3 0f ae /0]			LONG,FUTURE
+RDGSBASE	reg32				[m:	norexw f3 0f ae /1]			LONG,FUTURE
+RDGSBASE	reg64				[m:	o64 f3 0f ae /1]			LONG,FUTURE
+RDRAND		reg16				[m:	o16 0f c7 /6]				FUTURE
+RDRAND		reg32				[m:	o32 0f c7 /6]				FUTURE
+RDRAND		reg64				[m:	o64 0f c7 /6]				LONG,FUTURE
+WRFSBASE	reg32				[m:	norexw f3 0f ae /2]			LONG,FUTURE
+WRFSBASE	reg64				[m:	o64 f3 0f ae /2]			LONG,FUTURE
+WRGSBASE	reg32				[m:	norexw f3 0f ae /3]			LONG,FUTURE
+WRGSBASE	reg64				[m:	o64 f3 0f ae /3]			LONG,FUTURE
+VCVTPH2PS	ymmreg,xmmrm128			[rm:	vex.256.66.0f38.w0 13 /r]		AVX,FUTURE
+VCVTPH2PS	xmmreg,xmmrm64			[rm:	vex.128.66.0f38.w0 13 /r]		AVX,FUTURE
+VCVTPS2PH	xmmrm128,ymmreg,imm8		[mri:	vex.256.66.0f3a.w0 1d /r ib]		AVX,FUTURE
+VCVTPS2PH	xmmrm64,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 1d /r ib]		AVX,FUTURE
+
+; Per AVX spec revision 13, document 319433-013
+ADCX		reg32,rm32			[rm:	norexw 66 0f 38 f6 /r]			FUTURE
+ADCX		reg64,rm64			[rm:	o64 66 0f 38 f6 /r]			LONG,FUTURE
+ADOX		reg32,rm32			[rm:	norexw f3 0f 38 f6 /r]			FUTURE
+ADOX		reg64,rm64			[rm:	o64 f3 0f 38 f6 /r]			LONG,FUTURE
+RDSEED		reg16				[m:	o16 0f c7 /7]				FUTURE
+RDSEED		reg32				[m:	o32 0f c7 /7]				FUTURE
+RDSEED		reg64				[m:	o64 0f c7 /7]				LONG,FUTURE
+
+; Per AVX spec revision 14, document 319433-014
+CLAC		void				[	0f 01 ca]				PRIV,FUTURE
+STAC		void				[	0f 01 cb]				PRIV,FUTURE
+
+;# VIA (Centaur) security instructions
+XSTORE		void				[	0f a7 c0]				PENT,CYRIX
+XCRYPTECB	void				[	mustrep 0f a7 c8]			PENT,CYRIX
+XCRYPTCBC	void				[	mustrep 0f a7 d0]			PENT,CYRIX
+XCRYPTCTR	void				[	mustrep 0f a7 d8]			PENT,CYRIX
+XCRYPTCFB	void				[	mustrep 0f a7 e0]			PENT,CYRIX
+XCRYPTOFB	void				[	mustrep 0f a7 e8]			PENT,CYRIX
+MONTMUL		void				[	mustrep 0f a6 c0]			PENT,CYRIX
+XSHA1		void				[	mustrep 0f a6 c8]			PENT,CYRIX
+XSHA256		void				[	mustrep 0f a6 d0]			PENT,CYRIX
+
+;# AMD Lightweight Profiling (LWP) instructions
+;
+; based on pub number 43724 revision 3.04 date August 2009
+;
+; updated to match draft from AMD developer (patch has been
+; sent to binutils
+; 2010-03-22 Quentin Neill <quentin.neill@amd.com>
+;	     Sebastian Pop  <sebastian.pop@amd.com>
+;
+LLWPCB		reg32				[m: xop.m9.w0.l0.p0 12 /0]			AMD,386
+LLWPCB		reg64				[m: xop.m9.w1.l0.p0 12 /0]			AMD,X86_64,LONG
+
+SLWPCB		reg32				[m: xop.m9.w0.l0.p0 12 /1]			AMD,386
+SLWPCB		reg64				[m: xop.m9.w1.l0.p0 12 /1]			AMD,X86_64,LONG
+
+LWPVAL		reg32,rm32,imm32		[vmi: xop.m10.w0.ndd.l0.p0 12 /1 id]		AMD,386
+LWPVAL		reg64,rm32,imm32		[vmi: xop.m10.w1.ndd.l0.p0 12 /1 id]		AMD,X86_64,LONG
+
+LWPINS		reg32,rm32,imm32		[vmi: xop.m10.w0.ndd.l0.p0 12 /0 id]		AMD,386
+LWPINS		reg64,rm32,imm32		[vmi: xop.m10.w1.ndd.l0.p0 12 /0 id]		AMD,X86_64,LONG
+
+;# AMD XOP and FMA4 instructions (SSE5)
+;
+; based on pub number 43479 revision 3.04 dated November 2009
+;
+VFMADDPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 69 /r /is4]		AMD,SSE5
+VFMADDPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 69 /r /is4]		AMD,SSE5
+VFMADDPD	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 69 /r /is4]		AMD,SSE5
+VFMADDPD	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 69 /r /is4]		AMD,SSE5
+
+VFMADDPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 68 /r /is4]		AMD,SSE5
+VFMADDPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 68 /r /is4]		AMD,SSE5
+VFMADDPS	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 68 /r /is4]		AMD,SSE5
+VFMADDPS	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 68 /r /is4]		AMD,SSE5
+
+VFMADDSD	xmmreg,xmmreg*,xmmrm64,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 6b /r /is4]		AMD,SSE5
+VFMADDSD	xmmreg,xmmreg*,xmmreg,xmmrm64	[rvsm:	vex.m3.w1.nds.l0.p1 6b /r /is4]		AMD,SSE5
+
+VFMADDSS	xmmreg,xmmreg*,xmmrm32,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 6a /r /is4]		AMD,SSE5
+VFMADDSS	xmmreg,xmmreg*,xmmreg,xmmrm32	[rvsm:	vex.m3.w1.nds.l0.p1 6a /r /is4]		AMD,SSE5
+
+VFMADDSUBPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 5d /r /is4]		AMD,SSE5
+VFMADDSUBPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 5d /r /is4]		AMD,SSE5
+VFMADDSUBPD	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 5d /r /is4]		AMD,SSE5
+VFMADDSUBPD	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 5d /r /is4]		AMD,SSE5
+
+VFMADDSUBPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 5c /r /is4]		AMD,SSE5
+VFMADDSUBPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 5c /r /is4]		AMD,SSE5
+VFMADDSUBPS	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 5c /r /is4]		AMD,SSE5
+VFMADDSUBPS	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 5c /r /is4]		AMD,SSE5
+
+VFMSUBADDPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 5f /r /is4]		AMD,SSE5
+VFMSUBADDPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 5f /r /is4]		AMD,SSE5
+VFMSUBADDPD	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 5f /r /is4]		AMD,SSE5
+VFMSUBADDPD	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 5f /r /is4]		AMD,SSE5
+
+VFMSUBADDPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 5e /r /is4]		AMD,SSE5
+VFMSUBADDPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 5e /r /is4]		AMD,SSE5
+VFMSUBADDPS	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 5e /r /is4]		AMD,SSE5
+VFMSUBADDPS	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 5e /r /is4]		AMD,SSE5
+
+VFMSUBPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 6d /r /is4]		AMD,SSE5
+VFMSUBPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 6d /r /is4]		AMD,SSE5
+VFMSUBPD	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 6d /r /is4]		AMD,SSE5
+VFMSUBPD	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 6d /r /is4]		AMD,SSE5
+
+VFMSUBPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 6c /r /is4]		AMD,SSE5
+VFMSUBPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 6c /r /is4]		AMD,SSE5
+VFMSUBPS	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 6c /r /is4]		AMD,SSE5
+VFMSUBPS	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 6c /r /is4]		AMD,SSE5
+
+VFMSUBSD	xmmreg,xmmreg*,xmmrm64,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 6f /r /is4]		AMD,SSE5
+VFMSUBSD	xmmreg,xmmreg*,xmmreg,xmmrm64	[rvsm:	vex.m3.w1.nds.l0.p1 6f /r /is4]		AMD,SSE5
+
+VFMSUBSS	xmmreg,xmmreg*,xmmrm32,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 6e /r /is4]		AMD,SSE5
+VFMSUBSS	xmmreg,xmmreg*,xmmreg,xmmrm32	[rvsm:	vex.m3.w1.nds.l0.p1 6e /r /is4]		AMD,SSE5
+
+VFNMADDPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 79 /r /is4]		AMD,SSE5
+VFNMADDPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 79 /r /is4]		AMD,SSE5
+VFNMADDPD	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 79 /r /is4]		AMD,SSE5
+VFNMADDPD	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 79 /r /is4]		AMD,SSE5
+
+VFNMADDPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 78 /r /is4]		AMD,SSE5
+VFNMADDPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 78 /r /is4]		AMD,SSE5
+VFNMADDPS	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 78 /r /is4]		AMD,SSE5
+VFNMADDPS	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 78 /r /is4]		AMD,SSE5
+
+VFNMADDSD	xmmreg,xmmreg*,xmmrm64,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 7b /r /is4]		AMD,SSE5
+VFNMADDSD	xmmreg,xmmreg*,xmmreg,xmmrm64	[rvsm:	vex.m3.w1.nds.l0.p1 7b /r /is4]		AMD,SSE5
+
+VFNMADDSS	xmmreg,xmmreg*,xmmrm32,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 7a /r /is4]		AMD,SSE5
+VFNMADDSS	xmmreg,xmmreg*,xmmreg,xmmrm32	[rvsm:	vex.m3.w1.nds.l0.p1 7a /r /is4]		AMD,SSE5
+
+VFNMSUBPD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 7d /r /is4]		AMD,SSE5
+VFNMSUBPD	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 7d /r /is4]		AMD,SSE5
+VFNMSUBPD	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 7d /r /is4]		AMD,SSE5
+VFNMSUBPD	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 7d /r /is4]		AMD,SSE5
+
+VFNMSUBPS	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 7c /r /is4]		AMD,SSE5
+VFNMSUBPS	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.m3.w0.nds.l1.p1 7c /r /is4]		AMD,SSE5
+VFNMSUBPS	xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	vex.m3.w1.nds.l0.p1 7c /r /is4]		AMD,SSE5
+VFNMSUBPS	ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	vex.m3.w1.nds.l1.p1 7c /r /is4]		AMD,SSE5
+
+VFNMSUBSD	xmmreg,xmmreg*,xmmrm64,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 7f /r /is4]		AMD,SSE5
+VFNMSUBSD	xmmreg,xmmreg*,xmmreg,xmmrm64	[rvsm:	vex.m3.w1.nds.l0.p1 7f /r /is4]		AMD,SSE5
+
+VFNMSUBSS	xmmreg,xmmreg*,xmmrm32,xmmreg	[rvms:	vex.m3.w0.nds.l0.p1 7e /r /is4]		AMD,SSE5
+VFNMSUBSS	xmmreg,xmmreg*,xmmreg,xmmrm32	[rvsm:	vex.m3.w1.nds.l0.p1 7e /r /is4]		AMD,SSE5
+
+VFRCZPD		xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 81 /r]			AMD,SSE5
+VFRCZPD		ymmreg,ymmrm256*		[rm:	xop.m9.w0.l1.p0 81 /r]			AMD,SSE5
+
+VFRCZPS		xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 80 /r]			AMD,SSE5
+VFRCZPS		ymmreg,ymmrm256*		[rm:	xop.m9.w0.l1.p0 80 /r]			AMD,SSE5
+
+VFRCZSD		xmmreg,xmmrm64*			[rm:	xop.m9.w0.l0.p0 83 /r]			AMD,SSE5
+
+VFRCZSS		xmmreg,xmmrm32*			[rm:	xop.m9.w0.l0.p0 82 /r]			AMD,SSE5
+;
+; fixed: spec mention imm[7:4] though it should be /is4 even in spec
+VPCMOV		xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 a2 /r /is4]		AMD,SSE5
+VPCMOV		ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	xop.m8.w0.nds.l1.p0 a2 /r /is4]		AMD,SSE5
+VPCMOV		xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	xop.m8.w1.nds.l0.p0 a2 /r /is4]		AMD,SSE5
+VPCMOV		ymmreg,ymmreg*,ymmreg,ymmrm256	[rvsm:	xop.m8.w1.nds.l1.p0 a2 /r /is4]		AMD,SSE5
+
+VPCOMB		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 cc /r ib]		AMD,SSE5
+VPCOMD		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 ce /r ib]		AMD,SSE5
+VPCOMQ		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 cf /r ib]		AMD,SSE5
+;
+; fixed: spec mention only 3 operands in mnemonics
+VPCOMUB		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 ec /r ib]		AMD,SSE5
+VPCOMUD		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 ee /r ib]		AMD,SSE5
+VPCOMUQ		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 ef /r ib]		AMD,SSE5
+;
+; fixed: spec point wrong VPCOMB in mnemonic
+VPCOMUW		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 ed /r ib]		AMD,SSE5
+VPCOMW		xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	xop.m8.w0.nds.l0.p0 cd /r ib]		AMD,SSE5
+
+VPHADDBD	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 c2 /r]			AMD,SSE5
+VPHADDBQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 c3 /r]			AMD,SSE5
+VPHADDBW	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 c1 /r]			AMD,SSE5
+VPHADDDQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 cb /r]			AMD,SSE5
+;
+; fixed: spec has ymmreg for l0
+VPHADDUBD	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 d2 /r]			AMD,SSE5
+VPHADDUBQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 d3 /r]			AMD,SSE5
+;
+; fixed: spec has VPHADDUBWD
+VPHADDUBW	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 d1 /r]			AMD,SSE5
+;
+; fixed: opcode db
+VPHADDUDQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 db /r]			AMD,SSE5
+VPHADDUWD	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 d6 /r]			AMD,SSE5
+VPHADDUWQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 d7 /r]			AMD,SSE5
+;
+; fixed: spec has ymmreg for l0
+VPHADDWD	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 c6 /r]			AMD,SSE5
+;
+; fixed: spec has d7 opcode
+VPHADDWQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 c7 /r]			AMD,SSE5
+
+VPHSUBBW	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 e1 /r]			AMD,SSE5
+VPHSUBDQ	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 e3 /r]			AMD,SSE5
+VPHSUBWD	xmmreg,xmmrm128*		[rm:	xop.m9.w0.l0.p0 e2 /r]			AMD,SSE5
+
+VPMACSDD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 9e /r /is4]		AMD,SSE5
+;
+; fixed: spec has 97,9f opcodes here
+VPMACSDQH	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 9f /r /is4]		AMD,SSE5
+VPMACSDQL	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 97 /r /is4]		AMD,SSE5
+VPMACSSDD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 8e /r /is4]		AMD,SSE5
+VPMACSSDQH	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 8f /r /is4]		AMD,SSE5
+VPMACSSDQL	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 87 /r /is4]		AMD,SSE5
+VPMACSSWD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 86 /r /is4]		AMD,SSE5
+VPMACSSWW	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 85 /r /is4]		AMD,SSE5
+VPMACSWD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 96 /r /is4]		AMD,SSE5
+VPMACSWW	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 95 /r /is4]		AMD,SSE5
+VPMADCSSWD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 a6 /r /is4]		AMD,SSE5
+VPMADCSWD	xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 b6 /r /is4]		AMD,SSE5
+
+VPPERM		xmmreg,xmmreg*,xmmreg,xmmrm128	[rvsm:	xop.m8.w1.nds.l0.p0 a3 /r /is4]		AMD,SSE5
+VPPERM		xmmreg,xmmreg*,xmmrm128,xmmreg	[rvms:	xop.m8.w0.nds.l0.p0 a3 /r /is4]		AMD,SSE5
+
+VPROTB		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 90 /r]		AMD,SSE5
+VPROTB		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 90 /r]		AMD,SSE5
+;
+; fixed: spec point xmmreg instead of reg/mem
+VPROTB		xmmreg,xmmrm128*,imm8		[rmi:	xop.m8.w0.l0.p0 c0 /r ib]		AMD,SSE5
+
+VPROTD		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 92 /r]		AMD,SSE5
+VPROTD		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 92 /r]		AMD,SSE5
+;
+; fixed: spec error /r is needed
+VPROTD		xmmreg,xmmrm128*,imm8		[rmi:	xop.m8.w0.l0.p0 c2 /r ib]		AMD,SSE5
+VPROTQ		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 93 /r]		AMD,SSE5
+VPROTQ		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 93 /r]		AMD,SSE5
+;
+; fixed: spec error /r is needed
+VPROTQ		xmmreg,xmmrm128*,imm8		[rmi:	xop.m8.w0.l0.p0 c3 /r ib]		AMD,SSE5
+VPROTW		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 91 /r]		AMD,SSE5
+VPROTW		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 91 /r]		AMD,SSE5
+VPROTW		xmmreg,xmmrm128*,imm8		[rmi:	xop.m8.w0.l0.p0 c1 /r ib]		AMD,SSE5
+
+VPSHAB		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 98 /r]		AMD,SSE5
+VPSHAB		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 98 /r]		AMD,SSE5
+
+VPSHAD		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 9a /r]		AMD,SSE5
+VPSHAD		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 9a /r]		AMD,SSE5
+
+VPSHAQ		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 9b /r]		AMD,SSE5
+VPSHAQ		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 9b /r]		AMD,SSE5
+
+VPSHAW		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 99 /r]		AMD,SSE5
+VPSHAW		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 99 /r]		AMD,SSE5
+
+VPSHLB		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 94 /r]		AMD,SSE5
+VPSHLB		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 94 /r]		AMD,SSE5
+
+;
+; fixed: spec has ymmreg for l0
+VPSHLD		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 96 /r]		AMD,SSE5
+VPSHLD		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 96 /r]		AMD,SSE5
+
+VPSHLQ		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 97 /r]		AMD,SSE5
+VPSHLQ		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 97 /r]		AMD,SSE5
+
+VPSHLW		xmmreg,xmmrm128*,xmmreg		[rmv:	xop.m9.w0.nds.l0.p0 95 /r]		AMD,SSE5
+VPSHLW		xmmreg,xmmreg*,xmmrm128		[rvm:	xop.m9.w1.nds.l0.p0 95 /r]		AMD,SSE5
+
+;# Intel AVX2 instructions
+;
+; based on pub number 319433-011 dated July 2011
+;
+VMPSADBW	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a 42 /r ib]		FUTURE,AVX2
+VPABSB		ymmreg,ymmrm256			[rm:	vex.256.66.0f38 1c /r]			FUTURE,AVX2
+VPABSW		ymmreg,ymmrm256			[rm:	vex.256.66.0f38 1d /r]			FUTURE,AVX2
+VPABSD		ymmreg,ymmrm256			[rm:	vex.256.66.0f38 1e /r]			FUTURE,AVX2
+VPACKSSWB	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 63 /r]		FUTURE,AVX2
+VPACKSSDW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 6b /r]		FUTURE,AVX2
+VPACKUSDW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 2b /r]		FUTURE,AVX2
+VPACKUSWB	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 67 /r]		FUTURE,AVX2
+VPADDB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f fc /r]		FUTURE,AVX2
+VPADDW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f fd /r]		FUTURE,AVX2
+VPADDD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f fe /r]		FUTURE,AVX2
+VPADDQ		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f d4 /r]		FUTURE,AVX2
+VPADDSB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f ec /r]		FUTURE,AVX2
+VPADDSW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f ed /r]		FUTURE,AVX2
+VPADDUSB	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f dc /r]		FUTURE,AVX2
+VPADDUSW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f dd /r]		FUTURE,AVX2
+VPALIGNR	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a 0f /r ib]		FUTURE,AVX2
+VPAND		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f db /r]		FUTURE,AVX2
+VPANDN		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f df /r]		FUTURE,AVX2
+VPAVGB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f e0 /r]		FUTURE,AVX2
+VPAVGW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f e3 /r]		FUTURE,AVX2
+VPBLENDVB	ymmreg,ymmreg*,ymmrm256,ymmreg	[rvms:	vex.nds.256.66.0f3a 4c /r /is4]		FUTURE,AVX2
+VPBLENDW	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a 0e /r ib]		FUTURE,AVX2
+VPCMPEQB	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 74 /r]		FUTURE,AVX2
+VPCMPEQW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 75 /r]		FUTURE,AVX2
+VPCMPEQD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 76 /r]		FUTURE,AVX2
+VPCMPEQQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 29 /r]		FUTURE,AVX2
+VPCMPGTB	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 64 /r]		FUTURE,AVX2
+VPCMPGTW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 65 /r]		FUTURE,AVX2
+VPCMPGTD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 66 /r]		FUTURE,AVX2
+VPCMPGTQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 37 /r]		FUTURE,AVX2
+VPHADDW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 01 /r]		FUTURE,AVX2
+VPHADDD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 02 /r]		FUTURE,AVX2
+VPHADDSW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 03 /r]		FUTURE,AVX2
+VPHSUBW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 05 /r]		FUTURE,AVX2
+VPHSUBD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 06 /r]		FUTURE,AVX2
+VPHSUBSW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 07 /r]		FUTURE,AVX2
+VPMADDUBSW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 04 /r]		FUTURE,AVX2
+VPMADDWD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f f5 /r]		FUTURE,AVX2
+VPMAXSB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 3c /r]		FUTURE,AVX2
+VPMAXSW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f ee /r]		FUTURE,AVX2
+VPMAXSD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 3d /r]		FUTURE,AVX2
+VPMAXUB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f de /r]		FUTURE,AVX2
+VPMAXUW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 3e /r]		FUTURE,AVX2
+VPMAXUD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 3f /r]		FUTURE,AVX2
+VPMINSB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 38 /r]		FUTURE,AVX2
+VPMINSW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f ea /r]		FUTURE,AVX2
+VPMINSD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 39 /r]		FUTURE,AVX2
+VPMINUB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f da /r]		FUTURE,AVX2
+VPMINUW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 3a /r]		FUTURE,AVX2
+VPMINUD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 3b /r]		FUTURE,AVX2
+VPMOVMSKB	reg32,ymmreg			[rm:	vex.256.66.0f d7 /r]			FUTURE,AVX2
+VPMOVMSKB	reg64,ymmreg			[rm:	vex.256.66.0f d7 /r]			FUTURE,AVX2
+VPMOVSXBW	ymmreg,xmmrm128			[rm:	vex.256.66.0f38 20 /r]			FUTURE,AVX2
+VPMOVSXBD	ymmreg,mem64			[rm:	vex.256.66.0f38 21 /r]			FUTURE,AVX2
+VPMOVSXBD	ymmreg,xmmreg			[rm:	vex.256.66.0f38 21 /r]			FUTURE,AVX2
+VPMOVSXBQ	ymmreg,mem32			[rm:	vex.256.66.0f38 22 /r]			FUTURE,AVX2
+VPMOVSXBQ	ymmreg,xmmreg			[rm:	vex.256.66.0f38 22 /r]			FUTURE,AVX2
+VPMOVSXWD	ymmreg,xmmrm128			[rm:	vex.256.66.0f38 23 /r]			FUTURE,AVX2
+VPMOVSXWQ	ymmreg,mem64			[rm:	vex.256.66.0f38 24 /r]			FUTURE,AVX2
+VPMOVSXWQ	ymmreg,xmmreg			[rm:	vex.256.66.0f38 24 /r]			FUTURE,AVX2
+VPMOVSXDQ	ymmreg,xmmrm128			[rm:	vex.256.66.0f38 25 /r]			FUTURE,AVX2
+VPMOVZXBW	ymmreg,xmmrm128			[rm:	vex.256.66.0f38 30 /r]			FUTURE,AVX2
+VPMOVZXBD	ymmreg,mem64			[rm:	vex.256.66.0f38 31 /r]			FUTURE,AVX2
+VPMOVZXBD	ymmreg,xmmreg			[rm:	vex.256.66.0f38 31 /r]			FUTURE,AVX2
+VPMOVZXBQ	ymmreg,mem32			[rm:	vex.256.66.0f38 32 /r]			FUTURE,AVX2
+VPMOVZXBQ	ymmreg,xmmreg			[rm:	vex.256.66.0f38 32 /r]			FUTURE,AVX2
+VPMOVZXWD	ymmreg,xmmrm128			[rm:	vex.256.66.0f38 33 /r]			FUTURE,AVX2
+VPMOVZXWQ	ymmreg,mem64			[rm:	vex.256.66.0f38 34 /r]			FUTURE,AVX2
+VPMOVZXWQ	ymmreg,xmmreg			[rm:	vex.256.66.0f38 34 /r]			FUTURE,AVX2
+VPMOVZXDQ	ymmreg,xmmrm128			[rm:	vex.256.66.0f38 35 /r]			FUTURE,AVX2
+VPMULDQ		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 28 /r]		FUTURE,AVX2
+VPMULHRSW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 0b /r]		FUTURE,AVX2
+VPMULHUW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f e4 /r]		FUTURE,AVX2
+VPMULHW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f e5 /r]		FUTURE,AVX2
+VPMULLW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f d5 /r]		FUTURE,AVX2
+VPMULLD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 40 /r]		FUTURE,AVX2
+VPMULUDQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f f4 /r]		FUTURE,AVX2
+VPOR		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f eb /r]		FUTURE,AVX2
+VPSADBW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f f6 /r]		FUTURE,AVX2
+VPSHUFB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 00 /r]		FUTURE,AVX2
+VPSHUFD		ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f 70 /r ib]			FUTURE,AVX2
+VPSHUFHW	ymmreg,ymmrm256,imm8		[rmi:	vex.256.f3.0f 70 /r ib]			FUTURE,AVX2
+VPSHUFLW	ymmreg,ymmrm256,imm8		[rmi:	vex.256.f2.0f 70 /r ib]			FUTURE,AVX2
+VPSIGNB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 08 /r]		FUTURE,AVX2
+VPSIGNW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 09 /r]		FUTURE,AVX2
+VPSIGND		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38 0a /r]		FUTURE,AVX2
+VPSLLDQ		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 73 /7 ib]		FUTURE,AVX2
+VPSLLW		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f f1 /r]		FUTURE,AVX2
+VPSLLW		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 71 /6 ib]		FUTURE,AVX2
+VPSLLD		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f f2 /r]		FUTURE,AVX2
+VPSLLD		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 72 /6 ib]		FUTURE,AVX2
+VPSLLQ		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f f3 /r]		FUTURE,AVX2
+VPSLLQ		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 73 /6 ib]		FUTURE,AVX2
+VPSRAW		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f e1 /r]		FUTURE,AVX2
+VPSRAW		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 71 /4 ib]		FUTURE,AVX2
+VPSRAD		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f e2 /r]		FUTURE,AVX2
+VPSRAD		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 72 /4 ib]		FUTURE,AVX2
+VPSRLDQ		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 73 /3 ib]		FUTURE,AVX2
+VPSRLW		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f d1 /r]		FUTURE,AVX2
+VPSRLW		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 71 /2 ib]		FUTURE,AVX2
+VPSRLD		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f d2 /r]		FUTURE,AVX2
+VPSRLD		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f 72 /2 ib]		FUTURE,AVX2
+VPSRLQ		ymmreg,ymmreg*,xmmrm128		[rvm:	vex.nds.256.66.0f d3 /r]		FUTURE,AVX2
+VPSRLQ		ymmreg,ymmreg*,imm8		[vmi:	vex.ndd.256.66.0f.wig 73 /2 ib]		FUTURE,AVX2
+VPSUBB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f f8 /r]		FUTURE,AVX2
+VPSUBW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f f9 /r]		FUTURE,AVX2
+VPSUBD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f fa /r]		FUTURE,AVX2
+VPSUBQ		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f fb /r]		FUTURE,AVX2
+VPSUBSB		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f e8 /r]		FUTURE,AVX2
+VPSUBSW		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f e9 /r]		FUTURE,AVX2
+VPSUBUSB	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f d8 /r]		FUTURE,AVX2
+VPSUBUSW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f d9 /r]		FUTURE,AVX2
+VPUNPCKHBW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 68 /r]		FUTURE,AVX2
+VPUNPCKHWD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 69 /r]		FUTURE,AVX2
+VPUNPCKHDQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 6a /r]		FUTURE,AVX2
+VPUNPCKHQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 6d /r]		FUTURE,AVX2
+VPUNPCKLBW	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 60 /r]		FUTURE,AVX2
+VPUNPCKLWD	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 61 /r]		FUTURE,AVX2
+VPUNPCKLDQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 62 /r]		FUTURE,AVX2
+VPUNPCKLQDQ	ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f 6c /r]		FUTURE,AVX2
+VPXOR		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f ef /r]		FUTURE,AVX2
+VMOVNTDQA	ymmreg,mem256			[rm:	vex.256.66.0f38 2a /r]			FUTURE,AVX2
+VBROADCASTSS	xmmreg,xmmreg			[rm:	vex.128.66.0f38.w0 18 /r]		FUTURE,AVX2
+VBROADCASTSS	ymmreg,xmmreg			[rm:	vex.256.66.0f38.w0 18 /r]		FUTURE,AVX2
+VBROADCASTSD	ymmreg,xmmreg			[rm:	vex.256.66.0f38.w0 19 /r]		FUTURE,AVX2
+VBROADCASTI128	ymmreg,mem128			[rm:	vex.256.66.0f38.w0 5a /r]		FUTURE,AVX2
+VPBLENDD	xmmreg,xmmreg*,xmmrm128,imm8	[rvmi:	vex.nds.128.66.0f3a.w0 02 /r ib]	FUTURE,AVX2
+VPBLENDD	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a.w0 02 /r ib]	FUTURE,AVX2
+VPBROADCASTB	xmmreg,mem8			[rm:	vex.128.66.0f38.w0 78 /r]		FUTURE,AVX2
+VPBROADCASTB	xmmreg,xmmreg			[rm:	vex.128.66.0f38.w0 78 /r]		FUTURE,AVX2
+VPBROADCASTB	ymmreg,mem8			[rm:	vex.256.66.0f38.w0 78 /r]		FUTURE,AVX2
+VPBROADCASTB	ymmreg,xmmreg			[rm:	vex.256.66.0f38.w0 78 /r]		FUTURE,AVX2
+VPBROADCASTW	xmmreg,mem16			[rm:	vex.128.66.0f38.w0 79 /r]		FUTURE,AVX2
+VPBROADCASTW	xmmreg,xmmreg			[rm:	vex.128.66.0f38.w0 79 /r]		FUTURE,AVX2
+VPBROADCASTW	ymmreg,mem16			[rm:	vex.256.66.0f38.w0 79 /r]		FUTURE,AVX2
+VPBROADCASTW	ymmreg,xmmreg			[rm:	vex.256.66.0f38.w0 79 /r]		FUTURE,AVX2
+VPBROADCASTD	xmmreg,mem32			[rm:	vex.128.66.0f38.w0 58 /r]		FUTURE,AVX2
+VPBROADCASTD	xmmreg,xmmreg			[rm:	vex.128.66.0f38.w0 58 /r]		FUTURE,AVX2
+VPBROADCASTD	ymmreg,mem32			[rm:	vex.256.66.0f38.w0 58 /r]		FUTURE,AVX2
+VPBROADCASTD	ymmreg,xmmreg			[rm:	vex.256.66.0f38.w0 58 /r]		FUTURE,AVX2
+VPBROADCASTQ	xmmreg,mem64			[rm:	vex.128.66.0f38.w0 59 /r]		FUTURE,AVX2
+VPBROADCASTQ	xmmreg,xmmreg			[rm:	vex.128.66.0f38.w0 59 /r]		FUTURE,AVX2
+VPBROADCASTQ	ymmreg,mem64			[rm:	vex.256.66.0f38.w0 59 /r]		FUTURE,AVX2
+VPBROADCASTQ	ymmreg,xmmreg			[rm:	vex.256.66.0f38.w0 59 /r]		FUTURE,AVX2
+
+VPERMD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 36 /r]		FUTURE,AVX2
+VPERMPD		ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f3a.w1 01 /r ib]		FUTURE,AVX2
+VPERMPS		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 16 /r]		FUTURE,AVX2
+VPERMQ		ymmreg,ymmrm256,imm8		[rmi:	vex.256.66.0f3a.w1 00 /r ib]		FUTURE,AVX2
+VPERM2I128	ymmreg,ymmreg*,ymmrm256,imm8	[rvmi:	vex.nds.256.66.0f3a.w0 46 /r ib]	FUTURE,AVX2
+VEXTRACTI128	xmmrm128,ymmreg,imm8		[mri:	vex.256.66.0f3a.w0 39 /r ib]		FUTURE,AVX2
+
+VINSERTI128	ymmreg,ymmreg*,xmmrm128,imm8	[rvmi:	vex.nds.256.66.0f3a.w0 38 /r ib]	FUTURE,AVX2
+VPMASKMOVD	xmmreg,xmmreg*,mem128		[rvm:	vex.nds.128.66.0f38.w0 8c /r]		FUTURE,AVX2
+VPMASKMOVD	ymmreg,ymmreg*,mem256		[rvm:	vex.nds.256.66.0f38.w0 8c /r]		FUTURE,AVX2
+VPMASKMOVQ	xmmreg,xmmreg*,mem128		[rvm:	vex.nds.128.66.0f38.w1 8c /r]		FUTURE,AVX2
+VPMASKMOVQ	ymmreg,ymmreg*,mem256		[rvm:	vex.nds.256.66.0f38.w1 8c /r]		FUTURE,AVX2
+
+VPMASKMOVD	mem128,xmmreg*,xmmreg		[mvr:	vex.nds.128.66.0f38.w0 8e /r]		FUTURE,AVX2
+VPMASKMOVD	mem256,ymmreg*,ymmreg		[mvr:	vex.nds.256.66.0f38.w0 8e /r]		FUTURE,AVX2
+VPMASKMOVQ	mem128,xmmreg*,xmmreg		[mvr:	vex.nds.128.66.0f38.w1 8e /r]		FUTURE,AVX2
+VPMASKMOVQ	mem256,ymmreg*,ymmreg		[mvr:	vex.nds.256.66.0f38.w1 8e /r]		FUTURE,AVX2
+
+VPSLLVD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w0 47 /r]		FUTURE,AVX2
+VPSLLVQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w1 47 /r]		FUTURE,AVX2
+VPSLLVD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 47 /r]		FUTURE,AVX2
+VPSLLVQ		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w1 47 /r]		FUTURE,AVX2
+
+VPSRAVD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w0 46 /r]		FUTURE,AVX2
+VPSRAVD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 46 /r]		FUTURE,AVX2
+
+VPSRLVD		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w0 45 /r]		FUTURE,AVX2
+VPSRLVQ		xmmreg,xmmreg*,xmmrm128		[rvm:	vex.nds.128.66.0f38.w1 45 /r]		FUTURE,AVX2
+VPSRLVD		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w0 45 /r]		FUTURE,AVX2
+VPSRLVQ		ymmreg,ymmreg*,ymmrm256		[rvm:	vex.nds.256.66.0f38.w1 45 /r]		FUTURE,AVX2
+
+VGATHERDPD	xmmreg,xmem64,xmmreg		[rmv:	vm32x vex.dds.128.66.0f38.w1 92 /r]	FUTURE,AVX2
+VGATHERQPD	xmmreg,xmem64,xmmreg		[rmv:	vm64x vex.dds.128.66.0f38.w1 93 /r]	FUTURE,AVX2
+VGATHERDPD	ymmreg,xmem64,ymmreg		[rmv:	vm32x vex.dds.256.66.0f38.w1 92 /r]	FUTURE,AVX2
+VGATHERQPD	ymmreg,ymem64,ymmreg		[rmv:	vm64y vex.dds.256.66.0f38.w1 93 /r]	FUTURE,AVX2
+
+VGATHERDPS	xmmreg,xmem32,xmmreg		[rmv:	vm32x vex.dds.128.66.0f38.w0 92 /r]	FUTURE,AVX2
+VGATHERQPS	xmmreg,xmem32,xmmreg		[rmv:	vm64x vex.dds.128.66.0f38.w0 93 /r]	FUTURE,AVX2
+VGATHERDPS	ymmreg,ymem32,ymmreg		[rmv:	vm32y vex.dds.256.66.0f38.w0 92 /r]	FUTURE,AVX2
+VGATHERQPS	xmmreg,ymem32,xmmreg		[rmv:	vm64y vex.dds.256.66.0f38.w0 93 /r]	FUTURE,AVX2
+
+VPGATHERDD	xmmreg,xmem32,xmmreg		[rmv:	vm32x vex.dds.128.66.0f38.w0 90 /r]	FUTURE,AVX2
+VPGATHERQD	xmmreg,xmem32,xmmreg		[rmv:	vm64x vex.dds.128.66.0f38.w0 91 /r]	FUTURE,AVX2
+VPGATHERDD	ymmreg,ymem32,ymmreg		[rmv:	vm32y vex.dds.256.66.0f38.w0 90 /r]	FUTURE,AVX2
+VPGATHERQD	xmmreg,ymem32,xmmreg		[rmv:	vm64y vex.dds.256.66.0f38.w0 91 /r]	FUTURE,AVX2
+
+VPGATHERDQ	xmmreg,xmem64,xmmreg		[rmv:	vm32x vex.dds.128.66.0f38.w1 90 /r]	FUTURE,AVX2
+VPGATHERQQ	xmmreg,xmem64,xmmreg		[rmv:	vm64x vex.dds.128.66.0f38.w1 91 /r]	FUTURE,AVX2
+VPGATHERDQ	ymmreg,xmem64,ymmreg		[rmv:	vm32x vex.dds.256.66.0f38.w1 90 /r]	FUTURE,AVX2
+VPGATHERQQ	ymmreg,ymem64,ymmreg		[rmv:	vm64y vex.dds.256.66.0f38.w1 91 /r]	FUTURE,AVX2
+
+;# Intel Transactional Synchronization Extensions (TSX)
+XABORT		imm				[i:	c6 f8 ib]				FUTURE,RTM
+XABORT		imm8				[i:	c6 f8 ib]				FUTURE,RTM
+XBEGIN		imm				[i:	odf c7 f8 rel]				FUTURE,RTM
+XBEGIN		imm|near			[i:	odf c7 f8 rel]				FUTURE,RTM,ND
+XBEGIN		imm16				[i:	o16 c7 f8 rel]				FUTURE,RTM,NOLONG
+XBEGIN		imm16|near			[i:	o16 c7 f8 rel]				FUTURE,RTM,NOLONG,ND
+XBEGIN		imm32				[i:	o32 c7 f8 rel]				FUTURE,RTM,NOLONG
+XBEGIN		imm32|near			[i:	o32 c7 f8 rel]				FUTURE,RTM,NOLONG,ND
+XBEGIN		imm64				[i:	o64nw c7 f8 rel]				FUTURE,RTM,LONG
+XBEGIN		imm64|near			[i:	o64nw c7 f8 rel]				FUTURE,RTM,LONG,ND
+XEND		void				[	0f 01 d5]				FUTURE,RTM
+XTEST		void				[	0f 01 d6]				FUTURE,HLE,RTM
+
+;# Intel BMI1 and BMI2 instructions, AMD TBM instructions
+;
+; based on pub number 319433-011 dated July 2011
+;
+ANDN		reg32,reg32,rm32		[rvm:	vex.nds.lz.0f38.w0 f2 /r]		FUTURE,BMI1
+ANDN		reg64,reg64,rm64		[rvm:	vex.nds.lz.0f38.w1 f2 /r]		LONG,FUTURE,BMI1
+BEXTR		reg32,rm32,reg32		[rmv:	vex.nds.lz.0f38.w0 f7 /r]		FUTURE,BMI1
+BEXTR		reg64,rm64,reg64		[rmv:	vex.nds.lz.0f38.w1 f7 /r]		LONG,FUTURE,BMI1
+BEXTR		reg32,rm32,imm32		[rmi:	xop.m10.lz.w0 10 /r id]			FUTURE,TBM
+BEXTR		reg64,rm64,imm32		[rmi:	xop.m10.lz.w1 10 /r id]			LONG,FUTURE,TBM
+BLCI		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 02 /6]			FUTURE,TBM
+BLCI		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 02 /6]			LONG,FUTURE,TBM
+BLCIC		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /5]			FUTURE,TBM
+BLCIC		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /5]			LONG,FUTURE,TBM
+BLSI		reg32,rm32			[vm:	vex.ndd.lz.0f38.w0 f3 /3]		FUTURE,BMI1
+BLSI		reg64,rm64			[vm:	vex.ndd.lz.0f38.w1 f3 /3]		LONG,FUTURE,BMI1
+BLSIC		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /6]			FUTURE,TBM
+BLSIC		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /6]			LONG,FUTURE,TBM
+BLCFILL		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /1]			FUTURE,TBM
+BLCFILL		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /1]			LONG,FUTURE,TBM
+BLSFILL		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /2]			FUTURE,TBM
+BLSFILL		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /2]			LONG,FUTURE,TBM
+BLCMSK		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 02 /1]			FUTURE,TBM
+BLCMSK		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 02 /1]			LONG,FUTURE,TBM
+BLSMSK		reg32,rm32			[vm:	vex.ndd.lz.0f38.w0 f3 /2]		FUTURE,BMI1
+BLSMSK		reg64,rm64			[vm:	vex.ndd.lz.0f38.w1 f3 /2]		LONG,FUTURE,BMI1
+BLSR		reg32,rm32			[vm:	vex.ndd.lz.0f38.w0 f3 /1]		FUTURE,BMI1
+BLSR		reg64,rm64			[vm:	vex.ndd.lz.0f38.w1 f3 /1]		LONG,FUTURE,BMI1
+BLCS		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /3]			FUTURE,TBM
+BLCS		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /3]			LONG,FUTURE,TBM
+BZHI		reg32,rm32,reg32		[rmv:	vex.nds.lz.0f38.w0 f5 /r]		FUTURE,BMI2
+BZHI		reg64,rm64,reg64		[rmv:	vex.nds.lz.0f38.w1 f5 /r]		LONG,FUTURE,BMI2
+MULX		reg32,reg32,rm32		[rvm:	vex.ndd.lz.f2.0f38.w0 f6 /r]		FUTURE,BMI2
+MULX		reg64,reg64,rm64		[rvm:	vex.ndd.lz.f2.0f38.w1 f6 /r]		LONG,FUTURE,BMI2
+PDEP		reg32,reg32,rm32		[rvm:	vex.nds.lz.f2.0f38.w0 f5 /r]		FUTURE,BMI2
+PDEP		reg64,reg64,rm64		[rvm:	vex.nds.lz.f2.0f38.w1 f5 /r]		LONG,FUTURE,BMI2
+PEXT		reg32,reg32,rm32		[rvm:	vex.nds.lz.f3.0f38.w0 f5 /r]		FUTURE,BMI2
+PEXT		reg64,reg64,rm64		[rvm:	vex.nds.lz.f3.0f38.w1 f5 /r]		LONG,FUTURE,BMI2
+RORX		reg32,rm32,imm8			[rmi:	vex.lz.f2.0f3a.w0 f0 /r ib]		FUTURE,BMI2
+RORX		reg64,rm64,imm8			[rmi:	vex.lz.f2.0f3a.w1 f0 /r ib]		LONG,FUTURE,BMI2
+SARX		reg32,rm32,reg32		[rmv:	vex.nds.lz.f3.0f38.w0 f7 /r]		FUTURE,BMI2
+SARX		reg64,rm64,reg64		[rmv:	vex.nds.lz.f3.0f38.w1 f7 /r]		LONG,FUTURE,BMI2
+SHLX		reg32,rm32,reg32		[rmv:	vex.nds.lz.66.0f38.w0 f7 /r]		FUTURE,BMI2
+SHLX		reg64,rm64,reg64		[rmv:	vex.nds.lz.66.0f38.w1 f7 /r]		LONG,FUTURE,BMI2
+SHRX		reg32,rm32,reg32		[rmv:	vex.nds.lz.f2.0f38.w0 f7 /r]		FUTURE,BMI2
+SHRX		reg64,rm64,reg64		[rmv:	vex.nds.lz.f2.0f38.w1 f7 /r]		LONG,FUTURE,BMI2
+TZCNT		reg16,rm16			[rm:	o16 f3i 0f bc /r]			FUTURE,BMI1
+TZCNT		reg32,rm32			[rm:	o32 f3i 0f bc /r]			FUTURE,BMI1
+TZCNT		reg64,rm64			[rm:	o64 f3i 0f bc /r]			LONG,FUTURE,BMI1
+TZMSK		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /4]			FUTURE,TBM
+TZMSK		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /4]			LONG,FUTURE,TBM
+T1MSKC		reg32,rm32			[vm:	xop.ndd.lz.m9.w0 01 /7]			FUTURE,TBM
+T1MSKC		reg64,rm64			[vm:	xop.ndd.lz.m9.w1 01 /7]			LONG,FUTURE,TBM
+
+PREFETCHWT1     mem8         [m:                               0f 0d /2 ]  PREFETCHWT1,FUTURE
+
+;# Intel Memory Protection Extensions (MPX)
+BNDMK       bndreg,mem             [rm:         f3 0f 1b /r ]  MPX,MIB,FUTURE
+BNDCL       bndreg,mem             [rm:         f3 0f 1a /r ]  MPX,FUTURE
+BNDCL       bndreg,reg32           [rm:         f3 0f 1a /r ]  MPX,NOLONG,FUTURE
+BNDCL       bndreg,reg64           [rm:   o64nw f3 0f 1a /r ]  MPX,LONG,FUTURE
+BNDCU       bndreg,mem             [rm:         f2 0f 1a /r ]  MPX,FUTURE
+BNDCU       bndreg,reg32           [rm:         f2 0f 1a /r ]  MPX,NOLONG,FUTURE
+BNDCU       bndreg,reg64           [rm:   o64nw f2 0f 1a /r ]  MPX,LONG,FUTURE
+BNDCN       bndreg,mem             [rm:         f2 0f 1b /r ]  MPX,FUTURE
+BNDCN       bndreg,reg32           [rm:         f2 0f 1b /r ]  MPX,NOLONG,FUTURE
+BNDCN       bndreg,reg64           [rm:   o64nw f2 0f 1b /r ]  MPX,LONG,FUTURE
+BNDMOV      bndreg,bndreg          [rm:         66 0f 1a /r ]  MPX,FUTURE
+BNDMOV      bndreg,mem             [rm:         66 0f 1a /r ]  MPX,FUTURE
+BNDMOV      bndreg,bndreg          [mr:         66 0f 1b /r ]  MPX,FUTURE
+BNDMOV      mem,bndreg             [mr:         66 0f 1b /r ]  MPX,FUTURE
+BNDLDX      bndreg,mem             [rm:            0f 1a /r ]  MPX,MIB,FUTURE
+BNDLDX      bndreg,mem,reg32       [rmx:           0f 1a /r ]  MPX,MIB,NOLONG,FUTURE
+BNDLDX      bndreg,mem,reg64       [rmx:           0f 1a /r ]  MPX,MIB,LONG,FUTURE
+BNDSTX      mem,bndreg             [mr:            0f 1b /r ]  MPX,MIB,FUTURE
+BNDSTX      mem,reg32,bndreg       [mxr:           0f 1b /r ]  MPX,MIB,NOLONG,FUTURE
+BNDSTX      mem,reg64,bndreg       [mxr:           0f 1b /r ]  MPX,MIB,LONG,FUTURE
+BNDSTX      mem,bndreg,reg32       [mrx:           0f 1b /r ]  MPX,MIB,NOLONG,FUTURE
+BNDSTX      mem,bndreg,reg64       [mrx:           0f 1b /r ]  MPX,MIB,LONG,FUTURE
+
+;# Intel SHA acceleration instructions
+SHA1MSG1        xmmreg,xmmrm128                     [rm: 0f 38 c9 /r ] SHA,FUTURE
+SHA1MSG2        xmmreg,xmmrm128                     [rm: 0f 38 ca /r ] SHA,FUTURE
+SHA1NEXTE       xmmreg,xmmrm128                     [rm: 0f 38 c8 /r ] SHA,FUTURE
+SHA1RNDS4       xmmreg,xmmrm128,imm8                [rmi: 0f 3a cc /r ib ] SHA,FUTURE
+SHA256MSG1      xmmreg,xmmrm128                     [rm: 0f 38 cc /r ] SHA,FUTURE
+SHA256MSG2      xmmreg,xmmrm128                     [rm: 0f 38 cd /r ] SHA,FUTURE
+SHA256RNDS2     xmmreg,xmmrm128,xmm0                [rm-: 0f 38 cb /r ] SHA,FUTURE
+SHA256RNDS2     xmmreg,xmmrm128                     [rm:  0f 38 cb /r ] SHA,FUTURE
+
+;# AVX no exception conversions
+; Must precede AVX-512 versions
+VBCSTNEBF16PS	xmmreg,mem16				[rm:	vex.128.f3.0f38.w0 b1 /r]	AVXNECONVERT,FUTURE,LATEVEX,SW
+VBCSTNEBF16PS	ymmreg,mem16				[rm:	vex.256.f3.0f38.w0 b1 /r]	AVXNECONVERT,FUTURE,LATEVEX,SW
+VBCSTNESH2PS	xmmreg,mem16				[rm:	vex.128.66.0f38.w0 b1 /r]	AVXNECONVERT,FUTURE,LATEVEX,SW
+VBCSTNESH2PS	ymmreg,mem16				[rm:	vex.256.66.0f38.w0 b1 /r]	AVXNECONVERT,FUTURE,LATEVEX,SW
+VCVTNEEBF162PS	xmmreg,mem128				[rm:	vex.128.f3.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SX
+VCVTNEEBF162PS	ymmreg,mem256				[rm:	vex.256.f3.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SY
+VCVTNEEPH2PS	xmmreg,mem128				[rm:	vex.128.66.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SX
+VCVTNEEPH2PS	ymmreg,mem256				[rm:	vex.256.66.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SY
+VCVTNEOBF162PS	xmmreg,mem128				[rm:	vex.128.f2.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SX
+VCVTNEOBF162PS	ymmreg,mem256				[rm:	vex.256.f2.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SY
+VCVTNEOPH2PS	xmmreg,mem128				[rm:	vex.128.np.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SX
+VCVTNEOPH2PS	ymmreg,mem256				[rm:	vex.256.np.0f38.w0 b0 /r]	AVXNECONVERT,FUTURE,LATEVEX,SY
+VCVTNEPS2BF16	xmmreg,xmmrm128				[rm:	vex.128.f3.0f38.w0 72 /r]	AVXNECONVERT,FUTURE,LATEVEX,SX
+VCVTNEPS2BF16	ymmreg,ymmrm256				[rm:	vex.256.f3.0f38.w0 72 /r]	AVXNECONVERT,FUTURE,LATEVEX,SY
+
+;# AVX Vector Neural Network Instructions
+; Must precede AVX-512 versions
+VPDPBSSD  	 xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.f2.0f38.w0 50 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SX
+VPDPBSSD  	 ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.f2.0f38.w0 50 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SY
+VPDPBSSDS  	 xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.f2.0f38.w0 51 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SX
+VPDPBSSDS  	 ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.f2.0f38.w0 51 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SY
+VPDPBSUD  	 xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.f3.0f38.w0 50 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SX
+VPDPBSUD  	 ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.f3.0f38.w0 50 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SY
+VPDPBSUDS  	 xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.f3.0f38.w0 51 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SX
+VPDPBSUDS  	 ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.f3.0f38.w0 51 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SY
+VPDPBUUD  	 xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.np.0f38.w0 50 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SX
+VPDPBUUD  	 ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.np.0f38.w0 50 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SY
+VPDPBUUDS  	 xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.np.0f38.w0 51 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SX
+VPDPBUUDS  	 ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.np.0f38.w0 51 /r]	AVXVNNIINT8,FUTURE,LATEVEX,SY
+
+;# AVX Integer Fused Multiply-Add
+; Must precede AVX-512 versions
+VPMADD52HUQ     xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.66.0f38.w1 b5 /r]	AVXIFMA,FUTURE,LATEVEX,SX
+VPMADD52HUQ     ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.66.0f38.w1 b5 /r]	AVXIFMA,FUTURE,LATEVEX,SY
+VPMADD52LUQ     xmmreg,xmmreg,xmmrm128			[rvm:	vex.128.66.0f38.w1 b4 /r]	AVXIFMA,FUTURE,LATEVEX,SX
+VPMADD52LUQ     ymmreg,ymmreg,ymmrm256			[rvm:	vex.256.66.0f38.w1 b4 /r]	AVXIFMA,FUTURE,LATEVEX,SY
+
+;# AVX-512 mask register instructions
+KADDB           kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 4a /r ] FUTURE
+KADDD           kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w1 4a /r ] FUTURE
+KADDQ           kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 4a /r ] FUTURE
+KADDW           kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 4a /r ] FUTURE
+KANDB           kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 41 /r ] FUTURE
+KANDD           kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w1 41 /r ] FUTURE
+KANDNB          kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 42 /r ] FUTURE
+KANDND          kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w1 42 /r ] FUTURE
+KANDNQ          kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 42 /r ] FUTURE
+KANDNW          kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 42 /r ] FUTURE
+KANDQ           kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 41 /r ] FUTURE
+KANDW           kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 41 /r ] FUTURE
+KMOVB           kreg,krm8                           [rm: vex.l0.66.0f.w0 90 /r ] FUTURE
+KMOVB           mem8,kreg                           [mr: vex.l0.66.0f.w0 91 /r ] FUTURE
+KMOVB           kreg,reg32                          [rm: vex.l0.66.0f.w0 92 /r ] FUTURE
+KMOVB           kreg,reg8                           [rm: vex.l0.66.0f.w0 92 nohi /r ] FUTURE,ND
+KMOVB           reg32,kreg                          [rm: vex.l0.66.0f.w0 93 /r ] FUTURE
+KMOVD           kreg,krm32                          [rm: vex.l0.66.0f.w1 90 /r ] FUTURE
+KMOVD           mem32,kreg                          [mr: vex.l0.66.0f.w1 91 /r ] FUTURE
+KMOVD           kreg,reg32                          [rm: vex.l0.f2.0f.w0 92 /r ] FUTURE
+KMOVD           reg32,kreg                          [rm: vex.l0.f2.0f.w0 93 /r ] FUTURE
+KMOVQ           kreg,krm64                          [rm: vex.l0.0f.w1 90 /r ] FUTURE
+KMOVQ           mem64,kreg                          [mr: vex.l0.0f.w1 91 /r ] FUTURE
+KMOVQ           kreg,reg64                          [rm: vex.l0.f2.0f.w1 92 /r ] FUTURE
+KMOVQ           reg64,kreg                          [rm: vex.l0.f2.0f.w1 93 /r ] FUTURE
+KMOVW           kreg,krm16                          [rm: vex.l0.0f.w0 90 /r ] FUTURE
+KMOVW           mem16,kreg                          [mr: vex.l0.0f.w0 91 /r ] FUTURE
+KMOVW           kreg,reg32                          [rm: vex.l0.0f.w0 92 /r ] FUTURE
+KMOVW           kreg,reg16                          [rm: vex.l0.0f.w0 92 /r ] FUTURE,ND
+KMOVW           reg32,kreg                          [rm: vex.l0.0f.w0 93 /r ] FUTURE
+KNOTB           kreg,kreg                           [rm: vex.l0.66.0f.w0 44 /r ] FUTURE
+KNOTD           kreg,kreg                           [rm: vex.l0.66.0f.w1 44 /r ] FUTURE
+KNOTQ           kreg,kreg                           [rm: vex.l0.0f.w1 44 /r ] FUTURE
+KNOTW           kreg,kreg                           [rm: vex.l0.0f.w0 44 /r ] FUTURE
+KORB            kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 45 /r ] FUTURE
+KORD            kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w1 45 /r ] FUTURE
+KORQ            kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 45 /r ] FUTURE
+KORW            kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 45 /r ] FUTURE
+KORTESTB        kreg,kreg                           [rm: vex.l0.66.0f.w0 98 /r ] FUTURE
+KORTESTD        kreg,kreg                           [rm: vex.l0.66.0f.w1 98 /r ] FUTURE
+KORTESTQ        kreg,kreg                           [rm: vex.l0.0f.w1 98 /r ] FUTURE
+KORTESTW        kreg,kreg                           [rm: vex.l0.0f.w0 98 /r ] FUTURE
+KSHIFTLB        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w0 32 /r ib ] FUTURE
+KSHIFTLD        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w0 33 /r ib ] FUTURE
+KSHIFTLQ        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w1 33 /r ib ] FUTURE
+KSHIFTLW        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w1 32 /r ib ] FUTURE
+KSHIFTRB        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w0 30 /r ib ] FUTURE
+KSHIFTRD        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w0 31 /r ib ] FUTURE
+KSHIFTRQ        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w1 31 /r ib ] FUTURE
+KSHIFTRW        kreg,kreg,imm8                      [rmi: vex.l0.66.0f3a.w1 30 /r ib ] FUTURE
+KTESTB          kreg,kreg                           [rm: vex.l0.66.0f.w0 99 /r ] FUTURE
+KTESTD          kreg,kreg                           [rm: vex.l0.66.0f.w1 99 /r ] FUTURE
+KTESTQ          kreg,kreg                           [rm: vex.l0.0f.w1 99 /r ] FUTURE
+KTESTW          kreg,kreg                           [rm: vex.l0.0f.w0 99 /r ] FUTURE
+KUNPCKBW        kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 4b /r ] FUTURE
+KUNPCKDQ        kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 4b /r ] FUTURE
+KUNPCKWD        kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 4b /r ] FUTURE
+KXNORB          kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 46 /r ] FUTURE
+KXNORD          kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w1 46 /r ] FUTURE
+KXNORQ          kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 46 /r ] FUTURE
+KXNORW          kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 46 /r ] FUTURE
+KXORB           kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w0 47 /r ] FUTURE
+KXORD           kreg,kreg,kreg                      [rvm: vex.nds.l1.66.0f.w1 47 /r ] FUTURE
+KXORQ           kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w1 47 /r ] FUTURE
+KXORW           kreg,kreg,kreg                      [rvm: vex.nds.l1.0f.w0 47 /r ] FUTURE
+
+;# AVX-512 mask register instructions (aliases requiring explicit size support)
+KADD            kreg8,kreg,kreg                     [rvm: vex.nds.l1.66.0f.w0 4a /r ] FUTURE,ND,SM
+KADD            kreg32,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w1 4a /r ] FUTURE,ND,SM
+KADD            kreg64,kreg,kreg                    [rvm: vex.nds.l1.0f.w1 4a /r ] FUTURE,ND,SM
+KADD            kreg16,kreg,kreg                    [rvm: vex.nds.l1.0f.w0 4a /r ] FUTURE,ND,SM
+KAND            kreg8,kreg,kreg                     [rvm: vex.nds.l1.66.0f.w0 41 /r ] FUTURE,ND,SM
+KAND            kreg32,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w1 41 /r ] FUTURE,ND,SM
+KANDN           kreg64,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w0 42 /r ] FUTURE,ND,SM
+KANDN           kreg16,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w1 42 /r ] FUTURE,ND,SM
+KANDN           kreg8,kreg,kreg                     [rvm: vex.nds.l1.0f.w1 42 /r ] FUTURE,ND,SM
+KANDN           kreg32,kreg,kreg                    [rvm: vex.nds.l1.0f.w0 42 /r ] FUTURE,ND,SM
+KAND            kreg64,kreg,kreg                    [rvm: vex.nds.l1.0f.w1 41 /r ] FUTURE,ND,SM
+KAND            kreg16,kreg,kreg                    [rvm: vex.nds.l1.0f.w0 41 /r ] FUTURE,ND,SM
+KMOV            kreg8,krm8                          [rm: vex.l0.66.0f.w0 90 /r ] FUTURE,ND,SM
+KMOV            mem8,kreg8                          [mr: vex.l0.66.0f.w0 91 /r ] FUTURE,ND,SB,SM
+KMOV            kreg8,reg32                         [rm: vex.l0.66.0f.w0 92 /r ] FUTURE,ND,SX
+KMOV            kreg8,reg8                          [rm: vex.l0.66.0f.w0 92 /r ] FUTURE,ND,SM
+KMOV            reg32,kreg8                         [rm: vex.l0.66.0f.w0 93 /r ] FUTURE,ND,SX
+KMOV            kreg32,krm32                        [rm: vex.l0.66.0f.w1 90 /r ] FUTURE,ND,SM
+KMOV            mem32,kreg32                        [mr: vex.l0.66.0f.w1 91 /r ] FUTURE,ND,SM
+KMOV            kreg32,reg32                        [rm: vex.l0.f2.0f.w0 92 /r ] FUTURE,ND,SM
+KMOV            reg32,kreg32                        [rm: vex.l0.f2.0f.w0 93 /r ] FUTURE,ND,SM
+KMOV            kreg64,krm64                        [rm: vex.l0.0f.w1 90 /r ] FUTURE,ND,SM
+KMOV            mem64,kreg64                        [mr: vex.l0.0f.w1 91 /r ] FUTURE,ND,SM
+KMOV            kreg64,reg64                        [rm: vex.l0.f2.0f.w1 92 /r ] FUTURE,ND,SM
+KMOV            reg64,kreg64                        [rm: vex.l0.f2.0f.w1 93 /r ] FUTURE,ND,SM
+KMOV            kreg16,krm16                        [rm: vex.l0.0f.w0 90 /r ] FUTURE,ND,SM
+KMOV            mem16,kreg16                        [mr: vex.l0.0f.w0 91 /r ] FUTURE,ND,SM
+KMOV            kreg16,reg32                        [rm: vex.l0.0f.w0 92 /r ] FUTURE,ND,SX
+KMOV            reg32,kreg16                        [rm: vex.l0.0f.w0 93 /r ] FUTURE,ND,SX
+KMOV            kreg16,reg32                        [rm: vex.l0.0f.w0 92 /r ] FUTURE,ND,SX
+KMOV            kreg16,reg16                        [rm: vex.l0.0f.w0 92 /r ] FUTURE,ND,SM
+KNOT            kreg8,kreg8                         [rm: vex.l0.66.0f.w0 44 /r ] FUTURE,ND,SM
+KNOT            kreg32,kreg32                       [rm: vex.l0.66.0f.w1 44 /r ] FUTURE,ND,SM
+KNOT            kreg64,kreg64                       [rm: vex.l0.0f.w1 44 /r ] FUTURE,ND,SM
+KNOT            kreg16,kreg16                       [rm: vex.l0.0f.w0 44 /r ] FUTURE,ND,SM
+KOR             kreg8,kreg,kreg                     [rvm: vex.nds.l1.66.0f.w0 45 /r ] FUTURE,ND,SM
+KOR             kreg32,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w1 45 /r ] FUTURE,ND,SM
+KOR             kreg64,kreg,kreg                    [rvm: vex.nds.l1.0f.w1 45 /r ] FUTURE,ND,SM
+KOR             kreg16,kreg,kreg                    [rvm: vex.nds.l1.0f.w0 45 /r ] FUTURE,ND,SM
+KORTEST         kreg8,kreg                          [rm: vex.l0.66.0f.w0 98 /r ] FUTURE,ND,SM
+KORTEST         kreg32,kreg                         [rm: vex.l0.66.0f.w1 98 /r ] FUTURE,ND,SM
+KORTEST         kreg64,kreg                         [rm: vex.l0.0f.w1 98 /r ] FUTURE,ND,SM
+KORTEST         kreg16,kreg                         [rm: vex.l0.0f.w0 98 /r ] FUTURE,ND,SM
+KSHIFTL         kreg8,kreg,imm8                     [rmi: vex.l0.66.0f3a.w0 32 /r ib ] FUTURE,ND,SM2
+KSHIFTL         kreg32,kreg,imm8                    [rmi: vex.l0.66.0f3a.w0 33 /r ib ] FUTURE,ND,SM2
+KSHIFTL         kreg64,kreg,imm8                    [rmi: vex.l0.66.0f3a.w1 33 /r ib ] FUTURE,ND,SM2
+KSHIFTL         kreg16,kreg,imm8                    [rmi: vex.l0.66.0f3a.w1 32 /r ib ] FUTURE,ND,SM2
+KSHIFTR         kreg8,kreg,imm8                     [rmi: vex.l0.66.0f3a.w0 30 /r ib ] FUTURE,ND,SM2
+KSHIFTR         kreg32,kreg,imm8                    [rmi: vex.l0.66.0f3a.w0 31 /r ib ] FUTURE,ND,SM2
+KSHIFTR         kreg64,kreg,imm8                    [rmi: vex.l0.66.0f3a.w1 31 /r ib ] FUTURE,ND,SM2
+KSHIFTR         kreg16,kreg,imm8                    [rmi: vex.l0.66.0f3a.w1 30 /r ib ] FUTURE,ND,SM2
+KTEST           kreg8,kreg                          [rm: vex.l0.66.0f.w0 99 /r ] FUTURE,ND,SM
+KTEST           kreg32,kreg                         [rm: vex.l0.66.0f.w1 99 /r ] FUTURE,ND,SM
+KTEST           kreg64,kreg                         [rm: vex.l0.0f.w1 99 /r ] FUTURE,ND,SM
+KTEST           kreg16,kreg                         [rm: vex.l0.0f.w0 99 /r ] FUTURE,ND,SM
+KUNPCK          kreg16,kreg8,kreg8                  [rvm: vex.nds.l1.66.0f.w0 4b /r ] FUTURE,ND
+KUNPCK          kreg64,kreg32,kreg32                [rvm: vex.nds.l1.0f.w1 4b /r ] FUTURE,ND
+KUNPCK          kreg32,kreg16,kreg16                [rvm: vex.nds.l1.0f.w0 4b /r ] FUTURE,ND
+KXNOR           kreg8,kreg,kreg                     [rvm: vex.nds.l1.66.0f.w0 46 /r ] FUTURE,ND,SM
+KXNOR           kreg32,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w1 46 /r ] FUTURE,ND,SM
+KXNOR           kreg64,kreg,kreg                    [rvm: vex.nds.l1.0f.w1 46 /r ] FUTURE,ND,SM
+KXNOR           kreg16,kreg,kreg                    [rvm: vex.nds.l1.0f.w0 46 /r ] FUTURE,ND,SM
+KXOR            kreg8,kreg,kreg                     [rvm: vex.nds.l1.66.0f.w0 47 /r ] FUTURE,ND,SM
+KXOR            kreg32,kreg,kreg                    [rvm: vex.nds.l1.66.0f.w1 47 /r ] FUTURE,ND,SM
+KXOR            kreg64,kreg,kreg                    [rvm: vex.nds.l1.0f.w1 47 /r ] FUTURE,ND,SM
+KXOR            kreg16,kreg,kreg                    [rvm: vex.nds.l1.0f.w0 47 /r ] FUTURE,ND,SM
+
+;# AVX-512 instructions
+VADDPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 58 /r ] AVX512VL,AVX512,FUTURE
+VADDPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 58 /r ] AVX512VL,AVX512,FUTURE
+VADDPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f.w1 58 /r ] AVX512,FUTURE
+VADDPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 58 /r ] AVX512VL,AVX512,FUTURE
+VADDPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 58 /r ] AVX512VL,AVX512,FUTURE
+VADDPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32|er [rvm:fv: evex.nds.512.0f.w0 58 /r ] AVX512,FUTURE
+VADDSD          xmmreg|mask|z,xmmreg*,xmmrm64|er    [rvm:t1s: evex.nds.128.f2.0f.w1 58 /r ] AVX512,FUTURE
+VADDSS          xmmreg|mask|z,xmmreg*,xmmrm32|er    [rvm:t1s: evex.nds.128.f3.0f.w0 58 /r ] AVX512,FUTURE
+VALIGND         xmmreg|mask|z,xmmreg*,xmmrm128|b32,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w0 03 /r ib ] AVX512VL,AVX512,FUTURE
+VALIGND         ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w0 03 /r ib ] AVX512VL,AVX512,FUTURE
+VALIGND         zmmreg|mask|z,zmmreg*,zmmrm512|b32,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w0 03 /r ib ] AVX512,FUTURE
+VALIGNQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w1 03 /r ib ] AVX512VL,AVX512,FUTURE
+VALIGNQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w1 03 /r ib ] AVX512VL,AVX512,FUTURE
+VALIGNQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w1 03 /r ib ] AVX512,FUTURE
+VANDNPD         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 55 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDNPD         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 55 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDNPD         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 55 /r ] AVX512DQ,FUTURE
+VANDNPS         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 55 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDNPS         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 55 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDNPS         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.0f.w0 55 /r ] AVX512DQ,FUTURE
+VANDPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 54 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 54 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 54 /r ] AVX512DQ,FUTURE
+VANDPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 54 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 54 /r ] AVX512VL,AVX512DQ,FUTURE
+VANDPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.0f.w0 54 /r ] AVX512DQ,FUTURE
+VBLENDMPD       xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 65 /r ] AVX512VL,AVX512,FUTURE
+VBLENDMPD       ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 65 /r ] AVX512VL,AVX512,FUTURE
+VBLENDMPD       zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 65 /r ] AVX512,FUTURE
+VBLENDMPS       xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 65 /r ] AVX512VL,AVX512,FUTURE
+VBLENDMPS       ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 65 /r ] AVX512VL,AVX512,FUTURE
+VBLENDMPS       zmmreg|mask|z,zmmreg,zmmrm512|b32   [rvm:fv: evex.nds.512.66.0f38.w0 65 /r ] AVX512,FUTURE
+VBROADCASTF32X2 ymmreg|mask|z,xmmrm64               [rm:t2: evex.256.66.0f38.w0 19 /r ] AVX512VL,AVX512DQ,FUTURE
+VBROADCASTF32X2 zmmreg|mask|z,xmmrm64               [rm:t2: evex.512.66.0f38.w0 19 /r ] AVX512DQ,FUTURE
+VBROADCASTF32X4 ymmreg|mask|z,mem128                [rm:t4: evex.256.66.0f38.w0 1a /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTF32X4 zmmreg|mask|z,mem128                [rm:t4: evex.512.66.0f38.w0 1a /r ] AVX512,FUTURE
+VBROADCASTF32X8 zmmreg|mask|z,mem256                [rm:t8: evex.512.66.0f38.w0 1b /r ] AVX512DQ,FUTURE
+VBROADCASTF64X2 ymmreg|mask|z,mem128                [rm:t2: evex.256.66.0f38.w1 1a /r ] AVX512VL,AVX512DQ,FUTURE
+VBROADCASTF64X2 zmmreg|mask|z,mem128                [rm:t2: evex.512.66.0f38.w1 1a /r ] AVX512DQ,FUTURE
+VBROADCASTF64X4 zmmreg|mask|z,mem256                [rm:t4: evex.512.66.0f38.w1 1b /r ] AVX512,FUTURE
+VBROADCASTI32X2 xmmreg|mask|z,xmmrm64               [rm:t2: evex.128.66.0f38.w0 59 /r ] AVX512VL,AVX512DQ,FUTURE
+VBROADCASTI32X2 ymmreg|mask|z,xmmrm64               [rm:t2: evex.256.66.0f38.w0 59 /r ] AVX512VL,AVX512DQ,FUTURE
+VBROADCASTI32X2 zmmreg|mask|z,xmmrm64               [rm:t2: evex.512.66.0f38.w0 59 /r ] AVX512DQ,FUTURE
+VBROADCASTI32X4 ymmreg|mask|z,mem128                [rm:t4: evex.256.66.0f38.w0 5a /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTI32X4 zmmreg|mask|z,mem128                [rm:t4: evex.512.66.0f38.w0 5a /r ] AVX512,FUTURE
+VBROADCASTI32X8 zmmreg|mask|z,mem256                [rm:t8: evex.512.66.0f38.w0 5b /r ] AVX512DQ,FUTURE
+VBROADCASTI64X2 ymmreg|mask|z,mem128                [rm:t2: evex.256.66.0f38.w1 5a /r ] AVX512VL,AVX512DQ,FUTURE
+VBROADCASTI64X2 zmmreg|mask|z,mem128                [rm:t2: evex.512.66.0f38.w1 5a /r ] AVX512DQ,FUTURE
+VBROADCASTI64X4 zmmreg|mask|z,mem256                [rm:t4: evex.512.66.0f38.w1 5b /r ] AVX512,FUTURE
+VBROADCASTSD    ymmreg|mask|z,mem64                 [rm:t1s: evex.256.66.0f38.w1 19 /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTSD    zmmreg|mask|z,mem64                 [rm:t1s: evex.512.66.0f38.w1 19 /r ] AVX512,FUTURE
+VBROADCASTSD    ymmreg|mask|z,xmmreg                [rm: evex.256.66.0f38.w1 19 /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTSD    zmmreg|mask|z,xmmreg                [rm: evex.512.66.0f38.w1 19 /r ] AVX512,FUTURE
+VBROADCASTSS    xmmreg|mask|z,mem32                 [rm:t1s: evex.128.66.0f38.w0 18 /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTSS    ymmreg|mask|z,mem32                 [rm:t1s: evex.256.66.0f38.w0 18 /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTSS    zmmreg|mask|z,mem32                 [rm:t1s: evex.512.66.0f38.w0 18 /r ] AVX512,FUTURE
+VBROADCASTSS    xmmreg|mask|z,xmmreg                [rm: evex.128.66.0f38.w0 18 /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTSS    ymmreg|mask|z,xmmreg                [rm: evex.256.66.0f38.w0 18 /r ] AVX512VL,AVX512,FUTURE
+VBROADCASTSS    zmmreg|mask|z,xmmreg                [rm: evex.512.66.0f38.w0 18 /r ] AVX512,FUTURE
+VCMPEQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 00 ] AVX512,FUTURE
+VCMPEQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 00 ] AVX512,FUTURE
+VCMPEQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 00 ] AVX512,FUTURE
+VCMPEQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 00 ] AVX512,FUTURE
+VCMPEQ_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 00 ] AVX512,FUTURE
+VCMPEQ_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 00 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 00 ] AVX512,FUTURE
+VCMPEQ_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 00 ] AVX512,FUTURE
+VCMPEQ_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 00 ] AVX512,FUTURE
+VCMPLTPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLTPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLTPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 01 ] AVX512,FUTURE
+VCMPLTPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLTPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLTPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 01 ] AVX512,FUTURE
+VCMPLTSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 01 ] AVX512,FUTURE
+VCMPLTSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 01 ] AVX512,FUTURE
+VCMPLT_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 01 ] AVX512,FUTURE
+VCMPLT_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 01 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 01 ] AVX512,FUTURE
+VCMPLT_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 01 ] AVX512,FUTURE
+VCMPLT_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 01 ] AVX512,FUTURE
+VCMPLEPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLEPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLEPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 02 ] AVX512,FUTURE
+VCMPLEPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLEPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLEPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 02 ] AVX512,FUTURE
+VCMPLESD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 02 ] AVX512,FUTURE
+VCMPLESS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 02 ] AVX512,FUTURE
+VCMPLE_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 02 ] AVX512,FUTURE
+VCMPLE_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 02 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 02 ] AVX512,FUTURE
+VCMPLE_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 02 ] AVX512,FUTURE
+VCMPLE_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 02 ] AVX512,FUTURE
+VCMPUNORDPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORDPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORDPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORDPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORDPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORDPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORDSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORDSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORD_QPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_QPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_QPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORD_QPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_QPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 03 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_QPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORD_QSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 03 ] AVX512,FUTURE
+VCMPUNORD_QSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 03 ] AVX512,FUTURE
+VCMPNEQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQ_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQ_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 04 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQ_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 04 ] AVX512,FUTURE
+VCMPNEQ_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 04 ] AVX512,FUTURE
+VCMPNLTPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLTPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLTPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 05 ] AVX512,FUTURE
+VCMPNLTPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLTPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLTPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 05 ] AVX512,FUTURE
+VCMPNLTSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 05 ] AVX512,FUTURE
+VCMPNLTSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 05 ] AVX512,FUTURE
+VCMPNLT_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 05 ] AVX512,FUTURE
+VCMPNLT_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 05 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 05 ] AVX512,FUTURE
+VCMPNLT_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 05 ] AVX512,FUTURE
+VCMPNLT_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 05 ] AVX512,FUTURE
+VCMPNLEPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLEPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLEPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 06 ] AVX512,FUTURE
+VCMPNLEPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLEPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLEPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 06 ] AVX512,FUTURE
+VCMPNLESD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 06 ] AVX512,FUTURE
+VCMPNLESS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 06 ] AVX512,FUTURE
+VCMPNLE_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 06 ] AVX512,FUTURE
+VCMPNLE_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 06 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 06 ] AVX512,FUTURE
+VCMPNLE_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 06 ] AVX512,FUTURE
+VCMPNLE_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 06 ] AVX512,FUTURE
+VCMPORDPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORDPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORDPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 07 ] AVX512,FUTURE
+VCMPORDPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORDPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORDPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 07 ] AVX512,FUTURE
+VCMPORDSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 07 ] AVX512,FUTURE
+VCMPORDSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 07 ] AVX512,FUTURE
+VCMPORD_QPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORD_QPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORD_QPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 07 ] AVX512,FUTURE
+VCMPORD_QPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORD_QPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 07 ] AVX512VL,AVX512,FUTURE
+VCMPORD_QPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 07 ] AVX512,FUTURE
+VCMPORD_QSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 07 ] AVX512,FUTURE
+VCMPORD_QSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 07 ] AVX512,FUTURE
+VCMPEQ_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 08 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 08 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 08 ] AVX512,FUTURE
+VCMPEQ_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 08 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 08 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 08 ] AVX512,FUTURE
+VCMPEQ_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 08 ] AVX512,FUTURE
+VCMPEQ_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 08 ] AVX512,FUTURE
+VCMPNGEPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGEPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGEPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 09 ] AVX512,FUTURE
+VCMPNGEPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGEPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGEPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 09 ] AVX512,FUTURE
+VCMPNGESD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 09 ] AVX512,FUTURE
+VCMPNGESS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 09 ] AVX512,FUTURE
+VCMPNGE_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 09 ] AVX512,FUTURE
+VCMPNGE_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 09 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 09 ] AVX512,FUTURE
+VCMPNGE_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 09 ] AVX512,FUTURE
+VCMPNGE_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 09 ] AVX512,FUTURE
+VCMPNGTPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGTPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGTPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0a ] AVX512,FUTURE
+VCMPNGTPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGTPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGTPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0a ] AVX512,FUTURE
+VCMPNGTSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0a ] AVX512,FUTURE
+VCMPNGTSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0a ] AVX512,FUTURE
+VCMPNGT_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0a ] AVX512,FUTURE
+VCMPNGT_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0a ] AVX512,FUTURE
+VCMPNGT_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0a ] AVX512,FUTURE
+VCMPNGT_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0a ] AVX512,FUTURE
+VCMPFALSEPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSEPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSEPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSEPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSEPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSEPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSESD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSESS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSE_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSE_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSE_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0b ] AVX512,FUTURE
+VCMPFALSE_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0b ] AVX512,FUTURE
+VCMPNEQ_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0c ] AVX512,FUTURE
+VCMPNEQ_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0c ] AVX512,FUTURE
+VCMPNEQ_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0c ] AVX512,FUTURE
+VCMPNEQ_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0c ] AVX512,FUTURE
+VCMPGEPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGEPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGEPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0d ] AVX512,FUTURE
+VCMPGEPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGEPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGEPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0d ] AVX512,FUTURE
+VCMPGESD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0d ] AVX512,FUTURE
+VCMPGESS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0d ] AVX512,FUTURE
+VCMPGE_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0d ] AVX512,FUTURE
+VCMPGE_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0d ] AVX512,FUTURE
+VCMPGE_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0d ] AVX512,FUTURE
+VCMPGE_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0d ] AVX512,FUTURE
+VCMPGTPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGTPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGTPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0e ] AVX512,FUTURE
+VCMPGTPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGTPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGTPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0e ] AVX512,FUTURE
+VCMPGTSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0e ] AVX512,FUTURE
+VCMPGTSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0e ] AVX512,FUTURE
+VCMPGT_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0e ] AVX512,FUTURE
+VCMPGT_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0e ] AVX512,FUTURE
+VCMPGT_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0e ] AVX512,FUTURE
+VCMPGT_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0e ] AVX512,FUTURE
+VCMPTRUEPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUEPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUEPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUEPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUEPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUEPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUESD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUESS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUE_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUE_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 0f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUE_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 0f ] AVX512,FUTURE
+VCMPTRUE_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 0f ] AVX512,FUTURE
+VCMPEQ_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 10 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 10 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 10 ] AVX512,FUTURE
+VCMPEQ_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 10 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 10 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 10 ] AVX512,FUTURE
+VCMPEQ_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 10 ] AVX512,FUTURE
+VCMPEQ_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 10 ] AVX512,FUTURE
+VCMPLT_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 11 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 11 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 11 ] AVX512,FUTURE
+VCMPLT_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 11 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 11 ] AVX512VL,AVX512,FUTURE
+VCMPLT_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 11 ] AVX512,FUTURE
+VCMPLT_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 11 ] AVX512,FUTURE
+VCMPLT_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 11 ] AVX512,FUTURE
+VCMPLE_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 12 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 12 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 12 ] AVX512,FUTURE
+VCMPLE_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 12 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 12 ] AVX512VL,AVX512,FUTURE
+VCMPLE_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 12 ] AVX512,FUTURE
+VCMPLE_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 12 ] AVX512,FUTURE
+VCMPLE_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 12 ] AVX512,FUTURE
+VCMPUNORD_SPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 13 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_SPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 13 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_SPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 13 ] AVX512,FUTURE
+VCMPUNORD_SPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 13 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_SPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 13 ] AVX512VL,AVX512,FUTURE
+VCMPUNORD_SPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 13 ] AVX512,FUTURE
+VCMPUNORD_SSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 13 ] AVX512,FUTURE
+VCMPUNORD_SSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 13 ] AVX512,FUTURE
+VCMPNEQ_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 14 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 14 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 14 ] AVX512,FUTURE
+VCMPNEQ_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 14 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 14 ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 14 ] AVX512,FUTURE
+VCMPNEQ_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 14 ] AVX512,FUTURE
+VCMPNEQ_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 14 ] AVX512,FUTURE
+VCMPNLT_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 15 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 15 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 15 ] AVX512,FUTURE
+VCMPNLT_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 15 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 15 ] AVX512VL,AVX512,FUTURE
+VCMPNLT_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 15 ] AVX512,FUTURE
+VCMPNLT_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 15 ] AVX512,FUTURE
+VCMPNLT_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 15 ] AVX512,FUTURE
+VCMPNLE_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 16 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 16 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 16 ] AVX512,FUTURE
+VCMPNLE_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 16 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 16 ] AVX512VL,AVX512,FUTURE
+VCMPNLE_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 16 ] AVX512,FUTURE
+VCMPNLE_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 16 ] AVX512,FUTURE
+VCMPNLE_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 16 ] AVX512,FUTURE
+VCMPORD_SPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 17 ] AVX512VL,AVX512,FUTURE
+VCMPORD_SPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 17 ] AVX512VL,AVX512,FUTURE
+VCMPORD_SPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 17 ] AVX512,FUTURE
+VCMPORD_SPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 17 ] AVX512VL,AVX512,FUTURE
+VCMPORD_SPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 17 ] AVX512VL,AVX512,FUTURE
+VCMPORD_SPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 17 ] AVX512,FUTURE
+VCMPORD_SSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 17 ] AVX512,FUTURE
+VCMPORD_SSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 17 ] AVX512,FUTURE
+VCMPEQ_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 18 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 18 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 18 ] AVX512,FUTURE
+VCMPEQ_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 18 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 18 ] AVX512VL,AVX512,FUTURE
+VCMPEQ_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 18 ] AVX512,FUTURE
+VCMPEQ_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 18 ] AVX512,FUTURE
+VCMPEQ_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 18 ] AVX512,FUTURE
+VCMPNGE_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 19 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 19 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 19 ] AVX512,FUTURE
+VCMPNGE_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 19 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 19 ] AVX512VL,AVX512,FUTURE
+VCMPNGE_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 19 ] AVX512,FUTURE
+VCMPNGE_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 19 ] AVX512,FUTURE
+VCMPNGE_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 19 ] AVX512,FUTURE
+VCMPNGT_UQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 1a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_UQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 1a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_UQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 1a ] AVX512,FUTURE
+VCMPNGT_UQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 1a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_UQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 1a ] AVX512VL,AVX512,FUTURE
+VCMPNGT_UQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 1a ] AVX512,FUTURE
+VCMPNGT_UQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 1a ] AVX512,FUTURE
+VCMPNGT_UQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 1a ] AVX512,FUTURE
+VCMPFALSE_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 1b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 1b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 1b ] AVX512,FUTURE
+VCMPFALSE_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 1b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 1b ] AVX512VL,AVX512,FUTURE
+VCMPFALSE_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 1b ] AVX512,FUTURE
+VCMPFALSE_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 1b ] AVX512,FUTURE
+VCMPFALSE_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 1b ] AVX512,FUTURE
+VCMPNEQ_OSPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 1c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OSPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 1c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OSPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 1c ] AVX512,FUTURE
+VCMPNEQ_OSPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 1c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OSPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 1c ] AVX512VL,AVX512,FUTURE
+VCMPNEQ_OSPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 1c ] AVX512,FUTURE
+VCMPNEQ_OSSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 1c ] AVX512,FUTURE
+VCMPNEQ_OSSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 1c ] AVX512,FUTURE
+VCMPGE_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 1d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 1d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 1d ] AVX512,FUTURE
+VCMPGE_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 1d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 1d ] AVX512VL,AVX512,FUTURE
+VCMPGE_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 1d ] AVX512,FUTURE
+VCMPGE_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 1d ] AVX512,FUTURE
+VCMPGE_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 1d ] AVX512,FUTURE
+VCMPGT_OQPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 1e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OQPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 1e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OQPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 1e ] AVX512,FUTURE
+VCMPGT_OQPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 1e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OQPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 1e ] AVX512VL,AVX512,FUTURE
+VCMPGT_OQPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 1e ] AVX512,FUTURE
+VCMPGT_OQSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 1e ] AVX512,FUTURE
+VCMPGT_OQSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 1e ] AVX512,FUTURE
+VCMPTRUE_USPD          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r 1f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_USPD          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r 1f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_USPD          kreg|mask,zmmreg,zmmrm512|b64|sae [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r 1f ] AVX512,FUTURE
+VCMPTRUE_USPS          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.0f.w0 c2 /r 1f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_USPS          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.0f.w0 c2 /r 1f ] AVX512VL,AVX512,FUTURE
+VCMPTRUE_USPS          kreg|mask,zmmreg,zmmrm512|b32|sae [rvmi:fv: evex.nds.512.0f.w0 c2 /r 1f ] AVX512,FUTURE
+VCMPTRUE_USSD          kreg|mask,xmmreg,xmmrm64|sae   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r 1f ] AVX512,FUTURE
+VCMPTRUE_USSS          kreg|mask,xmmreg,xmmrm32|sae   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r 1f ] AVX512,FUTURE
+VCMPPD          kreg|mask,xmmreg,xmmrm128|b64,imm8  [rvmi:fv: evex.nds.128.66.0f.w1 c2 /r ib ] AVX512VL,AVX512,FUTURE
+VCMPPD          kreg|mask,ymmreg,ymmrm256|b64,imm8  [rvmi:fv: evex.nds.256.66.0f.w1 c2 /r ib ] AVX512VL,AVX512,FUTURE
+VCMPPD          kreg|mask,zmmreg,zmmrm512|b64|sae,imm8 [rvmi:fv: evex.nds.512.66.0f.w1 c2 /r ib ] AVX512,FUTURE
+VCMPPS          kreg|mask,xmmreg,xmmrm128|b32,imm8  [rvmi:fv: evex.nds.128.0f.w0 c2 /r ib ] AVX512VL,AVX512,FUTURE
+VCMPPS          kreg|mask,ymmreg,ymmrm256|b32,imm8  [rvmi:fv: evex.nds.256.0f.w0 c2 /r ib ] AVX512VL,AVX512,FUTURE
+VCMPPS          kreg|mask,zmmreg,zmmrm512|b32|sae,imm8 [rvmi:fv: evex.nds.512.0f.w0 c2 /r ib ] AVX512,FUTURE
+VCMPSD          kreg|mask,xmmreg,xmmrm64|sae,imm8   [rvmi:t1s: evex.nds.128.f2.0f.w1 c2 /r ib ] AVX512,FUTURE
+VCMPSS          kreg|mask,xmmreg,xmmrm32|sae,imm8   [rvmi:t1s: evex.nds.128.f3.0f.w0 c2 /r ib ] AVX512,FUTURE
+VCOMISD         xmmreg,xmmrm64|sae                  [rm:t1s: evex.128.66.0f.w1 2f /r ] AVX512,FUTURE
+VCOMISS         xmmreg,xmmrm32|sae                  [rm:t1s: evex.128.0f.w0 2f /r ] AVX512,FUTURE
+VCOMPRESSPD     mem128|mask,xmmreg                  [mr:t1s: evex.128.66.0f38.w1 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPD     mem256|mask,ymmreg                  [mr:t1s: evex.256.66.0f38.w1 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPD     mem512|mask,zmmreg                  [mr:t1s: evex.512.66.0f38.w1 8a /r ] AVX512,FUTURE
+VCOMPRESSPD     xmmreg|mask|z,xmmreg                [mr: evex.128.66.0f38.w1 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPD     ymmreg|mask|z,ymmreg                [mr: evex.256.66.0f38.w1 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPD     zmmreg|mask|z,zmmreg                [mr: evex.512.66.0f38.w1 8a /r ] AVX512,FUTURE
+VCOMPRESSPS     mem128|mask,xmmreg                  [mr:t1s: evex.128.66.0f38.w0 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPS     mem256|mask,ymmreg                  [mr:t1s: evex.256.66.0f38.w0 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPS     mem512|mask,zmmreg                  [mr:t1s: evex.512.66.0f38.w0 8a /r ] AVX512,FUTURE
+VCOMPRESSPS     xmmreg|mask|z,xmmreg                [mr: evex.128.66.0f38.w0 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPS     ymmreg|mask|z,ymmreg                [mr: evex.256.66.0f38.w0 8a /r ] AVX512VL,AVX512,FUTURE
+VCOMPRESSPS     zmmreg|mask|z,zmmreg                [mr: evex.512.66.0f38.w0 8a /r ] AVX512,FUTURE
+VCVTDQ2PD       xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.f3.0f.w0 e6 /r ] AVX512VL,AVX512,FUTURE
+VCVTDQ2PD       ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.f3.0f.w0 e6 /r ] AVX512VL,AVX512,FUTURE
+VCVTDQ2PD       zmmreg|mask|z,ymmrm256|b32|er       [rm:hv: evex.512.f3.0f.w0 e6 /r ] AVX512,FUTURE
+VCVTDQ2PS       xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.0f.w0 5b /r ] AVX512VL,AVX512,FUTURE
+VCVTDQ2PS       ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.0f.w0 5b /r ] AVX512VL,AVX512,FUTURE
+VCVTDQ2PS       zmmreg|mask|z,zmmrm512|b32|er       [rm:fv: evex.512.0f.w0 5b /r ] AVX512,FUTURE
+VCVTPD2DQ       xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.f2.0f.w1 e6 /r ] AVX512VL,AVX512,FUTURE
+VCVTPD2DQ       xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.f2.0f.w1 e6 /r ] AVX512VL,AVX512,FUTURE
+VCVTPD2DQ       ymmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.f2.0f.w1 e6 /r ] AVX512,FUTURE
+VCVTPD2PS       xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 5a /r ] AVX512VL,AVX512,FUTURE
+VCVTPD2PS       xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 5a /r ] AVX512VL,AVX512,FUTURE
+VCVTPD2PS       ymmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.66.0f.w1 5a /r ] AVX512,FUTURE
+VCVTPD2QQ       xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 7b /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPD2QQ       ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 7b /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPD2QQ       zmmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.66.0f.w1 7b /r ] AVX512DQ,FUTURE
+VCVTPD2UDQ      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.0f.w1 79 /r ] AVX512VL,AVX512,FUTURE
+VCVTPD2UDQ      xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.0f.w1 79 /r ] AVX512VL,AVX512,FUTURE
+VCVTPD2UDQ      ymmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.0f.w1 79 /r ] AVX512,FUTURE
+VCVTPD2UQQ      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 79 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPD2UQQ      ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 79 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPD2UQQ      zmmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.66.0f.w1 79 /r ] AVX512DQ,FUTURE
+VCVTPH2PS       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.w0 13 /r ] AVX512VL,AVX512,FUTURE
+VCVTPH2PS       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.w0 13 /r ] AVX512VL,AVX512,FUTURE
+VCVTPH2PS       zmmreg|mask|z,ymmrm256|sae          [rm:hvm: evex.512.66.0f38.w0 13 /r ] AVX512,FUTURE
+VCVTPS2DQ       xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f.w0 5b /r ] AVX512VL,AVX512,FUTURE
+VCVTPS2DQ       ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f.w0 5b /r ] AVX512VL,AVX512,FUTURE
+VCVTPS2DQ       zmmreg|mask|z,zmmrm512|b32|er       [rm:fv: evex.512.66.0f.w0 5b /r ] AVX512,FUTURE
+VCVTPS2PD       xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.0f.w0 5a /r ] AVX512VL,AVX512,FUTURE
+VCVTPS2PD       ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.0f.w0 5a /r ] AVX512VL,AVX512,FUTURE
+VCVTPS2PD       zmmreg|mask|z,ymmrm256|b32|sae      [rm:hv: evex.512.0f.w0 5a /r ] AVX512,FUTURE
+VCVTPS2PH       xmmreg|mask|z,xmmreg,imm8           [mri:hvm: evex.128.66.0f3a.w0 1d /r ib ] AVX512VL,AVX512,FUTURE
+VCVTPS2PH       xmmreg|mask|z,ymmreg,imm8           [mri:hvm: evex.256.66.0f3a.w0 1d /r ib ] AVX512VL,AVX512,FUTURE
+VCVTPS2PH       ymmreg|mask|z,zmmreg|sae,imm8       [mri:hvm: evex.512.66.0f3a.w0 1d /r ib ] AVX512,FUTURE
+VCVTPS2PH       mem64|mask,xmmreg,imm8              [mri:hvm: evex.128.66.0f3a.w0 1d /r ib ] AVX512VL,AVX512,FUTURE
+VCVTPS2PH       mem128|mask,ymmreg,imm8             [mri:hvm: evex.256.66.0f3a.w0 1d /r ib ] AVX512VL,AVX512,FUTURE
+VCVTPS2PH       mem256|mask,zmmreg|sae,imm8         [mri:hvm: evex.512.66.0f3a.w0 1d /r ib ] AVX512,FUTURE
+VCVTPS2QQ       xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.66.0f.w0 7b /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPS2QQ       ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.66.0f.w0 7b /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPS2QQ       zmmreg|mask|z,ymmrm256|b32|er       [rm:hv: evex.512.66.0f.w0 7b /r ] AVX512DQ,FUTURE
+VCVTPS2UDQ      xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.0f.w0 79 /r ] AVX512VL,AVX512,FUTURE
+VCVTPS2UDQ      ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.0f.w0 79 /r ] AVX512VL,AVX512,FUTURE
+VCVTPS2UDQ      zmmreg|mask|z,zmmrm512|b32|er       [rm:fv: evex.512.0f.w0 79 /r ] AVX512,FUTURE
+VCVTPS2UQQ      xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.66.0f.w0 79 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPS2UQQ      ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.66.0f.w0 79 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTPS2UQQ      zmmreg|mask|z,ymmrm256|b32|er       [rm:hv: evex.512.66.0f.w0 79 /r ] AVX512DQ,FUTURE
+VCVTQQ2PD       xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.f3.0f.w1 e6 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTQQ2PD       ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.f3.0f.w1 e6 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTQQ2PD       zmmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.f3.0f.w1 e6 /r ] AVX512DQ,FUTURE
+VCVTQQ2PS       xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.0f.w1 5b /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTQQ2PS       xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.0f.w1 5b /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTQQ2PS       ymmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.0f.w1 5b /r ] AVX512DQ,FUTURE
+VCVTSD2SI       reg32,xmmrm64|er                    [rm:t1f64: evex.128.f2.0f.w0 2d /r ] AVX512,FUTURE
+VCVTSD2SI       reg64,xmmrm64|er                    [rm:t1f64: evex.128.f2.0f.w1 2d /r ] AVX512,FUTURE
+VCVTSD2SS       xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.f2.0f.w1 5a /r ] AVX512,FUTURE
+VCVTSD2USI      reg32,xmmrm64|er                    [rm:t1f64: evex.128.f2.0f.w0 79 /r ] AVX512,FUTURE
+VCVTSD2USI      reg64,xmmrm64|er                    [rm:t1f64: evex.128.f2.0f.w1 79 /r ] AVX512,FUTURE
+VCVTSI2SD       xmmreg,xmmreg|er,rm32               [rvm:t1s: evex.nds.128.f2.0f.w0 2a /r ] AVX512,FUTURE
+VCVTSI2SD       xmmreg,xmmreg|er,rm64               [rvm:t1s: evex.nds.128.f2.0f.w1 2a /r ] AVX512,FUTURE
+VCVTSI2SS       xmmreg,xmmreg|er,rm32               [rvm:t1s: evex.nds.128.f3.0f.w0 2a /r ] AVX512,FUTURE
+VCVTSI2SS       xmmreg,xmmreg|er,rm64               [rvm:t1s: evex.nds.128.f3.0f.w1 2a /r ] AVX512,FUTURE
+VCVTSS2SD       xmmreg|mask|z,xmmreg,xmmrm32|sae    [rvm:t1s: evex.nds.128.f3.0f.w0 5a /r ] AVX512,FUTURE
+VCVTSS2SI       reg32,xmmrm32|er                    [rm:t1f32: evex.128.f3.0f.w0 2d /r ] AVX512,FUTURE
+VCVTSS2SI       reg64,xmmrm32|er                    [rm:t1f32: evex.128.f3.0f.w1 2d /r ] AVX512,FUTURE
+VCVTSS2USI      reg32,xmmrm32|er                    [rm:t1f32: evex.128.f3.0f.w0 79 /r ] AVX512,FUTURE
+VCVTSS2USI      reg64,xmmrm32|er                    [rm:t1f32: evex.128.f3.0f.w1 79 /r ] AVX512,FUTURE
+VCVTTPD2DQ      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 e6 /r ] AVX512VL,AVX512,FUTURE
+VCVTTPD2DQ      xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 e6 /r ] AVX512VL,AVX512,FUTURE
+VCVTTPD2DQ      ymmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f.w1 e6 /r ] AVX512,FUTURE
+VCVTTPD2QQ      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPD2QQ      ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPD2QQ      zmmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f.w1 7a /r ] AVX512DQ,FUTURE
+VCVTTPD2UDQ     xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.0f.w1 78 /r ] AVX512VL,AVX512,FUTURE
+VCVTTPD2UDQ     xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.0f.w1 78 /r ] AVX512VL,AVX512,FUTURE
+VCVTTPD2UDQ     ymmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.0f.w1 78 /r ] AVX512,FUTURE
+VCVTTPD2UQQ     xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 78 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPD2UQQ     ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 78 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPD2UQQ     zmmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f.w1 78 /r ] AVX512DQ,FUTURE
+VCVTTPS2DQ      xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.f3.0f.w0 5b /r ] AVX512VL,AVX512,FUTURE
+VCVTTPS2DQ      ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.f3.0f.w0 5b /r ] AVX512VL,AVX512,FUTURE
+VCVTTPS2DQ      zmmreg|mask|z,zmmrm512|b32|sae      [rm:fv: evex.512.f3.0f.w0 5b /r ] AVX512,FUTURE
+VCVTTPS2QQ      xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.66.0f.w0 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPS2QQ      ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.66.0f.w0 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPS2QQ      zmmreg|mask|z,ymmrm256|b32|sae      [rm:hv: evex.512.66.0f.w0 7a /r ] AVX512DQ,FUTURE
+VCVTTPS2UDQ     xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.0f.w0 78 /r ] AVX512VL,AVX512,FUTURE
+VCVTTPS2UDQ     ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.0f.w0 78 /r ] AVX512VL,AVX512,FUTURE
+VCVTTPS2UDQ     zmmreg|mask|z,zmmrm512|b32|sae      [rm:fv: evex.512.0f.w0 78 /r ] AVX512,FUTURE
+VCVTTPS2UQQ     xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.66.0f.w0 78 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPS2UQQ     ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.66.0f.w0 78 /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTTPS2UQQ     zmmreg|mask|z,ymmrm256|b32|sae      [rm:hv: evex.512.66.0f.w0 78 /r ] AVX512DQ,FUTURE
+VCVTTSD2SI      reg32,xmmrm64|sae                   [rm:t1f64: evex.128.f2.0f.w0 2c /r ] AVX512,FUTURE
+VCVTTSD2SI      reg64,xmmrm64|sae                   [rm:t1f64: evex.128.f2.0f.w1 2c /r ] AVX512,FUTURE
+VCVTTSD2USI     reg32,xmmrm64|sae                   [rm:t1f64: evex.128.f2.0f.w0 78 /r ] AVX512,FUTURE
+VCVTTSD2USI     reg64,xmmrm64|sae                   [rm:t1f64: evex.128.f2.0f.w1 78 /r ] AVX512,FUTURE
+VCVTTSS2SI      reg32,xmmrm32|sae                   [rm:t1f32: evex.128.f3.0f.w0 2c /r ] AVX512,FUTURE
+VCVTTSS2SI      reg64,xmmrm32|sae                   [rm:t1f32: evex.128.f3.0f.w1 2c /r ] AVX512,FUTURE
+VCVTTSS2USI     reg32,xmmrm32|sae                   [rm:t1f32: evex.128.f3.0f.w0 78 /r ] AVX512,FUTURE
+VCVTTSS2USI     reg64,xmmrm32|sae                   [rm:t1f32: evex.128.f3.0f.w1 78 /r ] AVX512,FUTURE
+VCVTUDQ2PD      xmmreg|mask|z,xmmrm64|b32           [rm:hv: evex.128.f3.0f.w0 7a /r ] AVX512VL,AVX512,FUTURE
+VCVTUDQ2PD      ymmreg|mask|z,xmmrm128|b32          [rm:hv: evex.256.f3.0f.w0 7a /r ] AVX512VL,AVX512,FUTURE
+VCVTUDQ2PD      zmmreg|mask|z,ymmrm256|b32|er       [rm:hv: evex.512.f3.0f.w0 7a /r ] AVX512,FUTURE
+VCVTUDQ2PS      xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.f2.0f.w0 7a /r ] AVX512VL,AVX512,FUTURE
+VCVTUDQ2PS      ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.f2.0f.w0 7a /r ] AVX512VL,AVX512,FUTURE
+VCVTUDQ2PS      zmmreg|mask|z,zmmrm512|b32|er       [rm:fv: evex.512.f2.0f.w0 7a /r ] AVX512,FUTURE
+VCVTUQQ2PD      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.f3.0f.w1 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTUQQ2PD      ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.f3.0f.w1 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTUQQ2PD      zmmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.f3.0f.w1 7a /r ] AVX512DQ,FUTURE
+VCVTUQQ2PS      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.f2.0f.w1 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTUQQ2PS      xmmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.f2.0f.w1 7a /r ] AVX512VL,AVX512DQ,FUTURE
+VCVTUQQ2PS      ymmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.f2.0f.w1 7a /r ] AVX512DQ,FUTURE
+VCVTUSI2SD      xmmreg,xmmreg|er,rm32               [rvm:t1s: evex.nds.128.f2.0f.w0 7b /r ] AVX512,FUTURE
+VCVTUSI2SD      xmmreg,xmmreg|er,rm64               [rvm:t1s: evex.nds.128.f2.0f.w1 7b /r ] AVX512,FUTURE
+VCVTUSI2SS      xmmreg,xmmreg|er,rm32               [rvm:t1s: evex.nds.128.f3.0f.w0 7b /r ] AVX512,FUTURE
+VCVTUSI2SS      xmmreg,xmmreg|er,rm64               [rvm:t1s: evex.nds.128.f3.0f.w1 7b /r ] AVX512,FUTURE
+VDBPSADBW       xmmreg|mask|z,xmmreg*,xmmrm128,imm8 [rvmi:fvm: evex.nds.128.66.0f3a.w0 42 /r ib ] AVX512VL,AVX512BW,FUTURE
+VDBPSADBW       ymmreg|mask|z,ymmreg*,ymmrm256,imm8 [rvmi:fvm: evex.nds.256.66.0f3a.w0 42 /r ib ] AVX512VL,AVX512BW,FUTURE
+VDBPSADBW       zmmreg|mask|z,zmmreg*,zmmrm512,imm8 [rvmi:fvm: evex.nds.512.66.0f3a.w0 42 /r ib ] AVX512BW,FUTURE
+VDIVPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 5e /r ] AVX512VL,AVX512,FUTURE
+VDIVPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 5e /r ] AVX512VL,AVX512,FUTURE
+VDIVPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f.w1 5e /r ] AVX512,FUTURE
+VDIVPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 5e /r ] AVX512VL,AVX512,FUTURE
+VDIVPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 5e /r ] AVX512VL,AVX512,FUTURE
+VDIVPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32|er [rvm:fv: evex.nds.512.0f.w0 5e /r ] AVX512,FUTURE
+VDIVSD          xmmreg|mask|z,xmmreg*,xmmrm64|er    [rvm:t1s: evex.nds.128.f2.0f.w1 5e /r ] AVX512,FUTURE
+VDIVSS          xmmreg|mask|z,xmmreg*,xmmrm32|er    [rvm:t1s: evex.nds.128.f3.0f.w0 5e /r ] AVX512,FUTURE
+VEXP2PD         zmmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f38.w1 c8 /r ] AVX512ER,FUTURE
+VEXP2PS         zmmreg|mask|z,zmmrm512|b32|sae      [rm:fv: evex.512.66.0f38.w0 c8 /r ] AVX512ER,FUTURE
+VEXPANDPD       xmmreg|mask|z,mem128                [rm:t1s: evex.128.66.0f38.w1 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPD       ymmreg|mask|z,mem256                [rm:t1s: evex.256.66.0f38.w1 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPD       zmmreg|mask|z,mem512                [rm:t1s: evex.512.66.0f38.w1 88 /r ] AVX512,FUTURE
+VEXPANDPD       xmmreg|mask|z,xmmreg                [rm:t1s: evex.128.66.0f38.w1 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPD       ymmreg|mask|z,ymmreg                [rm:t1s: evex.256.66.0f38.w1 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPD       zmmreg|mask|z,zmmreg                [rm:t1s: evex.512.66.0f38.w1 88 /r ] AVX512,FUTURE
+VEXPANDPS       xmmreg|mask|z,mem128                [rm:t1s: evex.128.66.0f38.w0 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPS       ymmreg|mask|z,mem256                [rm:t1s: evex.256.66.0f38.w0 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPS       zmmreg|mask|z,mem512                [rm:t1s: evex.512.66.0f38.w0 88 /r ] AVX512,FUTURE
+VEXPANDPS       xmmreg|mask|z,xmmreg                [rm:t1s: evex.128.66.0f38.w0 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPS       ymmreg|mask|z,ymmreg                [rm:t1s: evex.256.66.0f38.w0 88 /r ] AVX512VL,AVX512,FUTURE
+VEXPANDPS       zmmreg|mask|z,zmmreg                [rm:t1s: evex.512.66.0f38.w0 88 /r ] AVX512,FUTURE
+VEXTRACTF32X4   xmmreg|mask|z,ymmreg,imm8           [mri: evex.256.66.0f3a.w0 19 /r ib ] AVX512VL,AVX512,FUTURE
+VEXTRACTF32X4   xmmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w0 19 /r ib ] AVX512,FUTURE
+VEXTRACTF32X4   mem128|mask,ymmreg,imm8             [mri:t4: evex.256.66.0f3a.w0 19 /r ib ] AVX512VL,AVX512,FUTURE
+VEXTRACTF32X4   mem128|mask,zmmreg,imm8             [mri:t4: evex.512.66.0f3a.w0 19 /r ib ] AVX512,FUTURE
+VEXTRACTF32X8   ymmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w0 1b /r ib ] AVX512DQ,FUTURE
+VEXTRACTF32X8   mem256|mask,zmmreg,imm8             [mri:t8: evex.512.66.0f3a.w0 1b /r ib ] AVX512DQ,FUTURE
+VEXTRACTF64X2   xmmreg|mask|z,ymmreg,imm8           [mri: evex.256.66.0f3a.w1 19 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VEXTRACTF64X2   xmmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w1 19 /r ib ] AVX512DQ,FUTURE
+VEXTRACTF64X2   mem128|mask,ymmreg,imm8             [mri:t2: evex.256.66.0f3a.w1 19 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VEXTRACTF64X2   mem128|mask,zmmreg,imm8             [mri:t2: evex.512.66.0f3a.w1 19 /r ib ] AVX512DQ,FUTURE
+VEXTRACTF64X4   ymmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w1 1b /r ib ] AVX512,FUTURE
+VEXTRACTF64X4   mem256|mask,zmmreg,imm8             [mri:t4: evex.512.66.0f3a.w1 1b /r ib ] AVX512,FUTURE
+VEXTRACTI32X4   xmmreg|mask|z,ymmreg,imm8           [mri: evex.256.66.0f3a.w0 39 /r ib ] AVX512VL,AVX512,FUTURE
+VEXTRACTI32X4   xmmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w0 39 /r ib ] AVX512,FUTURE
+VEXTRACTI32X4   mem128|mask,ymmreg,imm8             [mri:t4: evex.256.66.0f3a.w0 39 /r ib ] AVX512VL,AVX512,FUTURE
+VEXTRACTI32X4   mem128|mask,zmmreg,imm8             [mri:t4: evex.512.66.0f3a.w0 39 /r ib ] AVX512,FUTURE
+VEXTRACTI32X8   ymmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w0 3b /r ib ] AVX512DQ,FUTURE
+VEXTRACTI32X8   mem256|mask,zmmreg,imm8             [mri:t8: evex.512.66.0f3a.w0 3b /r ib ] AVX512DQ,FUTURE
+VEXTRACTI64X2   xmmreg|mask|z,ymmreg,imm8           [mri: evex.256.66.0f3a.w1 39 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VEXTRACTI64X2   xmmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w1 39 /r ib ] AVX512DQ,FUTURE
+VEXTRACTI64X2   mem128|mask,ymmreg,imm8             [mri:t2: evex.256.66.0f3a.w1 39 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VEXTRACTI64X2   mem128|mask,zmmreg,imm8             [mri:t2: evex.512.66.0f3a.w1 39 /r ib ] AVX512DQ,FUTURE
+VEXTRACTI64X4   ymmreg|mask|z,zmmreg,imm8           [mri: evex.512.66.0f3a.w1 3b /r ib ] AVX512,FUTURE
+VEXTRACTI64X4   mem256|mask,zmmreg,imm8             [mri:t4: evex.512.66.0f3a.w1 3b /r ib ] AVX512,FUTURE
+VEXTRACTPS      reg32,xmmreg,imm8                   [mri:t1s: evex.128.66.0f3a.wig 17 /r ib ] AVX512,FUTURE
+VEXTRACTPS      reg64,xmmreg,imm8                   [mri:t1s: evex.128.66.0f3a.wig 17 /r ib ] AVX512,FUTURE
+VEXTRACTPS      mem32,xmmreg,imm8                   [mri:t1s: evex.128.66.0f3a.wig 17 /r ib ] AVX512,FUTURE
+VFIXUPIMMPD     xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w1 54 /r ib ] AVX512VL,AVX512,FUTURE
+VFIXUPIMMPD     ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w1 54 /r ib ] AVX512VL,AVX512,FUTURE
+VFIXUPIMMPD     zmmreg|mask|z,zmmreg*,zmmrm512|b64|sae,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w1 54 /r ib ] AVX512,FUTURE
+VFIXUPIMMPS     xmmreg|mask|z,xmmreg*,xmmrm128|b32,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w0 54 /r ib ] AVX512VL,AVX512,FUTURE
+VFIXUPIMMPS     ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w0 54 /r ib ] AVX512VL,AVX512,FUTURE
+VFIXUPIMMPS     zmmreg|mask|z,zmmreg*,zmmrm512|b32|sae,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w0 54 /r ib ] AVX512,FUTURE
+VFIXUPIMMSD     xmmreg|mask|z,xmmreg*,xmmrm64|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w1 55 /r ib ] AVX512,FUTURE
+VFIXUPIMMSS     xmmreg|mask|z,xmmreg*,xmmrm32|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w0 55 /r ib ] AVX512,FUTURE
+VFMADD132PD     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 98 /r ] AVX512VL,AVX512,FUTURE
+VFMADD132PD     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 98 /r ] AVX512VL,AVX512,FUTURE
+VFMADD132PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 98 /r ] AVX512,FUTURE
+VFMADD132PS     xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 98 /r ] AVX512VL,AVX512,FUTURE
+VFMADD132PS     ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 98 /r ] AVX512VL,AVX512,FUTURE
+VFMADD132PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 98 /r ] AVX512,FUTURE
+VFMADD132SD     xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 99 /r ] AVX512,FUTURE
+VFMADD132SS     xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 99 /r ] AVX512,FUTURE
+VFMADD213PD     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 a8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD213PD     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 a8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD213PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 a8 /r ] AVX512,FUTURE
+VFMADD213PS     xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 a8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD213PS     ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 a8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD213PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 a8 /r ] AVX512,FUTURE
+VFMADD213SD     xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 a9 /r ] AVX512,FUTURE
+VFMADD213SS     xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 a9 /r ] AVX512,FUTURE
+VFMADD231PD     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 b8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD231PD     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 b8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD231PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 b8 /r ] AVX512,FUTURE
+VFMADD231PS     xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 b8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD231PS     ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 b8 /r ] AVX512VL,AVX512,FUTURE
+VFMADD231PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 b8 /r ] AVX512,FUTURE
+VFMADD231SD     xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 b9 /r ] AVX512,FUTURE
+VFMADD231SS     xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 b9 /r ] AVX512,FUTURE
+VFMADDSUB132PD  xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 96 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB132PD  ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 96 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB132PD  zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 96 /r ] AVX512,FUTURE
+VFMADDSUB132PS  xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 96 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB132PS  ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 96 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB132PS  zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 96 /r ] AVX512,FUTURE
+VFMADDSUB213PD  xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 a6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB213PD  ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 a6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB213PD  zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 a6 /r ] AVX512,FUTURE
+VFMADDSUB213PS  xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 a6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB213PS  ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 a6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB213PS  zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 a6 /r ] AVX512,FUTURE
+VFMADDSUB231PD  xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 b6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB231PD  ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 b6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB231PD  zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 b6 /r ] AVX512,FUTURE
+VFMADDSUB231PS  xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 b6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB231PS  ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 b6 /r ] AVX512VL,AVX512,FUTURE
+VFMADDSUB231PS  zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 b6 /r ] AVX512,FUTURE
+VFMSUB132PD     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 9a /r ] AVX512VL,AVX512,FUTURE
+VFMSUB132PD     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 9a /r ] AVX512VL,AVX512,FUTURE
+VFMSUB132PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 9a /r ] AVX512,FUTURE
+VFMSUB132PS     xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 9a /r ] AVX512VL,AVX512,FUTURE
+VFMSUB132PS     ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 9a /r ] AVX512VL,AVX512,FUTURE
+VFMSUB132PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 9a /r ] AVX512,FUTURE
+VFMSUB132SD     xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 9b /r ] AVX512,FUTURE
+VFMSUB132SS     xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 9b /r ] AVX512,FUTURE
+VFMSUB213PD     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 aa /r ] AVX512VL,AVX512,FUTURE
+VFMSUB213PD     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 aa /r ] AVX512VL,AVX512,FUTURE
+VFMSUB213PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 aa /r ] AVX512,FUTURE
+VFMSUB213PS     xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 aa /r ] AVX512VL,AVX512,FUTURE
+VFMSUB213PS     ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 aa /r ] AVX512VL,AVX512,FUTURE
+VFMSUB213PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 aa /r ] AVX512,FUTURE
+VFMSUB213SD     xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 ab /r ] AVX512,FUTURE
+VFMSUB213SS     xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 ab /r ] AVX512,FUTURE
+VFMSUB231PD     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 ba /r ] AVX512VL,AVX512,FUTURE
+VFMSUB231PD     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 ba /r ] AVX512VL,AVX512,FUTURE
+VFMSUB231PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 ba /r ] AVX512,FUTURE
+VFMSUB231PS     xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 ba /r ] AVX512VL,AVX512,FUTURE
+VFMSUB231PS     ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 ba /r ] AVX512VL,AVX512,FUTURE
+VFMSUB231PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 ba /r ] AVX512,FUTURE
+VFMSUB231SD     xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 bb /r ] AVX512,FUTURE
+VFMSUB231SS     xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 bb /r ] AVX512,FUTURE
+VFMSUBADD132PD  xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 97 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD132PD  ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 97 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD132PD  zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 97 /r ] AVX512,FUTURE
+VFMSUBADD132PS  xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 97 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD132PS  ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 97 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD132PS  zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 97 /r ] AVX512,FUTURE
+VFMSUBADD213PD  xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 a7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD213PD  ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 a7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD213PD  zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 a7 /r ] AVX512,FUTURE
+VFMSUBADD213PS  xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 a7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD213PS  ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 a7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD213PS  zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 a7 /r ] AVX512,FUTURE
+VFMSUBADD231PD  xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 b7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD231PD  ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 b7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD231PD  zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 b7 /r ] AVX512,FUTURE
+VFMSUBADD231PS  xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 b7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD231PS  ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 b7 /r ] AVX512VL,AVX512,FUTURE
+VFMSUBADD231PS  zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 b7 /r ] AVX512,FUTURE
+VFNMADD132PD    xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 9c /r ] AVX512VL,AVX512,FUTURE
+VFNMADD132PD    ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 9c /r ] AVX512VL,AVX512,FUTURE
+VFNMADD132PD    zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 9c /r ] AVX512,FUTURE
+VFNMADD132PS    xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 9c /r ] AVX512VL,AVX512,FUTURE
+VFNMADD132PS    ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 9c /r ] AVX512VL,AVX512,FUTURE
+VFNMADD132PS    zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 9c /r ] AVX512,FUTURE
+VFNMADD132SD    xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 9d /r ] AVX512,FUTURE
+VFNMADD132SS    xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 9d /r ] AVX512,FUTURE
+VFNMADD213PD    xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 ac /r ] AVX512VL,AVX512,FUTURE
+VFNMADD213PD    ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 ac /r ] AVX512VL,AVX512,FUTURE
+VFNMADD213PD    zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 ac /r ] AVX512,FUTURE
+VFNMADD213PS    xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 ac /r ] AVX512VL,AVX512,FUTURE
+VFNMADD213PS    ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 ac /r ] AVX512VL,AVX512,FUTURE
+VFNMADD213PS    zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 ac /r ] AVX512,FUTURE
+VFNMADD213SD    xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 ad /r ] AVX512,FUTURE
+VFNMADD213SS    xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 ad /r ] AVX512,FUTURE
+VFNMADD231PD    xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 bc /r ] AVX512VL,AVX512,FUTURE
+VFNMADD231PD    ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 bc /r ] AVX512VL,AVX512,FUTURE
+VFNMADD231PD    zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 bc /r ] AVX512,FUTURE
+VFNMADD231PS    xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 bc /r ] AVX512VL,AVX512,FUTURE
+VFNMADD231PS    ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 bc /r ] AVX512VL,AVX512,FUTURE
+VFNMADD231PS    zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 bc /r ] AVX512,FUTURE
+VFNMADD231SD    xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 bd /r ] AVX512,FUTURE
+VFNMADD231SS    xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 bd /r ] AVX512,FUTURE
+VFNMSUB132PD    xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 9e /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB132PD    ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 9e /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB132PD    zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 9e /r ] AVX512,FUTURE
+VFNMSUB132PS    xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 9e /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB132PS    ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 9e /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB132PS    zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 9e /r ] AVX512,FUTURE
+VFNMSUB132SD    xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 9f /r ] AVX512,FUTURE
+VFNMSUB132SS    xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 9f /r ] AVX512,FUTURE
+VFNMSUB213PD    xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 ae /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB213PD    ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 ae /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB213PD    zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 ae /r ] AVX512,FUTURE
+VFNMSUB213PS    xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 ae /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB213PS    ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 ae /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB213PS    zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 ae /r ] AVX512,FUTURE
+VFNMSUB213SD    xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 af /r ] AVX512,FUTURE
+VFNMSUB213SS    xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 af /r ] AVX512,FUTURE
+VFNMSUB231PD    xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 be /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB231PD    ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 be /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB231PD    zmmreg|mask|z,zmmreg,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 be /r ] AVX512,FUTURE
+VFNMSUB231PS    xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 be /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB231PS    ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 be /r ] AVX512VL,AVX512,FUTURE
+VFNMSUB231PS    zmmreg|mask|z,zmmreg,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 be /r ] AVX512,FUTURE
+VFNMSUB231SD    xmmreg|mask|z,xmmreg,xmmrm64|er     [rvm:t1s: evex.nds.128.66.0f38.w1 bf /r ] AVX512,FUTURE
+VFNMSUB231SS    xmmreg|mask|z,xmmreg,xmmrm32|er     [rvm:t1s: evex.nds.128.66.0f38.w0 bf /r ] AVX512,FUTURE
+VFPCLASSPD      kreg|mask,xmmrm128|b64,imm8         [rmi:fv: evex.128.66.0f3a.w1 66 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VFPCLASSPD      kreg|mask,ymmrm256|b64,imm8         [rmi:fv: evex.256.66.0f3a.w1 66 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VFPCLASSPD      kreg|mask,zmmrm512|b64,imm8         [rmi:fv: evex.512.66.0f3a.w1 66 /r ib ] AVX512DQ,FUTURE
+VFPCLASSPS      kreg|mask,xmmrm128|b32,imm8         [rmi:fv: evex.128.66.0f3a.w0 66 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VFPCLASSPS      kreg|mask,ymmrm256|b32,imm8         [rmi:fv: evex.256.66.0f3a.w0 66 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VFPCLASSPS      kreg|mask,zmmrm512|b32,imm8         [rmi:fv: evex.512.66.0f3a.w0 66 /r ib ] AVX512DQ,FUTURE
+VFPCLASSSD      kreg|mask,xmmrm64,imm8              [rmi:t1s: evex.128.66.0f3a.w1 67 /r ib ] AVX512DQ,FUTURE
+VFPCLASSSS      kreg|mask,xmmrm32,imm8              [rmi:t1s: evex.128.66.0f3a.w0 67 /r ib ] AVX512DQ,FUTURE
+VGATHERDPD      xmmreg|mask,xmem64                  [rm:t1s: vsibx evex.128.66.0f38.w1 92 /r ] AVX512VL,AVX512,FUTURE
+VGATHERDPD      ymmreg|mask,xmem64                  [rm:t1s: vsibx evex.256.66.0f38.w1 92 /r ] AVX512VL,AVX512,FUTURE
+VGATHERDPD      zmmreg|mask,ymem64                  [rm:t1s: vsiby evex.512.66.0f38.w1 92 /r ] AVX512,FUTURE
+VGATHERDPS      xmmreg|mask,xmem32                  [rm:t1s: vsibx evex.128.66.0f38.w0 92 /r ] AVX512VL,AVX512,FUTURE
+VGATHERDPS      ymmreg|mask,ymem32                  [rm:t1s: vsiby evex.256.66.0f38.w0 92 /r ] AVX512VL,AVX512,FUTURE
+VGATHERDPS      zmmreg|mask,zmem32                  [rm:t1s: vsibz evex.512.66.0f38.w0 92 /r ] AVX512,FUTURE
+VGATHERPF0DPD   ymem64|mask                         [m:t1s: vsiby evex.512.66.0f38.w1 c6 /1 ] AVX512PF,FUTURE
+VGATHERPF0DPS   zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c6 /1 ] AVX512PF,FUTURE
+VGATHERPF0QPD   zmem64|mask                         [m:t1s: vsibz evex.512.66.0f38.w1 c7 /1 ] AVX512PF,FUTURE
+VGATHERPF0QPS   zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c7 /1 ] AVX512PF,FUTURE
+VGATHERPF1DPD   ymem64|mask                         [m:t1s: vsiby evex.512.66.0f38.w1 c6 /2 ] AVX512PF,FUTURE
+VGATHERPF1DPS   zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c6 /2 ] AVX512PF,FUTURE
+VGATHERPF1QPD   zmem64|mask                         [m:t1s: vsibz evex.512.66.0f38.w1 c7 /2 ] AVX512PF,FUTURE
+VGATHERPF1QPS   zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c7 /2 ] AVX512PF,FUTURE
+VGATHERQPD      xmmreg|mask,xmem64                  [rm:t1s: vsibx evex.128.66.0f38.w1 93 /r ] AVX512VL,AVX512,FUTURE
+VGATHERQPD      ymmreg|mask,ymem64                  [rm:t1s: vsiby evex.256.66.0f38.w1 93 /r ] AVX512VL,AVX512,FUTURE
+VGATHERQPD      zmmreg|mask,zmem64                  [rm:t1s: vsibz evex.512.66.0f38.w1 93 /r ] AVX512,FUTURE
+VGATHERQPS      xmmreg|mask,xmem32                  [rm:t1s: vsibx evex.128.66.0f38.w0 93 /r ] AVX512VL,AVX512,FUTURE
+VGATHERQPS      xmmreg|mask,ymem32                  [rm:t1s: vsiby evex.256.66.0f38.w0 93 /r ] AVX512VL,AVX512,FUTURE
+VGATHERQPS      ymmreg|mask,zmem32                  [rm:t1s: vsibz evex.512.66.0f38.w0 93 /r ] AVX512,FUTURE
+VGETEXPPD       xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f38.w1 42 /r ] AVX512VL,AVX512,FUTURE
+VGETEXPPD       ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f38.w1 42 /r ] AVX512VL,AVX512,FUTURE
+VGETEXPPD       zmmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f38.w1 42 /r ] AVX512,FUTURE
+VGETEXPPS       xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f38.w0 42 /r ] AVX512VL,AVX512,FUTURE
+VGETEXPPS       ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f38.w0 42 /r ] AVX512VL,AVX512,FUTURE
+VGETEXPPS       zmmreg|mask|z,zmmrm512|b32|sae      [rm:fv: evex.512.66.0f38.w0 42 /r ] AVX512,FUTURE
+VGETEXPSD       xmmreg|mask|z,xmmreg,xmmrm64|sae    [rvm:t1s: evex.nds.128.66.0f38.w1 43 /r ] AVX512,FUTURE
+VGETEXPSS       xmmreg|mask|z,xmmreg,xmmrm32|sae    [rvm:t1s: evex.nds.128.66.0f38.w0 43 /r ] AVX512,FUTURE
+VGETMANTPD      xmmreg|mask|z,xmmrm128|b64,imm8     [rmi:fv: evex.128.66.0f3a.w1 26 /r ib ] AVX512VL,AVX512,FUTURE
+VGETMANTPD      ymmreg|mask|z,ymmrm256|b64,imm8     [rmi:fv: evex.256.66.0f3a.w1 26 /r ib ] AVX512VL,AVX512,FUTURE
+VGETMANTPD      zmmreg|mask|z,zmmrm512|b64|sae,imm8 [rmi:fv: evex.512.66.0f3a.w1 26 /r ib ] AVX512,FUTURE
+VGETMANTPS      xmmreg|mask|z,xmmrm128|b32,imm8     [rmi:fv: evex.128.66.0f3a.w0 26 /r ib ] AVX512VL,AVX512,FUTURE
+VGETMANTPS      ymmreg|mask|z,ymmrm256|b32,imm8     [rmi:fv: evex.256.66.0f3a.w0 26 /r ib ] AVX512VL,AVX512,FUTURE
+VGETMANTPS      zmmreg|mask|z,zmmrm512|b32|sae,imm8 [rmi:fv: evex.512.66.0f3a.w0 26 /r ib ] AVX512,FUTURE
+VGETMANTSD      xmmreg|mask|z,xmmreg,xmmrm64|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w1 27 /r ib ] AVX512,FUTURE
+VGETMANTSS      xmmreg|mask|z,xmmreg,xmmrm32|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w0 27 /r ib ] AVX512,FUTURE
+VINSERTF32X4    ymmreg|mask|z,ymmreg*,xmmrm128,imm8 [rvmi:t4: evex.nds.256.66.0f3a.w0 18 /r ib ] AVX512VL,AVX512,FUTURE
+VINSERTF32X4    zmmreg|mask|z,zmmreg*,xmmrm128,imm8 [rvmi:t4: evex.nds.512.66.0f3a.w0 18 /r ib ] AVX512,FUTURE
+VINSERTF32X8    zmmreg|mask|z,zmmreg*,ymmrm256,imm8 [rvmi:t8: evex.nds.512.66.0f3a.w0 1a /r ib ] AVX512DQ,FUTURE
+VINSERTF64X2    ymmreg|mask|z,ymmreg*,xmmrm128,imm8 [rvmi:t2: evex.nds.256.66.0f3a.w1 18 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VINSERTF64X2    zmmreg|mask|z,zmmreg*,xmmrm128,imm8 [rvmi:t2: evex.nds.512.66.0f3a.w1 18 /r ib ] AVX512DQ,FUTURE
+VINSERTF64X4    zmmreg|mask|z,zmmreg*,ymmrm256,imm8 [rvmi:t4: evex.nds.512.66.0f3a.w1 1a /r ib ] AVX512,FUTURE
+VINSERTI32X4    ymmreg|mask|z,ymmreg*,xmmrm128,imm8 [rvmi:t4: evex.nds.256.66.0f3a.w0 38 /r ib ] AVX512VL,AVX512,FUTURE
+VINSERTI32X4    zmmreg|mask|z,zmmreg*,xmmrm128,imm8 [rvmi:t4: evex.nds.512.66.0f3a.w0 38 /r ib ] AVX512,FUTURE
+VINSERTI32X8    zmmreg|mask|z,zmmreg*,ymmrm256,imm8 [rvmi:t8: evex.nds.512.66.0f3a.w0 3a /r ib ] AVX512DQ,FUTURE
+VINSERTI64X2    ymmreg|mask|z,ymmreg*,xmmrm128,imm8 [rvmi:t2: evex.nds.256.66.0f3a.w1 38 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VINSERTI64X2    zmmreg|mask|z,zmmreg*,xmmrm128,imm8 [rvmi:t2: evex.nds.512.66.0f3a.w1 38 /r ib ] AVX512DQ,FUTURE
+VINSERTI64X4    zmmreg|mask|z,zmmreg*,ymmrm256,imm8 [rvmi:t4: evex.nds.512.66.0f3a.w1 3a /r ib ] AVX512,FUTURE
+VINSERTPS       xmmreg,xmmreg*,xmmrm32,imm8         [rvmi:t1s: evex.nds.128.66.0f3a.w0 21 /r ib ] AVX512,FUTURE
+VMAXPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 5f /r ] AVX512VL,AVX512,FUTURE
+VMAXPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 5f /r ] AVX512VL,AVX512,FUTURE
+VMAXPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64|sae [rvm:fv: evex.nds.512.66.0f.w1 5f /r ] AVX512,FUTURE
+VMAXPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 5f /r ] AVX512VL,AVX512,FUTURE
+VMAXPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 5f /r ] AVX512VL,AVX512,FUTURE
+VMAXPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32|sae [rvm:fv: evex.nds.512.0f.w0 5f /r ] AVX512,FUTURE
+VMAXSD          xmmreg|mask|z,xmmreg*,xmmrm64|sae   [rvm:t1s: evex.nds.128.f2.0f.w1 5f /r ] AVX512,FUTURE
+VMAXSS          xmmreg|mask|z,xmmreg*,xmmrm32|sae   [rvm:t1s: evex.nds.128.f3.0f.w0 5f /r ] AVX512,FUTURE
+VMINPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 5d /r ] AVX512VL,AVX512,FUTURE
+VMINPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 5d /r ] AVX512VL,AVX512,FUTURE
+VMINPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64|sae [rvm:fv: evex.nds.512.66.0f.w1 5d /r ] AVX512,FUTURE
+VMINPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 5d /r ] AVX512VL,AVX512,FUTURE
+VMINPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 5d /r ] AVX512VL,AVX512,FUTURE
+VMINPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32|sae [rvm:fv: evex.nds.512.0f.w0 5d /r ] AVX512,FUTURE
+VMINSD          xmmreg|mask|z,xmmreg*,xmmrm64|sae   [rvm:t1s: evex.nds.128.f2.0f.w1 5d /r ] AVX512,FUTURE
+VMINSS          xmmreg|mask|z,xmmreg*,xmmrm32|sae   [rvm:t1s: evex.nds.128.f3.0f.w0 5d /r ] AVX512,FUTURE
+VMOVAPD         xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.66.0f.w1 28 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPD         ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.66.0f.w1 28 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPD         zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.66.0f.w1 28 /r ] AVX512,FUTURE
+VMOVAPD         xmmreg|mask|z,xmmreg                [mr: evex.128.66.0f.w1 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPD         ymmreg|mask|z,ymmreg                [mr: evex.256.66.0f.w1 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPD         zmmreg|mask|z,zmmreg                [mr: evex.512.66.0f.w1 29 /r ] AVX512,FUTURE
+VMOVAPD         mem128|mask,xmmreg                  [mr:fvm: evex.128.66.0f.w1 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPD         mem256|mask,ymmreg                  [mr:fvm: evex.256.66.0f.w1 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPD         mem512|mask,zmmreg                  [mr:fvm: evex.512.66.0f.w1 29 /r ] AVX512,FUTURE
+VMOVAPS         xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.0f.w0 28 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPS         ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.0f.w0 28 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPS         zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.0f.w0 28 /r ] AVX512,FUTURE
+VMOVAPS         xmmreg|mask|z,xmmreg                [mr: evex.128.0f.w0 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPS         ymmreg|mask|z,ymmreg                [mr: evex.256.0f.w0 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPS         zmmreg|mask|z,zmmreg                [mr: evex.512.0f.w0 29 /r ] AVX512,FUTURE
+VMOVAPS         mem128|mask,xmmreg                  [mr:fvm: evex.128.0f.w0 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPS         mem256|mask,ymmreg                  [mr:fvm: evex.256.0f.w0 29 /r ] AVX512VL,AVX512,FUTURE
+VMOVAPS         mem512|mask,zmmreg                  [mr:fvm: evex.512.0f.w0 29 /r ] AVX512,FUTURE
+VMOVD           xmmreg,rm32                         [rm:t1s: evex.128.66.0f.w0 6e /r ] AVX512,FUTURE
+VMOVD           rm32,xmmreg                         [mr:t1s: evex.128.66.0f.w0 7e /r ] AVX512,FUTURE
+VMOVDDUP        xmmreg|mask|z,xmmrm64               [rm:dup: evex.128.f2.0f.w1 12 /r ] AVX512VL,AVX512,FUTURE
+VMOVDDUP        ymmreg|mask|z,ymmrm256              [rm:dup: evex.256.f2.0f.w1 12 /r ] AVX512VL,AVX512,FUTURE
+VMOVDDUP        zmmreg|mask|z,zmmrm512              [rm:dup: evex.512.f2.0f.w1 12 /r ] AVX512,FUTURE
+VMOVDQA32       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.66.0f.w0 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA32       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.66.0f.w0 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA32       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.66.0f.w0 6f /r ] AVX512,FUTURE
+VMOVDQA32       xmmrm128|mask|z,xmmreg              [mr:fvm: evex.128.66.0f.w0 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA32       ymmrm256|mask|z,ymmreg              [mr:fvm: evex.256.66.0f.w0 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA32       zmmrm512|mask|z,zmmreg              [mr:fvm: evex.512.66.0f.w0 7f /r ] AVX512,FUTURE
+VMOVDQA64       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.66.0f.w1 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA64       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.66.0f.w1 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA64       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.66.0f.w1 6f /r ] AVX512,FUTURE
+VMOVDQA64       xmmrm128|mask|z,xmmreg              [mr:fvm: evex.128.66.0f.w1 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA64       ymmrm256|mask|z,ymmreg              [mr:fvm: evex.256.66.0f.w1 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQA64       zmmrm512|mask|z,zmmreg              [mr:fvm: evex.512.66.0f.w1 7f /r ] AVX512,FUTURE
+VMOVDQU16       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.f2.0f.w1 6f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU16       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.f2.0f.w1 6f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU16       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.f2.0f.w1 6f /r ] AVX512BW,FUTURE
+VMOVDQU16       xmmrm128|mask|z,xmmreg              [mr:fvm: evex.128.f2.0f.w1 7f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU16       ymmrm256|mask|z,ymmreg              [mr:fvm: evex.256.f2.0f.w1 7f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU16       zmmrm512|mask|z,zmmreg              [mr:fvm: evex.512.f2.0f.w1 7f /r ] AVX512BW,FUTURE
+VMOVDQU32       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.f3.0f.w0 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU32       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.f3.0f.w0 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU32       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.f3.0f.w0 6f /r ] AVX512,FUTURE
+VMOVDQU32       xmmrm128|mask|z,xmmreg              [mr:fvm: evex.128.f3.0f.w0 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU32       ymmrm256|mask|z,ymmreg              [mr:fvm: evex.256.f3.0f.w0 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU32       zmmrm512|mask|z,zmmreg              [mr:fvm: evex.512.f3.0f.w0 7f /r ] AVX512,FUTURE
+VMOVDQU64       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.f3.0f.w1 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU64       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.f3.0f.w1 6f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU64       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.f3.0f.w1 6f /r ] AVX512,FUTURE
+VMOVDQU64       xmmrm128|mask|z,xmmreg              [mr:fvm: evex.128.f3.0f.w1 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU64       ymmrm256|mask|z,ymmreg              [mr:fvm: evex.256.f3.0f.w1 7f /r ] AVX512VL,AVX512,FUTURE
+VMOVDQU64       zmmrm512|mask|z,zmmreg              [mr:fvm: evex.512.f3.0f.w1 7f /r ] AVX512,FUTURE
+VMOVDQU8        xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.f2.0f.w0 6f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU8        ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.f2.0f.w0 6f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU8        zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.f2.0f.w0 6f /r ] AVX512BW,FUTURE
+VMOVDQU8        xmmrm128|mask|z,xmmreg              [mr:fvm: evex.128.f2.0f.w0 7f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU8        ymmrm256|mask|z,ymmreg              [mr:fvm: evex.256.f2.0f.w0 7f /r ] AVX512VL,AVX512BW,FUTURE
+VMOVDQU8        zmmrm512|mask|z,zmmreg              [mr:fvm: evex.512.f2.0f.w0 7f /r ] AVX512BW,FUTURE
+VMOVHLPS        xmmreg,xmmreg*,xmmreg               [rvm: evex.nds.128.0f.w0 12 /r ] AVX512,FUTURE
+VMOVHPD         xmmreg,xmmreg*,mem64                [rvm:t1s: evex.nds.128.66.0f.w1 16 /r ] AVX512,FUTURE
+VMOVHPD         mem64,xmmreg                        [mr:t1s: evex.128.66.0f.w1 17 /r ] AVX512,FUTURE
+VMOVHPS         xmmreg,xmmreg*,mem64                [rvm:t2: evex.nds.128.0f.w0 16 /r ] AVX512,FUTURE
+VMOVHPS         mem64,xmmreg                        [mr:t2: evex.128.0f.w0 17 /r ] AVX512,FUTURE
+VMOVLHPS        xmmreg,xmmreg*,xmmreg               [rvm: evex.nds.128.0f.w0 16 /r ] AVX512,FUTURE
+VMOVLPD         xmmreg,xmmreg*,mem64                [rvm:t1s: evex.nds.128.66.0f.w1 12 /r ] AVX512,FUTURE
+VMOVLPD         mem64,xmmreg                        [mr:t1s: evex.128.66.0f.w1 13 /r ] AVX512,FUTURE
+VMOVLPS         xmmreg,xmmreg*,mem64                [rvm:t2: evex.nds.128.0f.w0 12 /r ] AVX512,FUTURE
+VMOVLPS         mem64,xmmreg                        [mr:t2: evex.128.0f.w0 13 /r ] AVX512,FUTURE
+VMOVNTDQ        mem128,xmmreg                       [mr:fvm: evex.128.66.0f.w0 e7 /r ] AVX512VL,AVX512,FUTURE
+VMOVNTDQ        mem256,ymmreg                       [mr:fvm: evex.256.66.0f.w0 e7 /r ] AVX512VL,AVX512,FUTURE
+VMOVNTDQ        mem512,zmmreg                       [mr:fvm: evex.512.66.0f.w0 e7 /r ] AVX512,FUTURE
+VMOVNTDQA       xmmreg,mem128                       [rm:fvm: evex.128.66.0f38.w0 2a /r ] AVX512VL,AVX512,FUTURE
+VMOVNTDQA       ymmreg,mem256                       [rm:fvm: evex.256.66.0f38.w0 2a /r ] AVX512VL,AVX512,FUTURE
+VMOVNTDQA       zmmreg,mem512                       [rm:fvm: evex.512.66.0f38.w0 2a /r ] AVX512,FUTURE
+VMOVNTPD        mem128,xmmreg                       [mr:fvm: evex.128.66.0f.w1 2b /r ] AVX512VL,AVX512,FUTURE
+VMOVNTPD        mem256,ymmreg                       [mr:fvm: evex.256.66.0f.w1 2b /r ] AVX512VL,AVX512,FUTURE
+VMOVNTPD        mem512,zmmreg                       [mr:fvm: evex.512.66.0f.w1 2b /r ] AVX512,FUTURE
+VMOVNTPS        mem128,xmmreg                       [mr:fvm: evex.128.0f.w0 2b /r ] AVX512VL,AVX512,FUTURE
+VMOVNTPS        mem256,ymmreg                       [mr:fvm: evex.256.0f.w0 2b /r ] AVX512VL,AVX512,FUTURE
+VMOVNTPS        mem512,zmmreg                       [mr:fvm: evex.512.0f.w0 2b /r ] AVX512,FUTURE
+VMOVQ           xmmreg,rm64                         [rm:t1s: evex.128.66.0f.w1 6e /r ] AVX512,FUTURE
+VMOVQ           rm64,xmmreg                         [mr:t1s: evex.128.66.0f.w1 7e /r ] AVX512,FUTURE
+VMOVQ           xmmreg,xmmrm64                      [rm:t1s: evex.128.f3.0f.w1 7e /r ] AVX512,FUTURE
+VMOVQ           xmmrm64,xmmreg                      [mr:t1s: evex.128.66.0f.w1 d6 /r ] AVX512,FUTURE
+VMOVSD          xmmreg|mask|z,mem64                 [rm:t1s: evex.128.f2.0f.w1 10 /r ] AVX512,FUTURE
+VMOVSD          mem64|mask,xmmreg                   [mr:t1s: evex.128.f2.0f.w1 11 /r ] AVX512,FUTURE
+VMOVSD          xmmreg|mask|z,xmmreg*,xmmreg        [rvm: evex.nds.128.f2.0f.w1 10 /r ] AVX512,FUTURE
+VMOVSD          xmmreg|mask|z,xmmreg*,xmmreg        [mvr: evex.nds.128.f2.0f.w1 11 /r ] AVX512,FUTURE
+VMOVSHDUP       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.f3.0f.w0 16 /r ] AVX512VL,AVX512,FUTURE
+VMOVSHDUP       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.f3.0f.w0 16 /r ] AVX512VL,AVX512,FUTURE
+VMOVSHDUP       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.f3.0f.w0 16 /r ] AVX512,FUTURE
+VMOVSLDUP       xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.f3.0f.w0 12 /r ] AVX512VL,AVX512,FUTURE
+VMOVSLDUP       ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.f3.0f.w0 12 /r ] AVX512VL,AVX512,FUTURE
+VMOVSLDUP       zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.f3.0f.w0 12 /r ] AVX512,FUTURE
+VMOVSS          xmmreg|mask|z,mem32                 [rm:t1s: evex.128.f3.0f.w0 10 /r ] AVX512,FUTURE
+VMOVSS          mem32|mask,xmmreg                   [mr:t1s: evex.128.f3.0f.w0 11 /r ] AVX512,FUTURE
+VMOVSS          xmmreg|mask|z,xmmreg*,xmmreg        [rvm: evex.nds.128.f3.0f.w0 10 /r ] AVX512,FUTURE
+VMOVSS          xmmreg|mask|z,xmmreg*,xmmreg        [mvr: evex.nds.128.f3.0f.w0 11 /r ] AVX512,FUTURE
+VMOVUPD         xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.66.0f.w1 10 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPD         ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.66.0f.w1 10 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPD         zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.66.0f.w1 10 /r ] AVX512,FUTURE
+VMOVUPD         xmmreg|mask|z,xmmreg                [mr: evex.128.66.0f.w1 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPD         ymmreg|mask|z,ymmreg                [mr: evex.256.66.0f.w1 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPD         zmmreg|mask|z,zmmreg                [mr: evex.512.66.0f.w1 11 /r ] AVX512,FUTURE
+VMOVUPD         mem128|mask,xmmreg                  [mr:fvm: evex.128.66.0f.w1 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPD         mem256|mask,ymmreg                  [mr:fvm: evex.256.66.0f.w1 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPD         mem512|mask,zmmreg                  [mr:fvm: evex.512.66.0f.w1 11 /r ] AVX512,FUTURE
+VMOVUPS         xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.0f.w0 10 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPS         ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.0f.w0 10 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPS         zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.0f.w0 10 /r ] AVX512,FUTURE
+VMOVUPS         xmmreg|mask|z,xmmreg                [mr: evex.128.0f.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPS         ymmreg|mask|z,ymmreg                [mr: evex.256.0f.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPS         zmmreg|mask|z,zmmreg                [mr: evex.512.0f.w0 11 /r ] AVX512,FUTURE
+VMOVUPS         mem128|mask,xmmreg                  [mr:fvm: evex.128.0f.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPS         mem256|mask,ymmreg                  [mr:fvm: evex.256.0f.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VMOVUPS         mem512|mask,zmmreg                  [mr:fvm: evex.512.0f.w0 11 /r ] AVX512,FUTURE
+VMULPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 59 /r ] AVX512VL,AVX512,FUTURE
+VMULPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 59 /r ] AVX512VL,AVX512,FUTURE
+VMULPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f.w1 59 /r ] AVX512,FUTURE
+VMULPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 59 /r ] AVX512VL,AVX512,FUTURE
+VMULPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 59 /r ] AVX512VL,AVX512,FUTURE
+VMULPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32|er [rvm:fv: evex.nds.512.0f.w0 59 /r ] AVX512,FUTURE
+VMULSD          xmmreg|mask|z,xmmreg*,xmmrm64|er    [rvm:t1s: evex.nds.128.f2.0f.w1 59 /r ] AVX512,FUTURE
+VMULSS          xmmreg|mask|z,xmmreg*,xmmrm32|er    [rvm:t1s: evex.nds.128.f3.0f.w0 59 /r ] AVX512,FUTURE
+VORPD           xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 56 /r ] AVX512VL,AVX512DQ,FUTURE
+VORPD           ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 56 /r ] AVX512VL,AVX512DQ,FUTURE
+VORPD           zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 56 /r ] AVX512DQ,FUTURE
+VORPS           xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 56 /r ] AVX512VL,AVX512DQ,FUTURE
+VORPS           ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 56 /r ] AVX512VL,AVX512DQ,FUTURE
+VORPS           zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.0f.w0 56 /r ] AVX512DQ,FUTURE
+VPABSB          xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.66.0f38.wig 1c /r ] AVX512VL,AVX512BW,FUTURE
+VPABSB          ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.66.0f38.wig 1c /r ] AVX512VL,AVX512BW,FUTURE
+VPABSB          zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.66.0f38.wig 1c /r ] AVX512BW,FUTURE
+VPABSD          xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f38.w0 1e /r ] AVX512VL,AVX512,FUTURE
+VPABSD          ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f38.w0 1e /r ] AVX512VL,AVX512,FUTURE
+VPABSD          zmmreg|mask|z,zmmrm512|b32          [rm:fv: evex.512.66.0f38.w0 1e /r ] AVX512,FUTURE
+VPABSQ          xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f38.w1 1f /r ] AVX512VL,AVX512,FUTURE
+VPABSQ          ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f38.w1 1f /r ] AVX512VL,AVX512,FUTURE
+VPABSQ          zmmreg|mask|z,zmmrm512|b64          [rm:fv: evex.512.66.0f38.w1 1f /r ] AVX512,FUTURE
+VPABSW          xmmreg|mask|z,xmmrm128              [rm:fvm: evex.128.66.0f38.wig 1d /r ] AVX512VL,AVX512BW,FUTURE
+VPABSW          ymmreg|mask|z,ymmrm256              [rm:fvm: evex.256.66.0f38.wig 1d /r ] AVX512VL,AVX512BW,FUTURE
+VPABSW          zmmreg|mask|z,zmmrm512              [rm:fvm: evex.512.66.0f38.wig 1d /r ] AVX512BW,FUTURE
+VPACKSSDW       xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 6b /r ] AVX512VL,AVX512BW,FUTURE
+VPACKSSDW       ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 6b /r ] AVX512VL,AVX512BW,FUTURE
+VPACKSSDW       zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 6b /r ] AVX512BW,FUTURE
+VPACKSSWB       xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig 63 /r ] AVX512VL,AVX512BW,FUTURE
+VPACKSSWB       ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig 63 /r ] AVX512VL,AVX512BW,FUTURE
+VPACKSSWB       zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig 63 /r ] AVX512BW,FUTURE
+VPACKUSDW       xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 2b /r ] AVX512VL,AVX512BW,FUTURE
+VPACKUSDW       ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 2b /r ] AVX512VL,AVX512BW,FUTURE
+VPACKUSDW       zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 2b /r ] AVX512BW,FUTURE
+VPACKUSWB       xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig 67 /r ] AVX512VL,AVX512BW,FUTURE
+VPACKUSWB       ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig 67 /r ] AVX512VL,AVX512BW,FUTURE
+VPACKUSWB       zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig 67 /r ] AVX512BW,FUTURE
+VPADDB          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig fc /r ] AVX512VL,AVX512BW,FUTURE
+VPADDB          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig fc /r ] AVX512VL,AVX512BW,FUTURE
+VPADDB          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig fc /r ] AVX512BW,FUTURE
+VPADDD          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 fe /r ] AVX512VL,AVX512,FUTURE
+VPADDD          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 fe /r ] AVX512VL,AVX512,FUTURE
+VPADDD          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 fe /r ] AVX512,FUTURE
+VPADDQ          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 d4 /r ] AVX512VL,AVX512,FUTURE
+VPADDQ          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 d4 /r ] AVX512VL,AVX512,FUTURE
+VPADDQ          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 d4 /r ] AVX512,FUTURE
+VPADDSB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig ec /r ] AVX512VL,AVX512BW,FUTURE
+VPADDSB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig ec /r ] AVX512VL,AVX512BW,FUTURE
+VPADDSB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig ec /r ] AVX512BW,FUTURE
+VPADDSW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig ed /r ] AVX512VL,AVX512BW,FUTURE
+VPADDSW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig ed /r ] AVX512VL,AVX512BW,FUTURE
+VPADDSW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig ed /r ] AVX512BW,FUTURE
+VPADDUSB        xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig dc /r ] AVX512VL,AVX512BW,FUTURE
+VPADDUSB        ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig dc /r ] AVX512VL,AVX512BW,FUTURE
+VPADDUSB        zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig dc /r ] AVX512BW,FUTURE
+VPADDUSW        xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig dd /r ] AVX512VL,AVX512BW,FUTURE
+VPADDUSW        ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig dd /r ] AVX512VL,AVX512BW,FUTURE
+VPADDUSW        zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig dd /r ] AVX512BW,FUTURE
+VPADDW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig fd /r ] AVX512VL,AVX512BW,FUTURE
+VPADDW          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig fd /r ] AVX512VL,AVX512BW,FUTURE
+VPADDW          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig fd /r ] AVX512BW,FUTURE
+VPALIGNR        xmmreg|mask|z,xmmreg*,xmmrm128,imm8 [rvmi:fvm: evex.nds.128.66.0f3a.wig 0f /r ib ] AVX512VL,AVX512BW,FUTURE
+VPALIGNR        ymmreg|mask|z,ymmreg*,ymmrm256,imm8 [rvmi:fvm: evex.nds.256.66.0f3a.wig 0f /r ib ] AVX512VL,AVX512BW,FUTURE
+VPALIGNR        zmmreg|mask|z,zmmreg*,zmmrm512,imm8 [rvmi:fvm: evex.nds.512.66.0f3a.wig 0f /r ib ] AVX512BW,FUTURE
+VPANDD          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 db /r ] AVX512VL,AVX512,FUTURE
+VPANDD          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 db /r ] AVX512VL,AVX512,FUTURE
+VPANDD          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 db /r ] AVX512,FUTURE
+VPANDND         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 df /r ] AVX512VL,AVX512,FUTURE
+VPANDND         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 df /r ] AVX512VL,AVX512,FUTURE
+VPANDND         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 df /r ] AVX512,FUTURE
+VPANDNQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 df /r ] AVX512VL,AVX512,FUTURE
+VPANDNQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 df /r ] AVX512VL,AVX512,FUTURE
+VPANDNQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 df /r ] AVX512,FUTURE
+VPANDQ          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 db /r ] AVX512VL,AVX512,FUTURE
+VPANDQ          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 db /r ] AVX512VL,AVX512,FUTURE
+VPANDQ          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 db /r ] AVX512,FUTURE
+VPAVGB          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig e0 /r ] AVX512VL,AVX512BW,FUTURE
+VPAVGB          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig e0 /r ] AVX512VL,AVX512BW,FUTURE
+VPAVGB          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig e0 /r ] AVX512BW,FUTURE
+VPAVGW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig e3 /r ] AVX512VL,AVX512BW,FUTURE
+VPAVGW          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig e3 /r ] AVX512VL,AVX512BW,FUTURE
+VPAVGW          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig e3 /r ] AVX512BW,FUTURE
+VPBLENDMB       xmmreg|mask|z,xmmreg,xmmrm128       [rvm:fvm: evex.nds.128.66.0f38.w0 66 /r ] AVX512VL,AVX512BW,FUTURE
+VPBLENDMB       ymmreg|mask|z,ymmreg,ymmrm256       [rvm:fvm: evex.nds.256.66.0f38.w0 66 /r ] AVX512VL,AVX512BW,FUTURE
+VPBLENDMB       zmmreg|mask|z,zmmreg,zmmrm512       [rvm:fvm: evex.nds.512.66.0f38.w0 66 /r ] AVX512BW,FUTURE
+VPBLENDMD       xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 64 /r ] AVX512VL,AVX512,FUTURE
+VPBLENDMD       ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 64 /r ] AVX512VL,AVX512,FUTURE
+VPBLENDMD       zmmreg|mask|z,zmmreg,zmmrm512|b32   [rvm:fv: evex.nds.512.66.0f38.w0 64 /r ] AVX512,FUTURE
+VPBLENDMQ       xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 64 /r ] AVX512VL,AVX512,FUTURE
+VPBLENDMQ       ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 64 /r ] AVX512VL,AVX512,FUTURE
+VPBLENDMQ       zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 64 /r ] AVX512,FUTURE
+VPBLENDMW       xmmreg|mask|z,xmmreg,xmmrm128       [rvm:fvm: evex.nds.128.66.0f38.w1 66 /r ] AVX512VL,AVX512BW,FUTURE
+VPBLENDMW       ymmreg|mask|z,ymmreg,ymmrm256       [rvm:fvm: evex.nds.256.66.0f38.w1 66 /r ] AVX512VL,AVX512BW,FUTURE
+VPBLENDMW       zmmreg|mask|z,zmmreg,zmmrm512       [rvm:fvm: evex.nds.512.66.0f38.w1 66 /r ] AVX512BW,FUTURE
+VPBROADCASTB    xmmreg|mask|z,xmmrm8                [rm:t1s8: evex.128.66.0f38.w0 78 /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    ymmreg|mask|z,xmmrm8                [rm:t1s8: evex.256.66.0f38.w0 78 /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    zmmreg|mask|z,xmmrm8                [rm:t1s8: evex.512.66.0f38.w0 78 /r ] AVX512BW,FUTURE
+VPBROADCASTB    xmmreg|mask|z,reg8                  [rm: evex.128.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    xmmreg|mask|z,reg16                 [rm: evex.128.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    xmmreg|mask|z,reg32                 [rm: evex.128.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    xmmreg|mask|z,reg64                 [rm: evex.128.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    ymmreg|mask|z,reg8                  [rm: evex.256.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    ymmreg|mask|z,reg16                 [rm: evex.256.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    ymmreg|mask|z,reg32                 [rm: evex.256.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    ymmreg|mask|z,reg64                 [rm: evex.256.66.0f38.w0 7a /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTB    zmmreg|mask|z,reg8                  [rm: evex.512.66.0f38.w0 7a /r ] AVX512BW,FUTURE
+VPBROADCASTB    zmmreg|mask|z,reg16                 [rm: evex.512.66.0f38.w0 7a /r ] AVX512BW,FUTURE
+VPBROADCASTB    zmmreg|mask|z,reg32                 [rm: evex.512.66.0f38.w0 7a /r ] AVX512BW,FUTURE
+VPBROADCASTB    zmmreg|mask|z,reg64                 [rm: evex.512.66.0f38.w0 7a /r ] AVX512BW,FUTURE
+VPBROADCASTD    xmmreg|mask|z,mem32                 [rm:t1s: evex.128.66.0f38.w0 58 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTD    ymmreg|mask|z,mem32                 [rm:t1s: evex.256.66.0f38.w0 58 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTD    zmmreg|mask|z,mem32                 [rm:t1s: evex.512.66.0f38.w0 58 /r ] AVX512,FUTURE
+VPBROADCASTD    xmmreg|mask|z,xmmreg                [rm: evex.128.66.0f38.w0 58 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTD    ymmreg|mask|z,xmmreg                [rm: evex.256.66.0f38.w0 58 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTD    zmmreg|mask|z,xmmreg                [rm: evex.512.66.0f38.w0 58 /r ] AVX512,FUTURE
+VPBROADCASTD    xmmreg|mask|z,reg32                 [rm: evex.128.66.0f38.w0 7c /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTD    ymmreg|mask|z,reg32                 [rm: evex.256.66.0f38.w0 7c /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTD    zmmreg|mask|z,reg32                 [rm: evex.512.66.0f38.w0 7c /r ] AVX512,FUTURE
+VPBROADCASTMB2Q xmmreg,kreg                         [rm: evex.128.f3.0f38.w1 2a /r ] AVX512VL,AVX512CD,FUTURE
+VPBROADCASTMB2Q ymmreg,kreg                         [rm: evex.256.f3.0f38.w1 2a /r ] AVX512VL,AVX512CD,FUTURE
+VPBROADCASTMB2Q zmmreg,kreg                         [rm: evex.512.f3.0f38.w1 2a /r ] AVX512CD,FUTURE
+VPBROADCASTMW2D xmmreg,kreg                         [rm: evex.128.f3.0f38.w0 3a /r ] AVX512VL,AVX512CD,FUTURE
+VPBROADCASTMW2D ymmreg,kreg                         [rm: evex.256.f3.0f38.w0 3a /r ] AVX512VL,AVX512CD,FUTURE
+VPBROADCASTMW2D zmmreg,kreg                         [rm: evex.512.f3.0f38.w0 3a /r ] AVX512CD,FUTURE
+VPBROADCASTQ    xmmreg|mask|z,mem64                 [rm:t1s: evex.128.66.0f38.w1 59 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTQ    ymmreg|mask|z,mem64                 [rm:t1s: evex.256.66.0f38.w1 59 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTQ    zmmreg|mask|z,mem64                 [rm:t1s: evex.512.66.0f38.w1 59 /r ] AVX512,FUTURE
+VPBROADCASTQ    xmmreg|mask|z,xmmreg                [rm: evex.128.66.0f38.w1 59 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTQ    ymmreg|mask|z,xmmreg                [rm: evex.256.66.0f38.w1 59 /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTQ    zmmreg|mask|z,xmmreg                [rm: evex.512.66.0f38.w1 59 /r ] AVX512,FUTURE
+VPBROADCASTQ    xmmreg|mask|z,reg64                 [rm: evex.128.66.0f38.w1 7c /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTQ    ymmreg|mask|z,reg64                 [rm: evex.256.66.0f38.w1 7c /r ] AVX512VL,AVX512,FUTURE
+VPBROADCASTQ    zmmreg|mask|z,reg64                 [rm: evex.512.66.0f38.w1 7c /r ] AVX512,FUTURE
+VPBROADCASTW    xmmreg|mask|z,xmmrm16               [rm:t1s16: evex.128.66.0f38.w0 79 /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    ymmreg|mask|z,xmmrm16               [rm:t1s16: evex.256.66.0f38.w0 79 /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    zmmreg|mask|z,xmmrm16               [rm:t1s16: evex.512.66.0f38.w0 79 /r ] AVX512BW,FUTURE
+VPBROADCASTW    xmmreg|mask|z,reg16                 [rm: evex.128.66.0f38.w0 7b /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    xmmreg|mask|z,reg32                 [rm: evex.128.66.0f38.w0 7b /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    xmmreg|mask|z,reg64                 [rm: evex.128.66.0f38.w0 7b /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    ymmreg|mask|z,reg16                 [rm: evex.256.66.0f38.w0 7b /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    ymmreg|mask|z,reg32                 [rm: evex.256.66.0f38.w0 7b /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    ymmreg|mask|z,reg64                 [rm: evex.256.66.0f38.w0 7b /r ] AVX512VL,AVX512BW,FUTURE
+VPBROADCASTW    zmmreg|mask|z,reg16                 [rm: evex.512.66.0f38.w0 7b /r ] AVX512BW,FUTURE
+VPBROADCASTW    zmmreg|mask|z,reg32                 [rm: evex.512.66.0f38.w0 7b /r ] AVX512BW,FUTURE
+VPBROADCASTW    zmmreg|mask|z,reg64                 [rm: evex.512.66.0f38.w0 7b /r ] AVX512BW,FUTURE
+; VPCMPEQx and VPCMPGTx come in two flavors: SSE-like, and VPCMP with immediate. They are both
+; valid, but prefer the SSE version as it is one byte shorter.
+VPCMPEQB        kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.66.0f.wig 74 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQB        kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.66.0f.wig 74 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQB        kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.66.0f.wig 74 /r ] AVX512BW,FUTURE
+VPCMPEQD        kreg|mask,xmmreg,xmmrm128|b32       [rvm:fv: evex.nds.128.66.0f.w0 76 /r ] AVX512VL,AVX512,FUTURE
+VPCMPEQD        kreg|mask,ymmreg,ymmrm256|b32       [rvm:fv: evex.nds.256.66.0f.w0 76 /r ] AVX512VL,AVX512,FUTURE
+VPCMPEQD        kreg|mask,zmmreg,zmmrm512|b32       [rvm:fv: evex.nds.512.66.0f.w0 76 /r ] AVX512,FUTURE
+VPCMPEQQ        kreg|mask,xmmreg,xmmrm128|b64       [rvm:fv: evex.nds.128.66.0f38.w1 29 /r ] AVX512VL,AVX512,FUTURE
+VPCMPEQQ        kreg|mask,ymmreg,ymmrm256|b64       [rvm:fv: evex.nds.256.66.0f38.w1 29 /r ] AVX512VL,AVX512,FUTURE
+VPCMPEQQ        kreg|mask,zmmreg,zmmrm512|b64       [rvm:fv: evex.nds.512.66.0f38.w1 29 /r ] AVX512,FUTURE
+VPCMPEQW        kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.66.0f.wig 75 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQW        kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.66.0f.wig 75 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQW        kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.66.0f.wig 75 /r ] AVX512BW,FUTURE
+VPCMPGTB        kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.66.0f.wig 64 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTB        kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.66.0f.wig 64 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTB        kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.66.0f.wig 64 /r ] AVX512BW,FUTURE
+VPCMPGTD        kreg|mask,xmmreg,xmmrm128|b32       [rvm:fv: evex.nds.128.66.0f.w0 66 /r ] AVX512VL,AVX512,FUTURE
+VPCMPGTD        kreg|mask,ymmreg,ymmrm256|b32       [rvm:fv: evex.nds.256.66.0f.w0 66 /r ] AVX512VL,AVX512,FUTURE
+VPCMPGTD        kreg|mask,zmmreg,zmmrm512|b32       [rvm:fv: evex.nds.512.66.0f.w0 66 /r ] AVX512,FUTURE
+VPCMPGTQ        kreg|mask,xmmreg,xmmrm128|b64       [rvm:fv: evex.nds.128.66.0f38.w1 37 /r ] AVX512VL,AVX512,FUTURE
+VPCMPGTQ        kreg|mask,ymmreg,ymmrm256|b64       [rvm:fv: evex.nds.256.66.0f38.w1 37 /r ] AVX512VL,AVX512,FUTURE
+VPCMPGTQ        kreg|mask,zmmreg,zmmrm512|b64       [rvm:fv: evex.nds.512.66.0f38.w1 37 /r ] AVX512,FUTURE
+VPCMPGTW        kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.66.0f.wig 65 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTW        kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.66.0f.wig 65 /r ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTW        kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.66.0f.wig 65 /r ] AVX512BW,FUTURE
+; The systematic VPCMP with immediate instructions
+VPCMPEQB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 00 ] AVX512BW,FUTURE
+VPCMPEQD          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQD          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQD          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 00 ] AVX512,FUTURE
+VPCMPEQQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 00 ] AVX512,FUTURE
+VPCMPEQUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 00 ] AVX512BW,FUTURE
+VPCMPEQUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 00 ] AVX512,FUTURE
+VPCMPEQUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 00 ] AVX512VL,AVX512,FUTURE
+VPCMPEQUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 00 ] AVX512,FUTURE
+VPCMPEQUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 00 ] AVX512BW,FUTURE
+VPCMPEQW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 00 ] AVX512VL,AVX512BW,FUTURE
+VPCMPEQW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 00 ] AVX512BW,FUTURE
+VPCMPGEB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 05 ] AVX512BW,FUTURE
+VPCMPGED          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGED          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGED          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 05 ] AVX512,FUTURE
+VPCMPGEQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGEQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGEQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 05 ] AVX512,FUTURE
+VPCMPGEUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 05 ] AVX512BW,FUTURE
+VPCMPGEUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGEUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGEUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 05 ] AVX512,FUTURE
+VPCMPGEUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGEUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPGEUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 05 ] AVX512,FUTURE
+VPCMPGEUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 05 ] AVX512BW,FUTURE
+VPCMPGEW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGEW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 05 ] AVX512BW,FUTURE
+VPCMPGTB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 06 ] AVX512BW,FUTURE
+VPCMPGTD          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTD          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTD          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 06 ] AVX512,FUTURE
+VPCMPGTQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 06 ] AVX512,FUTURE
+VPCMPGTUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 06 ] AVX512BW,FUTURE
+VPCMPGTUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 06 ] AVX512,FUTURE
+VPCMPGTUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPGTUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 06 ] AVX512,FUTURE
+VPCMPGTUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 06 ] AVX512BW,FUTURE
+VPCMPGTW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPGTW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 06 ] AVX512BW,FUTURE
+VPCMPLEB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 02 ] AVX512BW,FUTURE
+VPCMPLED          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLED          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLED          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 02 ] AVX512,FUTURE
+VPCMPLEQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLEQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLEQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 02 ] AVX512,FUTURE
+VPCMPLEUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 02 ] AVX512BW,FUTURE
+VPCMPLEUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLEUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLEUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 02 ] AVX512,FUTURE
+VPCMPLEUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLEUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPLEUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 02 ] AVX512,FUTURE
+VPCMPLEUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 02 ] AVX512BW,FUTURE
+VPCMPLEW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLEW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 02 ] AVX512BW,FUTURE
+VPCMPLTB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 01 ] AVX512BW,FUTURE
+VPCMPLTD          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTD          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTD          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 01 ] AVX512,FUTURE
+VPCMPLTQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 01 ] AVX512,FUTURE
+VPCMPLTUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 01 ] AVX512BW,FUTURE
+VPCMPLTUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 01 ] AVX512,FUTURE
+VPCMPLTUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 01 ] AVX512VL,AVX512,FUTURE
+VPCMPLTUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 01 ] AVX512,FUTURE
+VPCMPLTUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 01 ] AVX512BW,FUTURE
+VPCMPLTW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 01 ] AVX512VL,AVX512BW,FUTURE
+VPCMPLTW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 01 ] AVX512BW,FUTURE
+VPCMPNEQB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 04 ] AVX512BW,FUTURE
+VPCMPNEQD          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQD          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQD          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 04 ] AVX512,FUTURE
+VPCMPNEQQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 04 ] AVX512,FUTURE
+VPCMPNEQUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 04 ] AVX512BW,FUTURE
+VPCMPNEQUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 04 ] AVX512,FUTURE
+VPCMPNEQUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 04 ] AVX512VL,AVX512,FUTURE
+VPCMPNEQUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 04 ] AVX512,FUTURE
+VPCMPNEQUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 04 ] AVX512BW,FUTURE
+VPCMPNEQW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 04 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNEQW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 04 ] AVX512BW,FUTURE
+VPCMPNGTB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 02 ] AVX512BW,FUTURE
+VPCMPNGTD          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTD          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTD          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 02 ] AVX512,FUTURE
+VPCMPNGTQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 02 ] AVX512,FUTURE
+VPCMPNGTUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 02 ] AVX512BW,FUTURE
+VPCMPNGTUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 02 ] AVX512,FUTURE
+VPCMPNGTUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 02 ] AVX512VL,AVX512,FUTURE
+VPCMPNGTUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 02 ] AVX512,FUTURE
+VPCMPNGTUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 02 ] AVX512BW,FUTURE
+VPCMPNGTW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 02 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNGTW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 02 ] AVX512BW,FUTURE
+VPCMPNLEB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 06 ] AVX512BW,FUTURE
+VPCMPNLED          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLED          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLED          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 06 ] AVX512,FUTURE
+VPCMPNLEQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLEQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLEQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 06 ] AVX512,FUTURE
+VPCMPNLEUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 06 ] AVX512BW,FUTURE
+VPCMPNLEUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLEUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLEUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 06 ] AVX512,FUTURE
+VPCMPNLEUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLEUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 06 ] AVX512VL,AVX512,FUTURE
+VPCMPNLEUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 06 ] AVX512,FUTURE
+VPCMPNLEUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 06 ] AVX512BW,FUTURE
+VPCMPNLEW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 06 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLEW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 06 ] AVX512BW,FUTURE
+VPCMPNLTB          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTB          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTB          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r 05 ] AVX512BW,FUTURE
+VPCMPNLTD          kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTD          kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTD          kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r 05 ] AVX512,FUTURE
+VPCMPNLTQ          kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTQ          kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTQ          kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r 05 ] AVX512,FUTURE
+VPCMPNLTUB         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTUB         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTUB         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r 05 ] AVX512BW,FUTURE
+VPCMPNLTUD         kreg|mask,xmmreg,xmmrm128|b32  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTUD         kreg|mask,ymmreg,ymmrm256|b32  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTUD         kreg|mask,zmmreg,zmmrm512|b32  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r 05 ] AVX512,FUTURE
+VPCMPNLTUQ         kreg|mask,xmmreg,xmmrm128|b64  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTUQ         kreg|mask,ymmreg,ymmrm256|b64  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r 05 ] AVX512VL,AVX512,FUTURE
+VPCMPNLTUQ         kreg|mask,zmmreg,zmmrm512|b64  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r 05 ] AVX512,FUTURE
+VPCMPNLTUW         kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTUW         kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTUW         kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r 05 ] AVX512BW,FUTURE
+VPCMPNLTW          kreg|mask,xmmreg,xmmrm128      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTW          kreg|mask,ymmreg,ymmrm256      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r 05 ] AVX512VL,AVX512BW,FUTURE
+VPCMPNLTW          kreg|mask,zmmreg,zmmrm512      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r 05 ] AVX512BW,FUTURE
+VPCMPB          kreg|mask,xmmreg,xmmrm128,imm8      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3f /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPB          kreg|mask,ymmreg,ymmrm256,imm8      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3f /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPB          kreg|mask,zmmreg,zmmrm512,imm8      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3f /r ib ] AVX512BW,FUTURE
+VPCMPD          kreg|mask,xmmreg,xmmrm128|b32,imm8  [rvmi:fv: evex.nds.128.66.0f3a.w0 1f /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPD          kreg|mask,ymmreg,ymmrm256|b32,imm8  [rvmi:fv: evex.nds.256.66.0f3a.w0 1f /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPD          kreg|mask,zmmreg,zmmrm512|b32,imm8  [rvmi:fv: evex.nds.512.66.0f3a.w0 1f /r ib ] AVX512,FUTURE
+VPCMPQ          kreg|mask,xmmreg,xmmrm128|b64,imm8  [rvmi:fv: evex.nds.128.66.0f3a.w1 1f /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPQ          kreg|mask,ymmreg,ymmrm256|b64,imm8  [rvmi:fv: evex.nds.256.66.0f3a.w1 1f /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPQ          kreg|mask,zmmreg,zmmrm512|b64,imm8  [rvmi:fv: evex.nds.512.66.0f3a.w1 1f /r ib ] AVX512,FUTURE
+VPCMPUB         kreg|mask,xmmreg,xmmrm128,imm8      [rvmi:fvm: evex.nds.128.66.0f3a.w0 3e /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPUB         kreg|mask,ymmreg,ymmrm256,imm8      [rvmi:fvm: evex.nds.256.66.0f3a.w0 3e /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPUB         kreg|mask,zmmreg,zmmrm512,imm8      [rvmi:fvm: evex.nds.512.66.0f3a.w0 3e /r ib ] AVX512BW,FUTURE
+VPCMPUD         kreg|mask,xmmreg,xmmrm128|b32,imm8  [rvmi:fv: evex.nds.128.66.0f3a.w0 1e /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPUD         kreg|mask,ymmreg,ymmrm256|b32,imm8  [rvmi:fv: evex.nds.256.66.0f3a.w0 1e /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPUD         kreg|mask,zmmreg,zmmrm512|b32,imm8  [rvmi:fv: evex.nds.512.66.0f3a.w0 1e /r ib ] AVX512,FUTURE
+VPCMPUQ         kreg|mask,xmmreg,xmmrm128|b64,imm8  [rvmi:fv: evex.nds.128.66.0f3a.w1 1e /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPUQ         kreg|mask,ymmreg,ymmrm256|b64,imm8  [rvmi:fv: evex.nds.256.66.0f3a.w1 1e /r ib ] AVX512VL,AVX512,FUTURE
+VPCMPUQ         kreg|mask,zmmreg,zmmrm512|b64,imm8  [rvmi:fv: evex.nds.512.66.0f3a.w1 1e /r ib ] AVX512,FUTURE
+VPCMPUW         kreg|mask,xmmreg,xmmrm128,imm8      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3e /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPUW         kreg|mask,ymmreg,ymmrm256,imm8      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3e /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPUW         kreg|mask,zmmreg,zmmrm512,imm8      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3e /r ib ] AVX512BW,FUTURE
+VPCMPW          kreg|mask,xmmreg,xmmrm128,imm8      [rvmi:fvm: evex.nds.128.66.0f3a.w1 3f /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPW          kreg|mask,ymmreg,ymmrm256,imm8      [rvmi:fvm: evex.nds.256.66.0f3a.w1 3f /r ib ] AVX512VL,AVX512BW,FUTURE
+VPCMPW          kreg|mask,zmmreg,zmmrm512,imm8      [rvmi:fvm: evex.nds.512.66.0f3a.w1 3f /r ib ] AVX512BW,FUTURE
+VPCOMPRESSD     mem128|mask,xmmreg                  [mr:t1s: evex.128.66.0f38.w0 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSD     mem256|mask,ymmreg                  [mr:t1s: evex.256.66.0f38.w0 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSD     mem512|mask,zmmreg                  [mr:t1s: evex.512.66.0f38.w0 8b /r ] AVX512,FUTURE
+VPCOMPRESSD     xmmreg|mask|z,xmmreg                [mr: evex.128.66.0f38.w0 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSD     ymmreg|mask|z,ymmreg                [mr: evex.256.66.0f38.w0 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSD     zmmreg|mask|z,zmmreg                [mr: evex.512.66.0f38.w0 8b /r ] AVX512,FUTURE
+VPCOMPRESSQ     mem128|mask,xmmreg                  [mr:t1s: evex.128.66.0f38.w1 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSQ     mem256|mask,ymmreg                  [mr:t1s: evex.256.66.0f38.w1 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSQ     mem512|mask,zmmreg                  [mr:t1s: evex.512.66.0f38.w1 8b /r ] AVX512,FUTURE
+VPCOMPRESSQ     xmmreg|mask|z,xmmreg                [mr: evex.128.66.0f38.w1 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSQ     ymmreg|mask|z,ymmreg                [mr: evex.256.66.0f38.w1 8b /r ] AVX512VL,AVX512,FUTURE
+VPCOMPRESSQ     zmmreg|mask|z,zmmreg                [mr: evex.512.66.0f38.w1 8b /r ] AVX512,FUTURE
+VPCONFLICTD     xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f38.w0 c4 /r ] AVX512VL,AVX512CD,FUTURE
+VPCONFLICTD     ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f38.w0 c4 /r ] AVX512VL,AVX512CD,FUTURE
+VPCONFLICTD     zmmreg|mask|z,zmmrm512|b32          [rm:fv: evex.512.66.0f38.w0 c4 /r ] AVX512CD,FUTURE
+VPCONFLICTQ     xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f38.w1 c4 /r ] AVX512VL,AVX512CD,FUTURE
+VPCONFLICTQ     ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f38.w1 c4 /r ] AVX512VL,AVX512CD,FUTURE
+VPCONFLICTQ     zmmreg|mask|z,zmmrm512|b64          [rm:fv: evex.512.66.0f38.w1 c4 /r ] AVX512CD,FUTURE
+VPERMB          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.w0 8d /r ] AVX512VL,AVX512VBMI,FUTURE
+VPERMB          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.w0 8d /r ] AVX512VL,AVX512VBMI,FUTURE
+VPERMB          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.w0 8d /r ] AVX512VBMI,FUTURE
+VPERMD          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 36 /r ] AVX512VL,AVX512,FUTURE
+VPERMD          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 36 /r ] AVX512,FUTURE
+VPERMI2B        xmmreg|mask|z,xmmreg,xmmrm128       [rvm:fvm: evex.nds.128.66.0f38.w0 75 /r ] AVX512VL,AVX512VBMI,FUTURE
+VPERMI2B        ymmreg|mask|z,ymmreg,ymmrm256       [rvm:fvm: evex.nds.256.66.0f38.w0 75 /r ] AVX512VL,AVX512VBMI,FUTURE
+VPERMI2B        zmmreg|mask|z,zmmreg,zmmrm512       [rvm:fvm: evex.nds.512.66.0f38.w0 75 /r ] AVX512VBMI,FUTURE
+VPERMI2D        xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 76 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2D        ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 76 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2D        zmmreg|mask|z,zmmreg,zmmrm512|b32   [rvm:fv: evex.nds.512.66.0f38.w0 76 /r ] AVX512,FUTURE
+VPERMI2PD       xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 77 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2PD       ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 77 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2PD       zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 77 /r ] AVX512,FUTURE
+VPERMI2PS       xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 77 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2PS       ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 77 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2PS       zmmreg|mask|z,zmmreg,zmmrm512|b32   [rvm:fv: evex.nds.512.66.0f38.w0 77 /r ] AVX512,FUTURE
+VPERMI2Q        xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 76 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2Q        ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 76 /r ] AVX512VL,AVX512,FUTURE
+VPERMI2Q        zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 76 /r ] AVX512,FUTURE
+VPERMI2W        xmmreg|mask|z,xmmreg,xmmrm128       [rvm:fvm: evex.nds.128.66.0f38.w1 75 /r ] AVX512VL,AVX512BW,FUTURE
+VPERMI2W        ymmreg|mask|z,ymmreg,ymmrm256       [rvm:fvm: evex.nds.256.66.0f38.w1 75 /r ] AVX512VL,AVX512BW,FUTURE
+VPERMI2W        zmmreg|mask|z,zmmreg,zmmrm512       [rvm:fvm: evex.nds.512.66.0f38.w1 75 /r ] AVX512BW,FUTURE
+VPERMILPD       xmmreg|mask|z,xmmrm128|b64,imm8     [rmi:fv: evex.128.66.0f3a.w1 05 /r ib ] AVX512VL,AVX512,FUTURE
+VPERMILPD       ymmreg|mask|z,ymmrm256|b64,imm8     [rmi:fv: evex.256.66.0f3a.w1 05 /r ib ] AVX512VL,AVX512,FUTURE
+VPERMILPD       zmmreg|mask|z,zmmrm512|b64,imm8     [rmi:fv: evex.512.66.0f3a.w1 05 /r ib ] AVX512,FUTURE
+VPERMILPD       xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 0d /r ] AVX512VL,AVX512,FUTURE
+VPERMILPD       ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 0d /r ] AVX512VL,AVX512,FUTURE
+VPERMILPD       zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 0d /r ] AVX512,FUTURE
+VPERMILPS       xmmreg|mask|z,xmmrm128|b32,imm8     [rmi:fv: evex.128.66.0f3a.w0 04 /r ib ] AVX512VL,AVX512,FUTURE
+VPERMILPS       ymmreg|mask|z,ymmrm256|b32,imm8     [rmi:fv: evex.256.66.0f3a.w0 04 /r ib ] AVX512VL,AVX512,FUTURE
+VPERMILPS       zmmreg|mask|z,zmmrm512|b32,imm8     [rmi:fv: evex.512.66.0f3a.w0 04 /r ib ] AVX512,FUTURE
+VPERMILPS       xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 0c /r ] AVX512VL,AVX512,FUTURE
+VPERMILPS       ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 0c /r ] AVX512VL,AVX512,FUTURE
+VPERMILPS       zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 0c /r ] AVX512,FUTURE
+VPERMPD         ymmreg|mask|z,ymmrm256|b64,imm8     [rmi:fv: evex.256.66.0f3a.w1 01 /r ib ] AVX512VL,AVX512,FUTURE
+VPERMPD         zmmreg|mask|z,zmmrm512|b64,imm8     [rmi:fv: evex.512.66.0f3a.w1 01 /r ib ] AVX512,FUTURE
+VPERMPD         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 16 /r ] AVX512VL,AVX512,FUTURE
+VPERMPD         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 16 /r ] AVX512,FUTURE
+VPERMPS         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 16 /r ] AVX512VL,AVX512,FUTURE
+VPERMPS         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 16 /r ] AVX512,FUTURE
+VPERMQ          ymmreg|mask|z,ymmrm256|b64,imm8     [rmi:fv: evex.256.66.0f3a.w1 00 /r ib ] AVX512VL,AVX512,FUTURE
+VPERMQ          zmmreg|mask|z,zmmrm512|b64,imm8     [rmi:fv: evex.512.66.0f3a.w1 00 /r ib ] AVX512,FUTURE
+VPERMQ          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 36 /r ] AVX512VL,AVX512,FUTURE
+VPERMQ          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 36 /r ] AVX512,FUTURE
+VPERMT2B        xmmreg|mask|z,xmmreg,xmmrm128       [rvm:fvm: evex.nds.128.66.0f38.w0 7d /r ] AVX512VL,AVX512VBMI,FUTURE
+VPERMT2B        ymmreg|mask|z,ymmreg,ymmrm256       [rvm:fvm: evex.nds.256.66.0f38.w0 7d /r ] AVX512VL,AVX512VBMI,FUTURE
+VPERMT2B        zmmreg|mask|z,zmmreg,zmmrm512       [rvm:fvm: evex.nds.512.66.0f38.w0 7d /r ] AVX512VBMI,FUTURE
+VPERMT2D        xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 7e /r ] AVX512VL,AVX512,FUTURE
+VPERMT2D        ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 7e /r ] AVX512VL,AVX512,FUTURE
+VPERMT2D        zmmreg|mask|z,zmmreg,zmmrm512|b32   [rvm:fv: evex.nds.512.66.0f38.w0 7e /r ] AVX512,FUTURE
+VPERMT2PD       xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 7f /r ] AVX512VL,AVX512,FUTURE
+VPERMT2PD       ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 7f /r ] AVX512VL,AVX512,FUTURE
+VPERMT2PD       zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 7f /r ] AVX512,FUTURE
+VPERMT2PS       xmmreg|mask|z,xmmreg,xmmrm128|b32   [rvm:fv: evex.nds.128.66.0f38.w0 7f /r ] AVX512VL,AVX512,FUTURE
+VPERMT2PS       ymmreg|mask|z,ymmreg,ymmrm256|b32   [rvm:fv: evex.nds.256.66.0f38.w0 7f /r ] AVX512VL,AVX512,FUTURE
+VPERMT2PS       zmmreg|mask|z,zmmreg,zmmrm512|b32   [rvm:fv: evex.nds.512.66.0f38.w0 7f /r ] AVX512,FUTURE
+VPERMT2Q        xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 7e /r ] AVX512VL,AVX512,FUTURE
+VPERMT2Q        ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 7e /r ] AVX512VL,AVX512,FUTURE
+VPERMT2Q        zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 7e /r ] AVX512,FUTURE
+VPERMT2W        xmmreg|mask|z,xmmreg,xmmrm128       [rvm:fvm: evex.nds.128.66.0f38.w1 7d /r ] AVX512VL,AVX512BW,FUTURE
+VPERMT2W        ymmreg|mask|z,ymmreg,ymmrm256       [rvm:fvm: evex.nds.256.66.0f38.w1 7d /r ] AVX512VL,AVX512BW,FUTURE
+VPERMT2W        zmmreg|mask|z,zmmreg,zmmrm512       [rvm:fvm: evex.nds.512.66.0f38.w1 7d /r ] AVX512BW,FUTURE
+VPERMW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.w1 8d /r ] AVX512VL,AVX512BW,FUTURE
+VPERMW          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.w1 8d /r ] AVX512VL,AVX512BW,FUTURE
+VPERMW          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.w1 8d /r ] AVX512BW,FUTURE
+VPEXPANDD       xmmreg|mask|z,mem128                [rm:t1s: evex.128.66.0f38.w0 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDD       ymmreg|mask|z,mem256                [rm:t1s: evex.256.66.0f38.w0 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDD       zmmreg|mask|z,mem512                [rm:t1s: evex.512.66.0f38.w0 89 /r ] AVX512,FUTURE
+VPEXPANDD       xmmreg|mask|z,xmmreg                [rm:t1s: evex.128.66.0f38.w0 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDD       ymmreg|mask|z,ymmreg                [rm:t1s: evex.256.66.0f38.w0 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDD       zmmreg|mask|z,zmmreg                [rm:t1s: evex.512.66.0f38.w0 89 /r ] AVX512,FUTURE
+VPEXPANDQ       xmmreg|mask|z,mem128                [rm:t1s: evex.128.66.0f38.w1 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDQ       ymmreg|mask|z,mem256                [rm:t1s: evex.256.66.0f38.w1 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDQ       zmmreg|mask|z,mem512                [rm:t1s: evex.512.66.0f38.w1 89 /r ] AVX512,FUTURE
+VPEXPANDQ       xmmreg|mask|z,xmmreg                [rm:t1s: evex.128.66.0f38.w1 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDQ       ymmreg|mask|z,ymmreg                [rm:t1s: evex.256.66.0f38.w1 89 /r ] AVX512VL,AVX512,FUTURE
+VPEXPANDQ       zmmreg|mask|z,zmmreg                [rm:t1s: evex.512.66.0f38.w1 89 /r ] AVX512,FUTURE
+VPEXTRB         reg8,xmmreg,imm8                    [mri:t1s8: evex.128.66.0f3a.wig 14 /r ib ] AVX512BW,FUTURE
+VPEXTRB         reg16,xmmreg,imm8                   [mri:t1s8: evex.128.66.0f3a.wig 14 /r ib ] AVX512BW,FUTURE
+VPEXTRB         reg32,xmmreg,imm8                   [mri:t1s8: evex.128.66.0f3a.wig 14 /r ib ] AVX512BW,FUTURE
+VPEXTRB         reg64,xmmreg,imm8                   [mri:t1s8: evex.128.66.0f3a.wig 14 /r ib ] AVX512BW,FUTURE
+VPEXTRB         mem8,xmmreg,imm8                    [mri:t1s8: evex.128.66.0f3a.wig 14 /r ib ] AVX512BW,FUTURE
+VPEXTRD         rm32,xmmreg,imm8                    [mri:t1s: evex.128.66.0f3a.w0 16 /r ib ] AVX512DQ,FUTURE
+VPEXTRQ         rm64,xmmreg,imm8                    [mri:t1s: evex.128.66.0f3a.w1 16 /r ib ] AVX512DQ,FUTURE
+VPEXTRW         reg16,xmmreg,imm8                   [mri:t1s16: evex.128.66.0f3a.wig 15 /r ib ] AVX512BW,FUTURE
+VPEXTRW         reg32,xmmreg,imm8                   [mri:t1s16: evex.128.66.0f3a.wig 15 /r ib ] AVX512BW,FUTURE
+VPEXTRW         reg64,xmmreg,imm8                   [mri:t1s16: evex.128.66.0f3a.wig 15 /r ib ] AVX512BW,FUTURE
+VPEXTRW         mem16,xmmreg,imm8                   [mri:t1s16: evex.128.66.0f3a.wig 15 /r ib ] AVX512BW,FUTURE
+VPEXTRW         reg16,xmmreg,imm8                   [rmi: evex.128.66.0f.wig c5 /r ib ] AVX512BW,FUTURE
+VPEXTRW         reg32,xmmreg,imm8                   [rmi: evex.128.66.0f.wig c5 /r ib ] AVX512BW,FUTURE
+VPEXTRW         reg64,xmmreg,imm8                   [rmi: evex.128.66.0f.wig c5 /r ib ] AVX512BW,FUTURE
+VPGATHERDD      xmmreg|mask,xmem32                  [rm:t1s: vsibx evex.128.66.0f38.w0 90 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERDD      ymmreg|mask,ymem32                  [rm:t1s: vsiby evex.256.66.0f38.w0 90 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERDD      zmmreg|mask,zmem32                  [rm:t1s: vsibz evex.512.66.0f38.w0 90 /r ] AVX512,FUTURE
+VPGATHERDQ      xmmreg|mask,xmem64                  [rm:t1s: vsibx evex.128.66.0f38.w1 90 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERDQ      ymmreg|mask,xmem64                  [rm:t1s: vsibx evex.256.66.0f38.w1 90 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERDQ      zmmreg|mask,ymem64                  [rm:t1s: vsiby evex.512.66.0f38.w1 90 /r ] AVX512,FUTURE
+VPGATHERQD      xmmreg|mask,xmem32                  [rm:t1s: vsibx evex.128.66.0f38.w0 91 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERQD      xmmreg|mask,ymem32                  [rm:t1s: vsiby evex.256.66.0f38.w0 91 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERQD      ymmreg|mask,zmem32                  [rm:t1s: vsibz evex.512.66.0f38.w0 91 /r ] AVX512,FUTURE
+VPGATHERQQ      xmmreg|mask,xmem64                  [rm:t1s: vsibx evex.128.66.0f38.w1 91 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERQQ      ymmreg|mask,ymem64                  [rm:t1s: vsiby evex.256.66.0f38.w1 91 /r ] AVX512VL,AVX512,FUTURE
+VPGATHERQQ      zmmreg|mask,zmem64                  [rm:t1s: vsibz evex.512.66.0f38.w1 91 /r ] AVX512,FUTURE
+VPINSRB         xmmreg,xmmreg*,reg32,imm8           [rvmi:t1s8: evex.nds.128.66.0f3a.wig 20 /r ib ] AVX512BW,FUTURE
+VPINSRB         xmmreg,xmmreg*,mem8,imm8            [rvmi:t1s8: evex.nds.128.66.0f3a.wig 20 /r ib ] AVX512BW,FUTURE
+VPINSRD         xmmreg,xmmreg*,rm32,imm8            [rvmi:t1s: evex.nds.128.66.0f3a.w0 22 /r ib ] AVX512DQ,FUTURE
+VPINSRQ         xmmreg,xmmreg*,rm64,imm8            [rvmi:t1s: evex.nds.128.66.0f3a.w1 22 /r ib ] AVX512DQ,FUTURE
+VPINSRW         xmmreg,xmmreg*,reg32,imm8           [rvmi:t1s16: evex.nds.128.66.0f.wig c4 /r ib ] AVX512BW,FUTURE
+VPINSRW         xmmreg,xmmreg*,mem16,imm8           [rvmi:t1s16: evex.nds.128.66.0f.wig c4 /r ib ] AVX512BW,FUTURE
+VPLZCNTD        xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f38.w0 44 /r ] AVX512VL,AVX512CD,FUTURE
+VPLZCNTD        ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f38.w0 44 /r ] AVX512VL,AVX512CD,FUTURE
+VPLZCNTD        zmmreg|mask|z,zmmrm512|b32          [rm:fv: evex.512.66.0f38.w0 44 /r ] AVX512CD,FUTURE
+VPLZCNTQ        xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f38.w1 44 /r ] AVX512VL,AVX512CD,FUTURE
+VPLZCNTQ        ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f38.w1 44 /r ] AVX512VL,AVX512CD,FUTURE
+VPLZCNTQ        zmmreg|mask|z,zmmrm512|b64          [rm:fv: evex.512.66.0f38.w1 44 /r ] AVX512CD,FUTURE
+VPMADD52HUQ     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 b5 /r ] AVX512VL,AVX512IFMA,FUTURE
+VPMADD52HUQ     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 b5 /r ] AVX512VL,AVX512IFMA,FUTURE
+VPMADD52HUQ     zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 b5 /r ] AVX512IFMA,FUTURE
+VPMADD52LUQ     xmmreg|mask|z,xmmreg,xmmrm128|b64   [rvm:fv: evex.nds.128.66.0f38.w1 b4 /r ] AVX512VL,AVX512IFMA,FUTURE
+VPMADD52LUQ     ymmreg|mask|z,ymmreg,ymmrm256|b64   [rvm:fv: evex.nds.256.66.0f38.w1 b4 /r ] AVX512VL,AVX512IFMA,FUTURE
+VPMADD52LUQ     zmmreg|mask|z,zmmreg,zmmrm512|b64   [rvm:fv: evex.nds.512.66.0f38.w1 b4 /r ] AVX512IFMA,FUTURE
+VPMADDUBSW      xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 04 /r ] AVX512VL,AVX512BW,FUTURE
+VPMADDUBSW      ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 04 /r ] AVX512VL,AVX512BW,FUTURE
+VPMADDUBSW      zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 04 /r ] AVX512BW,FUTURE
+VPMADDWD        xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig f5 /r ] AVX512VL,AVX512BW,FUTURE
+VPMADDWD        ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig f5 /r ] AVX512VL,AVX512BW,FUTURE
+VPMADDWD        zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig f5 /r ] AVX512BW,FUTURE
+VPMAXSB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 3c /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXSB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 3c /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXSB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 3c /r ] AVX512BW,FUTURE
+VPMAXSD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 3d /r ] AVX512VL,AVX512,FUTURE
+VPMAXSD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 3d /r ] AVX512VL,AVX512,FUTURE
+VPMAXSD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 3d /r ] AVX512,FUTURE
+VPMAXSQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 3d /r ] AVX512VL,AVX512,FUTURE
+VPMAXSQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 3d /r ] AVX512VL,AVX512,FUTURE
+VPMAXSQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 3d /r ] AVX512,FUTURE
+VPMAXSW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig ee /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXSW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig ee /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXSW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig ee /r ] AVX512BW,FUTURE
+VPMAXUB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig de /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXUB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig de /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXUB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig de /r ] AVX512BW,FUTURE
+VPMAXUD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 3f /r ] AVX512VL,AVX512,FUTURE
+VPMAXUD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 3f /r ] AVX512VL,AVX512,FUTURE
+VPMAXUD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 3f /r ] AVX512,FUTURE
+VPMAXUQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 3f /r ] AVX512VL,AVX512,FUTURE
+VPMAXUQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 3f /r ] AVX512VL,AVX512,FUTURE
+VPMAXUQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 3f /r ] AVX512,FUTURE
+VPMAXUW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 3e /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXUW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 3e /r ] AVX512VL,AVX512BW,FUTURE
+VPMAXUW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 3e /r ] AVX512BW,FUTURE
+VPMINSB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 38 /r ] AVX512VL,AVX512BW,FUTURE
+VPMINSB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 38 /r ] AVX512VL,AVX512BW,FUTURE
+VPMINSB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 38 /r ] AVX512BW,FUTURE
+VPMINSD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 39 /r ] AVX512VL,AVX512,FUTURE
+VPMINSD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 39 /r ] AVX512VL,AVX512,FUTURE
+VPMINSD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 39 /r ] AVX512,FUTURE
+VPMINSQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 39 /r ] AVX512VL,AVX512,FUTURE
+VPMINSQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 39 /r ] AVX512VL,AVX512,FUTURE
+VPMINSQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 39 /r ] AVX512,FUTURE
+VPMINSW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig ea /r ] AVX512VL,AVX512BW,FUTURE
+VPMINSW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig ea /r ] AVX512VL,AVX512BW,FUTURE
+VPMINSW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig ea /r ] AVX512BW,FUTURE
+VPMINUB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig da /r ] AVX512VL,AVX512BW,FUTURE
+VPMINUB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig da /r ] AVX512VL,AVX512BW,FUTURE
+VPMINUB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig da /r ] AVX512BW,FUTURE
+VPMINUD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 3b /r ] AVX512VL,AVX512,FUTURE
+VPMINUD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 3b /r ] AVX512VL,AVX512,FUTURE
+VPMINUD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 3b /r ] AVX512,FUTURE
+VPMINUQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 3b /r ] AVX512VL,AVX512,FUTURE
+VPMINUQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 3b /r ] AVX512VL,AVX512,FUTURE
+VPMINUQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 3b /r ] AVX512,FUTURE
+VPMINUW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 3a /r ] AVX512VL,AVX512BW,FUTURE
+VPMINUW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 3a /r ] AVX512VL,AVX512BW,FUTURE
+VPMINUW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 3a /r ] AVX512BW,FUTURE
+VPMOVB2M        kreg,xmmreg                         [rm: evex.128.f3.0f38.w0 29 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVB2M        kreg,ymmreg                         [rm: evex.256.f3.0f38.w0 29 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVB2M        kreg,zmmreg                         [rm: evex.512.f3.0f38.w0 29 /r ] AVX512BW,FUTURE
+VPMOVD2M        kreg,xmmreg                         [rm: evex.128.f3.0f38.w0 39 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVD2M        kreg,ymmreg                         [rm: evex.256.f3.0f38.w0 39 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVD2M        kreg,zmmreg                         [rm: evex.512.f3.0f38.w0 39 /r ] AVX512DQ,FUTURE
+VPMOVDB         xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 31 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDB         xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 31 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDB         xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 31 /r ] AVX512,FUTURE
+VPMOVDB         mem32|mask,xmmreg                   [mr:qvm: evex.128.f3.0f38.w0 31 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDB         mem64|mask,ymmreg                   [mr:qvm: evex.256.f3.0f38.w0 31 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDB         mem128|mask,zmmreg                  [mr:qvm: evex.512.f3.0f38.w0 31 /r ] AVX512,FUTURE
+VPMOVDW         xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 33 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDW         xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 33 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDW         ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 33 /r ] AVX512,FUTURE
+VPMOVDW         mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 33 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDW         mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 33 /r ] AVX512VL,AVX512,FUTURE
+VPMOVDW         mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 33 /r ] AVX512,FUTURE
+VPMOVM2B        xmmreg,kreg                         [rm: evex.128.f3.0f38.w0 28 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVM2B        ymmreg,kreg                         [rm: evex.256.f3.0f38.w0 28 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVM2B        zmmreg,kreg                         [rm: evex.512.f3.0f38.w0 28 /r ] AVX512BW,FUTURE
+VPMOVM2D        xmmreg,kreg                         [rm: evex.128.f3.0f38.w0 38 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVM2D        ymmreg,kreg                         [rm: evex.256.f3.0f38.w0 38 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVM2D        zmmreg,kreg                         [rm: evex.512.f3.0f38.w0 38 /r ] AVX512DQ,FUTURE
+VPMOVM2Q        xmmreg,kreg                         [rm: evex.128.f3.0f38.w1 38 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVM2Q        ymmreg,kreg                         [rm: evex.256.f3.0f38.w1 38 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVM2Q        zmmreg,kreg                         [rm: evex.512.f3.0f38.w1 38 /r ] AVX512DQ,FUTURE
+VPMOVM2W        xmmreg,kreg                         [rm: evex.128.f3.0f38.w1 28 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVM2W        ymmreg,kreg                         [rm: evex.256.f3.0f38.w1 28 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVM2W        zmmreg,kreg                         [rm: evex.512.f3.0f38.w1 28 /r ] AVX512BW,FUTURE
+VPMOVQ2M        kreg,xmmreg                         [rm: evex.128.f3.0f38.w1 39 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVQ2M        kreg,ymmreg                         [rm: evex.256.f3.0f38.w1 39 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMOVQ2M        kreg,zmmreg                         [rm: evex.512.f3.0f38.w1 39 /r ] AVX512DQ,FUTURE
+VPMOVQB         xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 32 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQB         xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 32 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQB         xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 32 /r ] AVX512,FUTURE
+VPMOVQB         mem16|mask,xmmreg                   [mr:ovm: evex.128.f3.0f38.w0 32 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQB         mem32|mask,ymmreg                   [mr:ovm: evex.256.f3.0f38.w0 32 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQB         mem64|mask,zmmreg                   [mr:ovm: evex.512.f3.0f38.w0 32 /r ] AVX512,FUTURE
+VPMOVQD         xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 35 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQD         xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 35 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQD         ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 35 /r ] AVX512,FUTURE
+VPMOVQD         mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 35 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQD         mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 35 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQD         mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 35 /r ] AVX512,FUTURE
+VPMOVQW         xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 34 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQW         xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 34 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQW         xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 34 /r ] AVX512,FUTURE
+VPMOVQW         mem32|mask,xmmreg                   [mr:qvm: evex.128.f3.0f38.w0 34 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQW         mem64|mask,ymmreg                   [mr:qvm: evex.256.f3.0f38.w0 34 /r ] AVX512VL,AVX512,FUTURE
+VPMOVQW         mem128|mask,zmmreg                  [mr:qvm: evex.512.f3.0f38.w0 34 /r ] AVX512,FUTURE
+VPMOVSDB        xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 21 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDB        xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 21 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDB        xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 21 /r ] AVX512,FUTURE
+VPMOVSDB        mem32|mask,xmmreg                   [mr:qvm: evex.128.f3.0f38.w0 21 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDB        mem64|mask,ymmreg                   [mr:qvm: evex.256.f3.0f38.w0 21 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDB        mem128|mask,zmmreg                  [mr:qvm: evex.512.f3.0f38.w0 21 /r ] AVX512,FUTURE
+VPMOVSDW        xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 23 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDW        xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 23 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDW        ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 23 /r ] AVX512,FUTURE
+VPMOVSDW        mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 23 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDW        mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 23 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSDW        mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 23 /r ] AVX512,FUTURE
+VPMOVSQB        xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 22 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQB        xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 22 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQB        xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 22 /r ] AVX512,FUTURE
+VPMOVSQB        mem16|mask,xmmreg                   [mr:ovm: evex.128.f3.0f38.w0 22 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQB        mem32|mask,ymmreg                   [mr:ovm: evex.256.f3.0f38.w0 22 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQB        mem64|mask,zmmreg                   [mr:ovm: evex.512.f3.0f38.w0 22 /r ] AVX512,FUTURE
+VPMOVSQD        xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 25 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQD        xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 25 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQD        ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 25 /r ] AVX512,FUTURE
+VPMOVSQD        mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 25 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQD        mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 25 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQD        mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 25 /r ] AVX512,FUTURE
+VPMOVSQW        xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 24 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQW        xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 24 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQW        xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 24 /r ] AVX512,FUTURE
+VPMOVSQW        mem32|mask,xmmreg                   [mr:qvm: evex.128.f3.0f38.w0 24 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQW        mem64|mask,ymmreg                   [mr:qvm: evex.256.f3.0f38.w0 24 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSQW        mem128|mask,zmmreg                  [mr:qvm: evex.512.f3.0f38.w0 24 /r ] AVX512,FUTURE
+VPMOVSWB        xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 20 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVSWB        xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 20 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVSWB        ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 20 /r ] AVX512BW,FUTURE
+VPMOVSWB        mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 20 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVSWB        mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 20 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVSWB        mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 20 /r ] AVX512BW,FUTURE
+VPMOVSXBD       xmmreg|mask|z,xmmrm32               [rm:qvm: evex.128.66.0f38.wig 21 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXBD       ymmreg|mask|z,xmmrm64               [rm:qvm: evex.256.66.0f38.wig 21 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXBD       zmmreg|mask|z,xmmrm128              [rm:qvm: evex.512.66.0f38.wig 21 /r ] AVX512,FUTURE
+VPMOVSXBQ       xmmreg|mask|z,xmmrm16               [rm:ovm: evex.128.66.0f38.wig 22 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXBQ       ymmreg|mask|z,xmmrm32               [rm:ovm: evex.256.66.0f38.wig 22 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXBQ       zmmreg|mask|z,xmmrm64               [rm:ovm: evex.512.66.0f38.wig 22 /r ] AVX512,FUTURE
+VPMOVSXBW       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.wig 20 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVSXBW       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.wig 20 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVSXBW       zmmreg|mask|z,ymmrm256              [rm:hvm: evex.512.66.0f38.wig 20 /r ] AVX512BW,FUTURE
+VPMOVSXDQ       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.w0 25 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXDQ       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.w0 25 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXDQ       zmmreg|mask|z,ymmrm256              [rm:hvm: evex.512.66.0f38.w0 25 /r ] AVX512,FUTURE
+VPMOVSXWD       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.wig 23 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXWD       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.wig 23 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXWD       zmmreg|mask|z,ymmrm256              [rm:hvm: evex.512.66.0f38.wig 23 /r ] AVX512,FUTURE
+VPMOVSXWQ       xmmreg|mask|z,xmmrm32               [rm:qvm: evex.128.66.0f38.wig 24 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXWQ       ymmreg|mask|z,xmmrm64               [rm:qvm: evex.256.66.0f38.wig 24 /r ] AVX512VL,AVX512,FUTURE
+VPMOVSXWQ       zmmreg|mask|z,xmmrm128              [rm:qvm: evex.512.66.0f38.wig 24 /r ] AVX512,FUTURE
+VPMOVUSDB       xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDB       xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDB       xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 11 /r ] AVX512,FUTURE
+VPMOVUSDB       mem32|mask,xmmreg                   [mr:qvm: evex.128.f3.0f38.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDB       mem64|mask,ymmreg                   [mr:qvm: evex.256.f3.0f38.w0 11 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDB       mem128|mask,zmmreg                  [mr:qvm: evex.512.f3.0f38.w0 11 /r ] AVX512,FUTURE
+VPMOVUSDW       xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 13 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDW       xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 13 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDW       ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 13 /r ] AVX512,FUTURE
+VPMOVUSDW       mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 13 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDW       mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 13 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSDW       mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 13 /r ] AVX512,FUTURE
+VPMOVUSQB       xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 12 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQB       xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 12 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQB       xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 12 /r ] AVX512,FUTURE
+VPMOVUSQB       mem16|mask,xmmreg                   [mr:ovm: evex.128.f3.0f38.w0 12 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQB       mem32|mask,ymmreg                   [mr:ovm: evex.256.f3.0f38.w0 12 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQB       mem64|mask,zmmreg                   [mr:ovm: evex.512.f3.0f38.w0 12 /r ] AVX512,FUTURE
+VPMOVUSQD       xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQD       xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQD       ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 15 /r ] AVX512,FUTURE
+VPMOVUSQD       mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQD       mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQD       mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 15 /r ] AVX512,FUTURE
+VPMOVUSQW       xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQW       xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQW       xmmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 14 /r ] AVX512,FUTURE
+VPMOVUSQW       mem32|mask,xmmreg                   [mr:qvm: evex.128.f3.0f38.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQW       mem64|mask,ymmreg                   [mr:qvm: evex.256.f3.0f38.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VPMOVUSQW       mem128|mask,zmmreg                  [mr:qvm: evex.512.f3.0f38.w0 14 /r ] AVX512,FUTURE
+VPMOVUSWB       xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 10 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVUSWB       xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 10 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVUSWB       ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 10 /r ] AVX512BW,FUTURE
+VPMOVUSWB       mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 10 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVUSWB       mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 10 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVUSWB       mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 10 /r ] AVX512BW,FUTURE
+VPMOVW2M        kreg,xmmreg                         [rm: evex.128.f3.0f38.w1 29 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVW2M        kreg,ymmreg                         [rm: evex.256.f3.0f38.w1 29 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVW2M        kreg,zmmreg                         [rm: evex.512.f3.0f38.w1 29 /r ] AVX512BW,FUTURE
+VPMOVWB         xmmreg|mask|z,xmmreg                [mr: evex.128.f3.0f38.w0 30 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVWB         xmmreg|mask|z,ymmreg                [mr: evex.256.f3.0f38.w0 30 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVWB         ymmreg|mask|z,zmmreg                [mr: evex.512.f3.0f38.w0 30 /r ] AVX512BW,FUTURE
+VPMOVWB         mem64|mask,xmmreg                   [mr:hvm: evex.128.f3.0f38.w0 30 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVWB         mem128|mask,ymmreg                  [mr:hvm: evex.256.f3.0f38.w0 30 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVWB         mem256|mask,zmmreg                  [mr:hvm: evex.512.f3.0f38.w0 30 /r ] AVX512BW,FUTURE
+VPMOVZXBD       xmmreg|mask|z,xmmrm32               [rm:qvm: evex.128.66.0f38.wig 31 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXBD       ymmreg|mask|z,xmmrm64               [rm:qvm: evex.256.66.0f38.wig 31 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXBD       zmmreg|mask|z,xmmrm128              [rm:qvm: evex.512.66.0f38.wig 31 /r ] AVX512,FUTURE
+VPMOVZXBQ       xmmreg|mask|z,xmmrm16               [rm:ovm: evex.128.66.0f38.wig 32 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXBQ       ymmreg|mask|z,xmmrm32               [rm:ovm: evex.256.66.0f38.wig 32 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXBQ       zmmreg|mask|z,xmmrm64               [rm:ovm: evex.512.66.0f38.wig 32 /r ] AVX512,FUTURE
+VPMOVZXBW       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.wig 30 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVZXBW       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.wig 30 /r ] AVX512VL,AVX512BW,FUTURE
+VPMOVZXBW       zmmreg|mask|z,ymmrm256              [rm:hvm: evex.512.66.0f38.wig 30 /r ] AVX512BW,FUTURE
+VPMOVZXDQ       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.w0 35 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXDQ       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.w0 35 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXDQ       zmmreg|mask|z,ymmrm256              [rm:hvm: evex.512.66.0f38.w0 35 /r ] AVX512,FUTURE
+VPMOVZXWD       xmmreg|mask|z,xmmrm64               [rm:hvm: evex.128.66.0f38.wig 33 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXWD       ymmreg|mask|z,xmmrm128              [rm:hvm: evex.256.66.0f38.wig 33 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXWD       zmmreg|mask|z,ymmrm256              [rm:hvm: evex.512.66.0f38.wig 33 /r ] AVX512,FUTURE
+VPMOVZXWQ       xmmreg|mask|z,xmmrm32               [rm:qvm: evex.128.66.0f38.wig 34 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXWQ       ymmreg|mask|z,xmmrm64               [rm:qvm: evex.256.66.0f38.wig 34 /r ] AVX512VL,AVX512,FUTURE
+VPMOVZXWQ       zmmreg|mask|z,xmmrm128              [rm:qvm: evex.512.66.0f38.wig 34 /r ] AVX512,FUTURE
+VPMULDQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 28 /r ] AVX512VL,AVX512,FUTURE
+VPMULDQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 28 /r ] AVX512VL,AVX512,FUTURE
+VPMULDQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 28 /r ] AVX512,FUTURE
+VPMULHRSW       xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 0b /r ] AVX512VL,AVX512BW,FUTURE
+VPMULHRSW       ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 0b /r ] AVX512VL,AVX512BW,FUTURE
+VPMULHRSW       zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 0b /r ] AVX512BW,FUTURE
+VPMULHUW        xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig e4 /r ] AVX512VL,AVX512BW,FUTURE
+VPMULHUW        ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig e4 /r ] AVX512VL,AVX512BW,FUTURE
+VPMULHUW        zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig e4 /r ] AVX512BW,FUTURE
+VPMULHW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig e5 /r ] AVX512VL,AVX512BW,FUTURE
+VPMULHW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig e5 /r ] AVX512VL,AVX512BW,FUTURE
+VPMULHW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig e5 /r ] AVX512BW,FUTURE
+VPMULLD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 40 /r ] AVX512VL,AVX512,FUTURE
+VPMULLD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 40 /r ] AVX512VL,AVX512,FUTURE
+VPMULLD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 40 /r ] AVX512,FUTURE
+VPMULLQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 40 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMULLQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 40 /r ] AVX512VL,AVX512DQ,FUTURE
+VPMULLQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 40 /r ] AVX512DQ,FUTURE
+VPMULLW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig d5 /r ] AVX512VL,AVX512BW,FUTURE
+VPMULLW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig d5 /r ] AVX512VL,AVX512BW,FUTURE
+VPMULLW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig d5 /r ] AVX512BW,FUTURE
+VPMULTISHIFTQB  xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 83 /r ] AVX512VL,AVX512VBMI,FUTURE
+VPMULTISHIFTQB  ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 83 /r ] AVX512VL,AVX512VBMI,FUTURE
+VPMULTISHIFTQB  zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 83 /r ] AVX512VBMI,FUTURE
+VPMULUDQ        xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 f4 /r ] AVX512VL,AVX512,FUTURE
+VPMULUDQ        ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 f4 /r ] AVX512VL,AVX512,FUTURE
+VPMULUDQ        zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 f4 /r ] AVX512,FUTURE
+VPORD           xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 eb /r ] AVX512VL,AVX512,FUTURE
+VPORD           ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 eb /r ] AVX512VL,AVX512,FUTURE
+VPORD           zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 eb /r ] AVX512,FUTURE
+VPORQ           xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 eb /r ] AVX512VL,AVX512,FUTURE
+VPORQ           ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 eb /r ] AVX512VL,AVX512,FUTURE
+VPORQ           zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 eb /r ] AVX512,FUTURE
+VPROLD          xmmreg|mask|z,xmmrm128|b32*,imm8    [vmi:fv: evex.nds.128.66.0f.w0 72 /1 ib ] AVX512VL,AVX512,FUTURE
+VPROLD          ymmreg|mask|z,ymmrm256|b32*,imm8    [vmi:fv: evex.nds.256.66.0f.w0 72 /1 ib ] AVX512VL,AVX512,FUTURE
+VPROLD          zmmreg|mask|z,zmmrm512|b32*,imm8    [vmi:fv: evex.nds.512.66.0f.w0 72 /1 ib ] AVX512,FUTURE
+VPROLQ          xmmreg|mask|z,xmmrm128|b64*,imm8    [vmi:fv: evex.nds.128.66.0f.w1 72 /1 ib ] AVX512VL,AVX512,FUTURE
+VPROLQ          ymmreg|mask|z,ymmrm256|b64*,imm8    [vmi:fv: evex.nds.256.66.0f.w1 72 /1 ib ] AVX512VL,AVX512,FUTURE
+VPROLQ          zmmreg|mask|z,zmmrm512|b64*,imm8    [vmi:fv: evex.nds.512.66.0f.w1 72 /1 ib ] AVX512,FUTURE
+VPROLVD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VPROLVD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VPROLVD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 15 /r ] AVX512,FUTURE
+VPROLVQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 15 /r ] AVX512VL,AVX512,FUTURE
+VPROLVQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 15 /r ] AVX512VL,AVX512,FUTURE
+VPROLVQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 15 /r ] AVX512,FUTURE
+VPRORD          xmmreg|mask|z,xmmrm128|b32*,imm8    [vmi:fv: evex.nds.128.66.0f.w0 72 /0 ib ] AVX512VL,AVX512,FUTURE
+VPRORD          ymmreg|mask|z,ymmrm256|b32*,imm8    [vmi:fv: evex.nds.256.66.0f.w0 72 /0 ib ] AVX512VL,AVX512,FUTURE
+VPRORD          zmmreg|mask|z,zmmrm512|b32*,imm8    [vmi:fv: evex.nds.512.66.0f.w0 72 /0 ib ] AVX512,FUTURE
+VPRORQ          xmmreg|mask|z,xmmrm128|b64*,imm8    [vmi:fv: evex.nds.128.66.0f.w1 72 /0 ib ] AVX512VL,AVX512,FUTURE
+VPRORQ          ymmreg|mask|z,ymmrm256|b64*,imm8    [vmi:fv: evex.nds.256.66.0f.w1 72 /0 ib ] AVX512VL,AVX512,FUTURE
+VPRORQ          zmmreg|mask|z,zmmrm512|b64*,imm8    [vmi:fv: evex.nds.512.66.0f.w1 72 /0 ib ] AVX512,FUTURE
+VPRORVD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VPRORVD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VPRORVD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 14 /r ] AVX512,FUTURE
+VPRORVQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 14 /r ] AVX512VL,AVX512,FUTURE
+VPRORVQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 14 /r ] AVX512VL,AVX512,FUTURE
+VPRORVQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 14 /r ] AVX512,FUTURE
+VPSADBW         xmmreg,xmmreg*,xmmrm128             [rvm:fvm: evex.nds.128.66.0f.wig f6 /r ] AVX512VL,AVX512BW,FUTURE
+VPSADBW         ymmreg,ymmreg*,ymmrm256             [rvm:fvm: evex.nds.256.66.0f.wig f6 /r ] AVX512VL,AVX512BW,FUTURE
+VPSADBW         zmmreg,zmmreg*,zmmrm512             [rvm:fvm: evex.nds.512.66.0f.wig f6 /r ] AVX512BW,FUTURE
+VPSCATTERDD     xmem32|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w0 a0 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERDD     ymem32|mask,ymmreg                  [mr:t1s: vsiby evex.256.66.0f38.w0 a0 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERDD     zmem32|mask,zmmreg                  [mr:t1s: vsibz evex.512.66.0f38.w0 a0 /r ] AVX512,FUTURE
+VPSCATTERDQ     xmem64|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w1 a0 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERDQ     xmem64|mask,ymmreg                  [mr:t1s: vsibx evex.256.66.0f38.w1 a0 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERDQ     ymem64|mask,zmmreg                  [mr:t1s: vsiby evex.512.66.0f38.w1 a0 /r ] AVX512,FUTURE
+VPSCATTERQD     xmem32|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w0 a1 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERQD     ymem32|mask,xmmreg                  [mr:t1s: vsiby evex.256.66.0f38.w0 a1 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERQD     zmem32|mask,ymmreg                  [mr:t1s: vsibz evex.512.66.0f38.w0 a1 /r ] AVX512,FUTURE
+VPSCATTERQQ     xmem64|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w1 a1 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERQQ     ymem64|mask,ymmreg                  [mr:t1s: vsiby evex.256.66.0f38.w1 a1 /r ] AVX512VL,AVX512,FUTURE
+VPSCATTERQQ     zmem64|mask,zmmreg                  [mr:t1s: vsibz evex.512.66.0f38.w1 a1 /r ] AVX512,FUTURE
+VPSHUFB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.wig 00 /r ] AVX512VL,AVX512BW,FUTURE
+VPSHUFB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.wig 00 /r ] AVX512VL,AVX512BW,FUTURE
+VPSHUFB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.wig 00 /r ] AVX512BW,FUTURE
+VPSHUFD         xmmreg|mask|z,xmmrm128|b32,imm8     [rmi:fv: evex.128.66.0f.w0 70 /r ib ] AVX512VL,AVX512,FUTURE
+VPSHUFD         ymmreg|mask|z,ymmrm256|b32,imm8     [rmi:fv: evex.256.66.0f.w0 70 /r ib ] AVX512VL,AVX512,FUTURE
+VPSHUFD         zmmreg|mask|z,zmmrm512|b32,imm8     [rmi:fv: evex.512.66.0f.w0 70 /r ib ] AVX512,FUTURE
+VPSHUFHW        xmmreg|mask|z,xmmrm128,imm8         [rmi:fvm: evex.128.f3.0f.wig 70 /r ib ] AVX512VL,AVX512BW,FUTURE
+VPSHUFHW        ymmreg|mask|z,ymmrm256,imm8         [rmi:fvm: evex.256.f3.0f.wig 70 /r ib ] AVX512VL,AVX512BW,FUTURE
+VPSHUFHW        zmmreg|mask|z,zmmrm512,imm8         [rmi:fvm: evex.512.f3.0f.wig 70 /r ib ] AVX512BW,FUTURE
+VPSHUFLW        xmmreg|mask|z,xmmrm128,imm8         [rmi:fvm: evex.128.f2.0f.wig 70 /r ib ] AVX512VL,AVX512BW,FUTURE
+VPSHUFLW        ymmreg|mask|z,ymmrm256,imm8         [rmi:fvm: evex.256.f2.0f.wig 70 /r ib ] AVX512VL,AVX512BW,FUTURE
+VPSHUFLW        zmmreg|mask|z,zmmrm512,imm8         [rmi:fvm: evex.512.f2.0f.wig 70 /r ib ] AVX512BW,FUTURE
+VPSLLD          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.w0 f2 /r ] AVX512VL,AVX512,FUTURE
+VPSLLD          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.w0 f2 /r ] AVX512VL,AVX512,FUTURE
+VPSLLD          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.w0 f2 /r ] AVX512,FUTURE
+VPSLLD          xmmreg|mask|z,xmmrm128|b32*,imm8    [vmi:fv: evex.nds.128.66.0f.w0 72 /6 ib ] AVX512VL,AVX512,FUTURE
+VPSLLD          ymmreg|mask|z,ymmrm256|b32*,imm8    [vmi:fv: evex.nds.256.66.0f.w0 72 /6 ib ] AVX512VL,AVX512,FUTURE
+VPSLLD          zmmreg|mask|z,zmmrm512|b32*,imm8    [vmi:fv: evex.nds.512.66.0f.w0 72 /6 ib ] AVX512,FUTURE
+VPSLLDQ         xmmreg,xmmrm128*,imm8               [vmi:fvm: evex.nds.128.66.0f.wig 73 /7 ib ] AVX512VL,AVX512BW,FUTURE
+VPSLLDQ         ymmreg,ymmrm256*,imm8               [vmi:fvm: evex.nds.256.66.0f.wig 73 /7 ib ] AVX512VL,AVX512BW,FUTURE
+VPSLLDQ         zmmreg,zmmrm512*,imm8               [vmi:fvm: evex.nds.512.66.0f.wig 73 /7 ib ] AVX512BW,FUTURE
+VPSLLQ          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.w1 f3 /r ] AVX512VL,AVX512,FUTURE
+VPSLLQ          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.w1 f3 /r ] AVX512VL,AVX512,FUTURE
+VPSLLQ          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.w1 f3 /r ] AVX512,FUTURE
+VPSLLQ          xmmreg|mask|z,xmmrm128|b64*,imm8    [vmi:fv: evex.nds.128.66.0f.w1 73 /6 ib ] AVX512VL,AVX512,FUTURE
+VPSLLQ          ymmreg|mask|z,ymmrm256|b64*,imm8    [vmi:fv: evex.nds.256.66.0f.w1 73 /6 ib ] AVX512VL,AVX512,FUTURE
+VPSLLQ          zmmreg|mask|z,zmmrm512|b64*,imm8    [vmi:fv: evex.nds.512.66.0f.w1 73 /6 ib ] AVX512,FUTURE
+VPSLLVD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 47 /r ] AVX512VL,AVX512,FUTURE
+VPSLLVD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 47 /r ] AVX512VL,AVX512,FUTURE
+VPSLLVD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 47 /r ] AVX512,FUTURE
+VPSLLVQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 47 /r ] AVX512VL,AVX512,FUTURE
+VPSLLVQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 47 /r ] AVX512VL,AVX512,FUTURE
+VPSLLVQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 47 /r ] AVX512,FUTURE
+VPSLLVW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.w1 12 /r ] AVX512VL,AVX512BW,FUTURE
+VPSLLVW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.w1 12 /r ] AVX512VL,AVX512BW,FUTURE
+VPSLLVW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.w1 12 /r ] AVX512BW,FUTURE
+VPSLLW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.wig f1 /r ] AVX512VL,AVX512BW,FUTURE
+VPSLLW          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.wig f1 /r ] AVX512VL,AVX512BW,FUTURE
+VPSLLW          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.wig f1 /r ] AVX512BW,FUTURE
+VPSLLW          xmmreg|mask|z,xmmrm128*,imm8        [vmi:fvm: evex.nds.128.66.0f.wig 71 /6 ib ] AVX512VL,AVX512BW,FUTURE
+VPSLLW          ymmreg|mask|z,ymmrm256*,imm8        [vmi:fvm: evex.nds.256.66.0f.wig 71 /6 ib ] AVX512VL,AVX512BW,FUTURE
+VPSLLW          zmmreg|mask|z,zmmrm512*,imm8        [vmi:fvm: evex.nds.512.66.0f.wig 71 /6 ib ] AVX512BW,FUTURE
+VPSRAD          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.w0 e2 /r ] AVX512VL,AVX512,FUTURE
+VPSRAD          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.w0 e2 /r ] AVX512VL,AVX512,FUTURE
+VPSRAD          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.w0 e2 /r ] AVX512,FUTURE
+VPSRAD          xmmreg|mask|z,xmmrm128|b32*,imm8    [vmi:fv: evex.nds.128.66.0f.w0 72 /4 ib ] AVX512VL,AVX512,FUTURE
+VPSRAD          ymmreg|mask|z,ymmrm256|b32*,imm8    [vmi:fv: evex.nds.256.66.0f.w0 72 /4 ib ] AVX512VL,AVX512,FUTURE
+VPSRAD          zmmreg|mask|z,zmmrm512|b32*,imm8    [vmi:fv: evex.nds.512.66.0f.w0 72 /4 ib ] AVX512,FUTURE
+VPSRAQ          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.w1 e2 /r ] AVX512VL,AVX512,FUTURE
+VPSRAQ          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.w1 e2 /r ] AVX512VL,AVX512,FUTURE
+VPSRAQ          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.w1 e2 /r ] AVX512,FUTURE
+VPSRAQ          xmmreg|mask|z,xmmrm128|b64*,imm8    [vmi:fv: evex.nds.128.66.0f.w1 72 /4 ib ] AVX512VL,AVX512,FUTURE
+VPSRAQ          ymmreg|mask|z,ymmrm256|b64*,imm8    [vmi:fv: evex.nds.256.66.0f.w1 72 /4 ib ] AVX512VL,AVX512,FUTURE
+VPSRAQ          zmmreg|mask|z,zmmrm512|b64*,imm8    [vmi:fv: evex.nds.512.66.0f.w1 72 /4 ib ] AVX512,FUTURE
+VPSRAVD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 46 /r ] AVX512VL,AVX512,FUTURE
+VPSRAVD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 46 /r ] AVX512VL,AVX512,FUTURE
+VPSRAVD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 46 /r ] AVX512,FUTURE
+VPSRAVQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 46 /r ] AVX512VL,AVX512,FUTURE
+VPSRAVQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 46 /r ] AVX512VL,AVX512,FUTURE
+VPSRAVQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 46 /r ] AVX512,FUTURE
+VPSRAVW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.w1 11 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRAVW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.w1 11 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRAVW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.w1 11 /r ] AVX512BW,FUTURE
+VPSRAW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.wig e1 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRAW          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.wig e1 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRAW          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.wig e1 /r ] AVX512BW,FUTURE
+VPSRAW          xmmreg|mask|z,xmmrm128*,imm8        [vmi:fvm: evex.nds.128.66.0f.wig 71 /4 ib ] AVX512VL,AVX512BW,FUTURE
+VPSRAW          ymmreg|mask|z,ymmrm256*,imm8        [vmi:fvm: evex.nds.256.66.0f.wig 71 /4 ib ] AVX512VL,AVX512BW,FUTURE
+VPSRAW          zmmreg|mask|z,zmmrm512*,imm8        [vmi:fvm: evex.nds.512.66.0f.wig 71 /4 ib ] AVX512BW,FUTURE
+VPSRLD          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.w0 d2 /r ] AVX512VL,AVX512,FUTURE
+VPSRLD          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.w0 d2 /r ] AVX512VL,AVX512,FUTURE
+VPSRLD          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.w0 d2 /r ] AVX512,FUTURE
+VPSRLD          xmmreg|mask|z,xmmrm128|b32*,imm8    [vmi:fv: evex.nds.128.66.0f.w0 72 /2 ib ] AVX512VL,AVX512,FUTURE
+VPSRLD          ymmreg|mask|z,ymmrm256|b32*,imm8    [vmi:fv: evex.nds.256.66.0f.w0 72 /2 ib ] AVX512VL,AVX512,FUTURE
+VPSRLD          zmmreg|mask|z,zmmrm512|b32*,imm8    [vmi:fv: evex.nds.512.66.0f.w0 72 /2 ib ] AVX512,FUTURE
+VPSRLDQ         xmmreg,xmmrm128*,imm8               [vmi:fvm: evex.nds.128.66.0f.wig 73 /3 ib ] AVX512VL,AVX512BW,FUTURE
+VPSRLDQ         ymmreg,ymmrm256*,imm8               [vmi:fvm: evex.nds.256.66.0f.wig 73 /3 ib ] AVX512VL,AVX512BW,FUTURE
+VPSRLDQ         zmmreg,zmmrm512*,imm8               [vmi:fvm: evex.nds.512.66.0f.wig 73 /3 ib ] AVX512BW,FUTURE
+VPSRLQ          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.w1 d3 /r ] AVX512VL,AVX512,FUTURE
+VPSRLQ          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.w1 d3 /r ] AVX512VL,AVX512,FUTURE
+VPSRLQ          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.w1 d3 /r ] AVX512,FUTURE
+VPSRLQ          xmmreg|mask|z,xmmrm128|b64*,imm8    [vmi:fv: evex.nds.128.66.0f.w1 73 /2 ib ] AVX512VL,AVX512,FUTURE
+VPSRLQ          ymmreg|mask|z,ymmrm256|b64*,imm8    [vmi:fv: evex.nds.256.66.0f.w1 73 /2 ib ] AVX512VL,AVX512,FUTURE
+VPSRLQ          zmmreg|mask|z,zmmrm512|b64*,imm8    [vmi:fv: evex.nds.512.66.0f.w1 73 /2 ib ] AVX512,FUTURE
+VPSRLVD         xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 45 /r ] AVX512VL,AVX512,FUTURE
+VPSRLVD         ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 45 /r ] AVX512VL,AVX512,FUTURE
+VPSRLVD         zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f38.w0 45 /r ] AVX512,FUTURE
+VPSRLVQ         xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 45 /r ] AVX512VL,AVX512,FUTURE
+VPSRLVQ         ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 45 /r ] AVX512VL,AVX512,FUTURE
+VPSRLVQ         zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f38.w1 45 /r ] AVX512,FUTURE
+VPSRLVW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f38.w1 10 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRLVW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f38.w1 10 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRLVW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f38.w1 10 /r ] AVX512BW,FUTURE
+VPSRLW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:m128: evex.nds.128.66.0f.wig d1 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRLW          ymmreg|mask|z,ymmreg*,xmmrm128      [rvm:m128: evex.nds.256.66.0f.wig d1 /r ] AVX512VL,AVX512BW,FUTURE
+VPSRLW          zmmreg|mask|z,zmmreg*,xmmrm128      [rvm:m128: evex.nds.512.66.0f.wig d1 /r ] AVX512BW,FUTURE
+VPSRLW          xmmreg|mask|z,xmmrm128*,imm8        [vmi:fvm: evex.nds.128.66.0f.wig 71 /2 ib ] AVX512VL,AVX512BW,FUTURE
+VPSRLW          ymmreg|mask|z,ymmrm256*,imm8        [vmi:fvm: evex.nds.256.66.0f.wig 71 /2 ib ] AVX512VL,AVX512BW,FUTURE
+VPSRLW          zmmreg|mask|z,zmmrm512*,imm8        [vmi:fvm: evex.nds.512.66.0f.wig 71 /2 ib ] AVX512BW,FUTURE
+VPSUBB          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig f8 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBB          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig f8 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBB          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig f8 /r ] AVX512BW,FUTURE
+VPSUBD          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 fa /r ] AVX512VL,AVX512,FUTURE
+VPSUBD          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 fa /r ] AVX512VL,AVX512,FUTURE
+VPSUBD          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 fa /r ] AVX512,FUTURE
+VPSUBQ          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 fb /r ] AVX512VL,AVX512,FUTURE
+VPSUBQ          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 fb /r ] AVX512VL,AVX512,FUTURE
+VPSUBQ          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 fb /r ] AVX512,FUTURE
+VPSUBSB         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig e8 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBSB         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig e8 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBSB         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig e8 /r ] AVX512BW,FUTURE
+VPSUBSW         xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig e9 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBSW         ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig e9 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBSW         zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig e9 /r ] AVX512BW,FUTURE
+VPSUBUSB        xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig d8 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBUSB        ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig d8 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBUSB        zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig d8 /r ] AVX512BW,FUTURE
+VPSUBUSW        xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig d9 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBUSW        ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig d9 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBUSW        zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig d9 /r ] AVX512BW,FUTURE
+VPSUBW          xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig f9 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBW          ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig f9 /r ] AVX512VL,AVX512BW,FUTURE
+VPSUBW          zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig f9 /r ] AVX512BW,FUTURE
+VPTERNLOGD      xmmreg|mask|z,xmmreg,xmmrm128|b32,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w0 25 /r ib ] AVX512VL,AVX512,FUTURE
+VPTERNLOGD      ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w0 25 /r ib ] AVX512VL,AVX512,FUTURE
+VPTERNLOGD      zmmreg|mask|z,zmmreg,zmmrm512|b32,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w0 25 /r ib ] AVX512,FUTURE
+VPTERNLOGQ      xmmreg|mask|z,xmmreg,xmmrm128|b64,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w1 25 /r ib ] AVX512VL,AVX512,FUTURE
+VPTERNLOGQ      ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w1 25 /r ib ] AVX512VL,AVX512,FUTURE
+VPTERNLOGQ      zmmreg|mask|z,zmmreg,zmmrm512|b64,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w1 25 /r ib ] AVX512,FUTURE
+VPTESTMB        kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.66.0f38.w0 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTMB        kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.66.0f38.w0 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTMB        kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.66.0f38.w0 26 /r ] AVX512BW,FUTURE
+VPTESTMD        kreg|mask,xmmreg,xmmrm128|b32       [rvm:fv: evex.nds.128.66.0f38.w0 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTMD        kreg|mask,ymmreg,ymmrm256|b32       [rvm:fv: evex.nds.256.66.0f38.w0 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTMD        kreg|mask,zmmreg,zmmrm512|b32       [rvm:fv: evex.nds.512.66.0f38.w0 27 /r ] AVX512,FUTURE
+VPTESTMQ        kreg|mask,xmmreg,xmmrm128|b64       [rvm:fv: evex.nds.128.66.0f38.w1 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTMQ        kreg|mask,ymmreg,ymmrm256|b64       [rvm:fv: evex.nds.256.66.0f38.w1 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTMQ        kreg|mask,zmmreg,zmmrm512|b64       [rvm:fv: evex.nds.512.66.0f38.w1 27 /r ] AVX512,FUTURE
+VPTESTMW        kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.66.0f38.w1 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTMW        kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.66.0f38.w1 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTMW        kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.66.0f38.w1 26 /r ] AVX512BW,FUTURE
+VPTESTNMB       kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.f3.0f38.w0 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTNMB       kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.f3.0f38.w0 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTNMB       kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.f3.0f38.w0 26 /r ] AVX512BW,FUTURE
+VPTESTNMD       kreg|mask,xmmreg,xmmrm128|b32       [rvm:fv: evex.nds.128.f3.0f38.w0 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTNMD       kreg|mask,ymmreg,ymmrm256|b32       [rvm:fv: evex.nds.256.f3.0f38.w0 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTNMD       kreg|mask,zmmreg,zmmrm512|b32       [rvm:fv: evex.nds.512.f3.0f38.w0 27 /r ] AVX512,FUTURE
+VPTESTNMQ       kreg|mask,xmmreg,xmmrm128|b64       [rvm:fv: evex.nds.128.f3.0f38.w1 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTNMQ       kreg|mask,ymmreg,ymmrm256|b64       [rvm:fv: evex.nds.256.f3.0f38.w1 27 /r ] AVX512VL,AVX512,FUTURE
+VPTESTNMQ       kreg|mask,zmmreg,zmmrm512|b64       [rvm:fv: evex.nds.512.f3.0f38.w1 27 /r ] AVX512,FUTURE
+VPTESTNMW       kreg|mask,xmmreg,xmmrm128           [rvm:fvm: evex.nds.128.f3.0f38.w1 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTNMW       kreg|mask,ymmreg,ymmrm256           [rvm:fvm: evex.nds.256.f3.0f38.w1 26 /r ] AVX512VL,AVX512BW,FUTURE
+VPTESTNMW       kreg|mask,zmmreg,zmmrm512           [rvm:fvm: evex.nds.512.f3.0f38.w1 26 /r ] AVX512BW,FUTURE
+VPUNPCKHBW      xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig 68 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKHBW      ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig 68 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKHBW      zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig 68 /r ] AVX512BW,FUTURE
+VPUNPCKHDQ      xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 6a /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKHDQ      ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 6a /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKHDQ      zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 6a /r ] AVX512,FUTURE
+VPUNPCKHQDQ     xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 6d /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKHQDQ     ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 6d /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKHQDQ     zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 6d /r ] AVX512,FUTURE
+VPUNPCKHWD      xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig 69 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKHWD      ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig 69 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKHWD      zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig 69 /r ] AVX512BW,FUTURE
+VPUNPCKLBW      xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig 60 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKLBW      ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig 60 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKLBW      zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig 60 /r ] AVX512BW,FUTURE
+VPUNPCKLDQ      xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 62 /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKLDQ      ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 62 /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKLDQ      zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 62 /r ] AVX512,FUTURE
+VPUNPCKLQDQ     xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 6c /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKLQDQ     ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 6c /r ] AVX512VL,AVX512,FUTURE
+VPUNPCKLQDQ     zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 6c /r ] AVX512,FUTURE
+VPUNPCKLWD      xmmreg|mask|z,xmmreg*,xmmrm128      [rvm:fvm: evex.nds.128.66.0f.wig 61 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKLWD      ymmreg|mask|z,ymmreg*,ymmrm256      [rvm:fvm: evex.nds.256.66.0f.wig 61 /r ] AVX512VL,AVX512BW,FUTURE
+VPUNPCKLWD      zmmreg|mask|z,zmmreg*,zmmrm512      [rvm:fvm: evex.nds.512.66.0f.wig 61 /r ] AVX512BW,FUTURE
+VPXORD          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f.w0 ef /r ] AVX512VL,AVX512,FUTURE
+VPXORD          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f.w0 ef /r ] AVX512VL,AVX512,FUTURE
+VPXORD          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.66.0f.w0 ef /r ] AVX512,FUTURE
+VPXORQ          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 ef /r ] AVX512VL,AVX512,FUTURE
+VPXORQ          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 ef /r ] AVX512VL,AVX512,FUTURE
+VPXORQ          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 ef /r ] AVX512,FUTURE
+VRANGEPD        xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w1 50 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VRANGEPD        ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w1 50 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VRANGEPD        zmmreg|mask|z,zmmreg*,zmmrm512|b64|sae,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w1 50 /r ib ] AVX512DQ,FUTURE
+VRANGEPS        xmmreg|mask|z,xmmreg*,xmmrm128|b32,imm8 [rvmi:fv: evex.nds.128.66.0f3a.w0 50 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VRANGEPS        ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w0 50 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VRANGEPS        zmmreg|mask|z,zmmreg*,zmmrm512|b32|sae,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w0 50 /r ib ] AVX512DQ,FUTURE
+VRANGESD        xmmreg|mask|z,xmmreg*,xmmrm64|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w1 51 /r ib ] AVX512DQ,FUTURE
+VRANGESS        xmmreg|mask|z,xmmreg*,xmmrm32|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w0 51 /r ib ] AVX512DQ,FUTURE
+VRCP14PD        xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f38.w1 4c /r ] AVX512VL,AVX512,FUTURE
+VRCP14PD        ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f38.w1 4c /r ] AVX512VL,AVX512,FUTURE
+VRCP14PD        zmmreg|mask|z,zmmrm512|b64          [rm:fv: evex.512.66.0f38.w1 4c /r ] AVX512,FUTURE
+VRCP14PS        xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f38.w0 4c /r ] AVX512VL,AVX512,FUTURE
+VRCP14PS        ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f38.w0 4c /r ] AVX512VL,AVX512,FUTURE
+VRCP14PS        zmmreg|mask|z,zmmrm512|b32          [rm:fv: evex.512.66.0f38.w0 4c /r ] AVX512,FUTURE
+VRCP14SD        xmmreg|mask|z,xmmreg*,xmmrm64       [rvm:t1s: evex.nds.128.66.0f38.w1 4d /r ] AVX512,FUTURE
+VRCP14SS        xmmreg|mask|z,xmmreg*,xmmrm32       [rvm:t1s: evex.nds.128.66.0f38.w0 4d /r ] AVX512,FUTURE
+VRCP28PD        zmmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f38.w1 ca /r ] AVX512ER,FUTURE
+VRCP28PS        zmmreg|mask|z,zmmrm512|b32|sae      [rm:fv: evex.512.66.0f38.w0 ca /r ] AVX512ER,FUTURE
+VRCP28SD        xmmreg|mask|z,xmmreg*,xmmrm64|sae   [rvm:t1s: evex.nds.128.66.0f38.w1 cb /r ] AVX512ER,FUTURE
+VRCP28SS        xmmreg|mask|z,xmmreg*,xmmrm32|sae   [rvm:t1s: evex.nds.128.66.0f38.w0 cb /r ] AVX512ER,FUTURE
+VREDUCEPD       xmmreg|mask|z,xmmrm128|b64,imm8     [rmi:fv: evex.128.66.0f3a.w1 56 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VREDUCEPD       ymmreg|mask|z,ymmrm256|b64,imm8     [rmi:fv: evex.256.66.0f3a.w1 56 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VREDUCEPD       zmmreg|mask|z,zmmrm512|b64|sae,imm8 [rmi:fv: evex.512.66.0f3a.w1 56 /r ib ] AVX512DQ,FUTURE
+VREDUCEPS       xmmreg|mask|z,xmmrm128|b32,imm8     [rmi:fv: evex.128.66.0f3a.w0 56 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VREDUCEPS       ymmreg|mask|z,ymmrm256|b32,imm8     [rmi:fv: evex.256.66.0f3a.w0 56 /r ib ] AVX512VL,AVX512DQ,FUTURE
+VREDUCEPS       zmmreg|mask|z,zmmrm512|b32|sae,imm8 [rmi:fv: evex.512.66.0f3a.w0 56 /r ib ] AVX512DQ,FUTURE
+VREDUCESD       xmmreg|mask|z,xmmreg*,xmmrm64|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w1 57 /r ib ] AVX512DQ,FUTURE
+VREDUCESS       xmmreg|mask|z,xmmreg*,xmmrm32|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w0 57 /r ib ] AVX512DQ,FUTURE
+VRNDSCALEPD     xmmreg|mask|z,xmmrm128|b64,imm8     [rmi:fv: evex.128.66.0f3a.w1 09 /r ib ] AVX512VL,AVX512,FUTURE
+VRNDSCALEPD     ymmreg|mask|z,ymmrm256|b64,imm8     [rmi:fv: evex.256.66.0f3a.w1 09 /r ib ] AVX512VL,AVX512,FUTURE
+VRNDSCALEPD     zmmreg|mask|z,zmmrm512|b64|sae,imm8 [rmi:fv: evex.512.66.0f3a.w1 09 /r ib ] AVX512,FUTURE
+VRNDSCALEPS     xmmreg|mask|z,xmmrm128|b32,imm8     [rmi:fv: evex.128.66.0f3a.w0 08 /r ib ] AVX512VL,AVX512,FUTURE
+VRNDSCALEPS     ymmreg|mask|z,ymmrm256|b32,imm8     [rmi:fv: evex.256.66.0f3a.w0 08 /r ib ] AVX512VL,AVX512,FUTURE
+VRNDSCALEPS     zmmreg|mask|z,zmmrm512|b32|sae,imm8 [rmi:fv: evex.512.66.0f3a.w0 08 /r ib ] AVX512,FUTURE
+VRNDSCALESD     xmmreg|mask|z,xmmreg*,xmmrm64|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w1 0b /r ib ] AVX512,FUTURE
+VRNDSCALESS     xmmreg|mask|z,xmmreg*,xmmrm32|sae,imm8 [rvmi:t1s: evex.nds.128.66.0f3a.w0 0a /r ib ] AVX512,FUTURE
+VRSQRT14PD      xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f38.w1 4e /r ] AVX512VL,AVX512,FUTURE
+VRSQRT14PD      ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f38.w1 4e /r ] AVX512VL,AVX512,FUTURE
+VRSQRT14PD      zmmreg|mask|z,zmmrm512|b64          [rm:fv: evex.512.66.0f38.w1 4e /r ] AVX512,FUTURE
+VRSQRT14PS      xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.66.0f38.w0 4e /r ] AVX512VL,AVX512,FUTURE
+VRSQRT14PS      ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.66.0f38.w0 4e /r ] AVX512VL,AVX512,FUTURE
+VRSQRT14PS      zmmreg|mask|z,zmmrm512|b32          [rm:fv: evex.512.66.0f38.w0 4e /r ] AVX512,FUTURE
+VRSQRT14SD      xmmreg|mask|z,xmmreg*,xmmrm64       [rvm:t1s: evex.nds.128.66.0f38.w1 4f /r ] AVX512,FUTURE
+VRSQRT14SS      xmmreg|mask|z,xmmreg*,xmmrm32       [rvm:t1s: evex.nds.128.66.0f38.w0 4f /r ] AVX512,FUTURE
+VRSQRT28PD      zmmreg|mask|z,zmmrm512|b64|sae      [rm:fv: evex.512.66.0f38.w1 cc /r ] AVX512ER,FUTURE
+VRSQRT28PS      zmmreg|mask|z,zmmrm512|b32|sae      [rm:fv: evex.512.66.0f38.w0 cc /r ] AVX512ER,FUTURE
+VRSQRT28SD      xmmreg|mask|z,xmmreg*,xmmrm64|sae   [rvm:t1s: evex.nds.128.66.0f38.w1 cd /r ] AVX512ER,FUTURE
+VRSQRT28SS      xmmreg|mask|z,xmmreg*,xmmrm32|sae   [rvm:t1s: evex.nds.128.66.0f38.w0 cd /r ] AVX512ER,FUTURE
+VSCALEFPD       xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f38.w1 2c /r ] AVX512VL,AVX512,FUTURE
+VSCALEFPD       ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f38.w1 2c /r ] AVX512VL,AVX512,FUTURE
+VSCALEFPD       zmmreg|mask|z,zmmreg*,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f38.w1 2c /r ] AVX512,FUTURE
+VSCALEFPS       xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.66.0f38.w0 2c /r ] AVX512VL,AVX512,FUTURE
+VSCALEFPS       ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.66.0f38.w0 2c /r ] AVX512VL,AVX512,FUTURE
+VSCALEFPS       zmmreg|mask|z,zmmreg*,zmmrm512|b32|er [rvm:fv: evex.nds.512.66.0f38.w0 2c /r ] AVX512,FUTURE
+VSCALEFSD       xmmreg|mask|z,xmmreg*,xmmrm64|er    [rvm:t1s: evex.nds.128.66.0f38.w1 2d /r ] AVX512,FUTURE
+VSCALEFSS       xmmreg|mask|z,xmmreg*,xmmrm32|er    [rvm:t1s: evex.nds.128.66.0f38.w0 2d /r ] AVX512,FUTURE
+VSCATTERDPD     xmem64|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w1 a2 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERDPD     xmem64|mask,ymmreg                  [mr:t1s: vsibx evex.256.66.0f38.w1 a2 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERDPD     ymem64|mask,zmmreg                  [mr:t1s: vsiby evex.512.66.0f38.w1 a2 /r ] AVX512,FUTURE
+VSCATTERDPS     xmem32|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w0 a2 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERDPS     ymem32|mask,ymmreg                  [mr:t1s: vsiby evex.256.66.0f38.w0 a2 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERDPS     zmem32|mask,zmmreg                  [mr:t1s: vsibz evex.512.66.0f38.w0 a2 /r ] AVX512,FUTURE
+VSCATTERPF0DPD  ymem64|mask                         [m:t1s: vsiby evex.512.66.0f38.w1 c6 /5 ] AVX512PF,FUTURE
+VSCATTERPF0DPS  zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c6 /5 ] AVX512PF,FUTURE
+VSCATTERPF0QPD  zmem64|mask                         [m:t1s: vsibz evex.512.66.0f38.w1 c7 /5 ] AVX512PF,FUTURE
+VSCATTERPF0QPS  zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c7 /5 ] AVX512PF,FUTURE
+VSCATTERPF1DPD  ymem64|mask                         [m:t1s: vsiby evex.512.66.0f38.w1 c6 /6 ] AVX512PF,FUTURE
+VSCATTERPF1DPS  zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c6 /6 ] AVX512PF,FUTURE
+VSCATTERPF1QPD  zmem64|mask                         [m:t1s: vsibz evex.512.66.0f38.w1 c7 /6 ] AVX512PF,FUTURE
+VSCATTERPF1QPS  zmem32|mask                         [m:t1s: vsibz evex.512.66.0f38.w0 c7 /6 ] AVX512PF,FUTURE
+VSCATTERQPD     xmem64|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w1 a3 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERQPD     ymem64|mask,ymmreg                  [mr:t1s: vsiby evex.256.66.0f38.w1 a3 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERQPD     zmem64|mask,zmmreg                  [mr:t1s: vsibz evex.512.66.0f38.w1 a3 /r ] AVX512,FUTURE
+VSCATTERQPS     xmem32|mask,xmmreg                  [mr:t1s: vsibx evex.128.66.0f38.w0 a3 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERQPS     ymem32|mask,xmmreg                  [mr:t1s: vsiby evex.256.66.0f38.w0 a3 /r ] AVX512VL,AVX512,FUTURE
+VSCATTERQPS     zmem32|mask,ymmreg                  [mr:t1s: vsibz evex.512.66.0f38.w0 a3 /r ] AVX512,FUTURE
+VSHUFF32X4      ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w0 23 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFF32X4      zmmreg|mask|z,zmmreg*,zmmrm512|b32,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w0 23 /r ib ] AVX512,FUTURE
+VSHUFF64X2      ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w1 23 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFF64X2      zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w1 23 /r ib ] AVX512,FUTURE
+VSHUFI32X4      ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w0 43 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFI32X4      zmmreg|mask|z,zmmreg*,zmmrm512|b32,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w0 43 /r ib ] AVX512,FUTURE
+VSHUFI64X2      ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f3a.w1 43 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFI64X2      zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8 [rvmi:fv: evex.nds.512.66.0f3a.w1 43 /r ib ] AVX512,FUTURE
+VSHUFPD         xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8 [rvmi:fv: evex.nds.128.66.0f.w1 c6 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFPD         ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8 [rvmi:fv: evex.nds.256.66.0f.w1 c6 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFPD         zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8 [rvmi:fv: evex.nds.512.66.0f.w1 c6 /r ib ] AVX512,FUTURE
+VSHUFPS         xmmreg|mask|z,xmmreg*,xmmrm128|b32,imm8 [rvmi:fv: evex.nds.128.0f.w0 c6 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFPS         ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8 [rvmi:fv: evex.nds.256.0f.w0 c6 /r ib ] AVX512VL,AVX512,FUTURE
+VSHUFPS         zmmreg|mask|z,zmmreg*,zmmrm512|b32,imm8 [rvmi:fv: evex.nds.512.0f.w0 c6 /r ib ] AVX512,FUTURE
+VSQRTPD         xmmreg|mask|z,xmmrm128|b64          [rm:fv: evex.128.66.0f.w1 51 /r ] AVX512VL,AVX512,FUTURE
+VSQRTPD         ymmreg|mask|z,ymmrm256|b64          [rm:fv: evex.256.66.0f.w1 51 /r ] AVX512VL,AVX512,FUTURE
+VSQRTPD         zmmreg|mask|z,zmmrm512|b64|er       [rm:fv: evex.512.66.0f.w1 51 /r ] AVX512,FUTURE
+VSQRTPS         xmmreg|mask|z,xmmrm128|b32          [rm:fv: evex.128.0f.w0 51 /r ] AVX512VL,AVX512,FUTURE
+VSQRTPS         ymmreg|mask|z,ymmrm256|b32          [rm:fv: evex.256.0f.w0 51 /r ] AVX512VL,AVX512,FUTURE
+VSQRTPS         zmmreg|mask|z,zmmrm512|b32|er       [rm:fv: evex.512.0f.w0 51 /r ] AVX512,FUTURE
+VSQRTSD         xmmreg|mask|z,xmmreg*,xmmrm64|er    [rvm:t1s: evex.nds.128.f2.0f.w1 51 /r ] AVX512,FUTURE
+VSQRTSS         xmmreg|mask|z,xmmreg*,xmmrm32|er    [rvm:t1s: evex.nds.128.f3.0f.w0 51 /r ] AVX512,FUTURE
+VSUBPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 5c /r ] AVX512VL,AVX512,FUTURE
+VSUBPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 5c /r ] AVX512VL,AVX512,FUTURE
+VSUBPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64|er [rvm:fv: evex.nds.512.66.0f.w1 5c /r ] AVX512,FUTURE
+VSUBPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 5c /r ] AVX512VL,AVX512,FUTURE
+VSUBPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 5c /r ] AVX512VL,AVX512,FUTURE
+VSUBPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32|er [rvm:fv: evex.nds.512.0f.w0 5c /r ] AVX512,FUTURE
+VSUBSD          xmmreg|mask|z,xmmreg*,xmmrm64|er    [rvm:t1s: evex.nds.128.f2.0f.w1 5c /r ] AVX512,FUTURE
+VSUBSS          xmmreg|mask|z,xmmreg*,xmmrm32|er    [rvm:t1s: evex.nds.128.f3.0f.w0 5c /r ] AVX512,FUTURE
+VUCOMISD        xmmreg,xmmrm64|sae                  [rm:t1s: evex.128.66.0f.w1 2e /r ] AVX512,FUTURE
+VUCOMISS        xmmreg,xmmrm32|sae                  [rm:t1s: evex.128.0f.w0 2e /r ] AVX512,FUTURE
+VUNPCKHPD       xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 15 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKHPD       ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 15 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKHPD       zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 15 /r ] AVX512,FUTURE
+VUNPCKHPS       xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKHPS       ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 15 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKHPS       zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.0f.w0 15 /r ] AVX512,FUTURE
+VUNPCKLPD       xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 14 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKLPD       ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 14 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKLPD       zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 14 /r ] AVX512,FUTURE
+VUNPCKLPS       xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKLPS       ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 14 /r ] AVX512VL,AVX512,FUTURE
+VUNPCKLPS       zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.0f.w0 14 /r ] AVX512,FUTURE
+VXORPD          xmmreg|mask|z,xmmreg*,xmmrm128|b64  [rvm:fv: evex.nds.128.66.0f.w1 57 /r ] AVX512VL,AVX512DQ,FUTURE
+VXORPD          ymmreg|mask|z,ymmreg*,ymmrm256|b64  [rvm:fv: evex.nds.256.66.0f.w1 57 /r ] AVX512VL,AVX512DQ,FUTURE
+VXORPD          zmmreg|mask|z,zmmreg*,zmmrm512|b64  [rvm:fv: evex.nds.512.66.0f.w1 57 /r ] AVX512DQ,FUTURE
+VXORPS          xmmreg|mask|z,xmmreg*,xmmrm128|b32  [rvm:fv: evex.nds.128.0f.w0 57 /r ] AVX512VL,AVX512DQ,FUTURE
+VXORPS          ymmreg|mask|z,ymmreg*,ymmrm256|b32  [rvm:fv: evex.nds.256.0f.w0 57 /r ] AVX512VL,AVX512DQ,FUTURE
+VXORPS          zmmreg|mask|z,zmmreg*,zmmrm512|b32  [rvm:fv: evex.nds.512.0f.w0 57 /r ] AVX512DQ,FUTURE
+; MJC PUBLIC END
+
+;# Intel memory protection keys for userspace (PKU aka PKEYs)
+RDPKRU		void				[	0f 01 ee]				LONG,FUTURE
+WRPKRU		void				[	0f 01 ef]				LONG,FUTURE
+
+;# Read Processor ID
+RDPID		reg32				[m:	f3 0f c7 /7]				NOLONG,FUTURE
+RDPID		reg64				[m:	o64nw f3 0f c7 /7]			LONG,FUTURE
+RDPID		reg32				[m:	f3 0f c7 /7]				LONG,UNDOC,FUTURE
+
+;# New memory instructions
+CLFLUSHOPT	mem				[m:	66 0f ae /7]				FUTURE
+CLWB            mem                             [m:     66 0f ae /6]                            FUTURE
+; This one was killed before it saw the light of day
+PCOMMIT         void                            [       66 0f ae f8]                            FUTURE,NEVER,NOP
+
+; AMD Zen v1
+CLZERO		void				[	0f 01 fc]				FUTURE,AMD
+CLZERO		reg_ax				[-:	a16 0f 01 fc]				FUTURE,AMD,ND,NOLONG
+CLZERO		reg_eax				[-:	a32 0f 01 fc]				FUTURE,AMD,ND
+CLZERO		reg_rax				[-:	a64 0f 01 fc]				FUTURE,AMD,ND,LONG
+
+;# Processor trace write
+PTWRITE		rm32				[m:	np 0f ae /4]				FUTURE
+PTWRITE		rm64				[m:	o64 np 0f ae /4]			LONG,FUTURE
+
+;# Instructions from the Intel Instruction Set Extensions,
+;# doc 319433-034 May 2018
+CLDEMOTE	mem				[m:	np 0f 1c /0]				FUTURE
+MOVDIRI		mem32,reg32			[mr:	np 0f 38 f9 /r]				FUTURE,SD
+MOVDIRI		mem64,reg64			[mr:	o64 0f 38 f9 /r]			FUTURE,LONG,SQ
+MOVDIR64B	reg16,mem512			[rm:	a16 66 0f 38 f8 /r]			FUTURE,NOLONG
+MOVDIR64B	reg32,mem512			[rm:	a32 66 0f 38 f8 /r]			FUTURE
+MOVDIR64B	reg64,mem512			[rm:	o64nw a64 66 0f 38 f8 /r]		FUTURE,LONG
+PCONFIG		void				[	np 0f 01 c5]				FUTURE
+TPAUSE		reg32				[m:	66 0f ae /6]				FUTURE
+TPAUSE		reg32,reg_edx,reg_eax		[m--:	66 0f ae /6]				FUTURE,ND
+UMONITOR	reg16				[m:	a16 f3 0f ae /6]			FUTURE,NOLONG
+UMONITOR	reg32				[m:	a32 f3 0f ae /6]			FUTURE
+UMONITOR	reg64				[m:	o64nw a64 f3 0f ae /6]			FUTURE,LONG
+UMWAIT		reg32				[m:	f2 0f ae /6]				FUTURE
+UMWAIT		reg32,reg_edx,reg_eax		[m--:	f2 0f ae /6]				FUTURE,ND
+WBNOINVD	void				[	f3 0f 09]				FUTURE
+
+;# Galois field operations (GFNI)
+GF2P8AFFINEINVQB	xmmreg,xmmrm128,imm8			[rmi:	  66 0f 3a cf /r ib]			GFNI,SSE,FUTURE
+VGF2P8AFFINEINVQB	xmmreg,xmmreg*,xmmrm128,imm8		[rvmi:	  vex.nds.128.66.0f3a.w1 cf /r ib]	GFNI,AVX,FUTURE
+VGF2P8AFFINEINVQB	ymmreg,ymmreg*,ymmrm256,imm8		[rvmi:	  vex.nds.256.66.0f3a.w1 cf /r ib]	GFNI,AVX,FUTURE
+VGF2P8AFFINEINVQB	xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8	[rvmi:fv: evex.nds.128.66.0f3a.w1 cf /r ib]	GFNI,AVX512VL,FUTURE
+VGF2P8AFFINEINVQB	ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8	[rvmi:fv: evex.nds.256.66.0f3a.w1 cf /r ib]	GFNI,AVX512VL,FUTURE
+VGF2P8AFFINEINVQB	zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8	[rvmi:fv: evex.nds.512.66.0f3a.w1 cf /r ib]	GFNI,AVX512,FUTURE
+GF2P8AFFINEQB   	xmmreg,xmmrm128,imm8			[rmi:	  66 0f 3a ce /r ib]			GFNI,SSE,FUTURE
+VGF2P8AFFINEQB   	xmmreg,xmmreg*,xmmrm128,imm8		[rvmi:	  vex.nds.128.66.0f3a.w1 ce /r ib]	GFNI,AVX,FUTURE
+VGF2P8AFFINEQB   	ymmreg,ymmreg*,ymmrm256,imm8		[rvmi:	  vex.nds.256.66.0f3a.w1 ce /r ib]	GFNI,AVX,FUTURE
+VGF2P8AFFINEQB   	xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8	[rvmi:fv: evex.nds.128.66.0f3a.w1 ce /r ib]	GFNI,AVX512VL,FUTURE
+VGF2P8AFFINEQB   	ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8	[rvmi:fv: evex.nds.256.66.0f3a.w1 ce /r ib]	GFNI,AVX512VL,FUTURE
+VGF2P8AFFINEQB   	zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8	[rvmi:fv: evex.nds.512.66.0f3a.w1 ce /r ib]	GFNI,AVX512,FUTURE
+GF2P8MULB		xmmreg,xmmrm128				[rm:      66 0f 38 cf /r]			GFNI,SSE,FUTURE
+VGF2P8MULB		xmmreg,xmmreg*,xmmrm128			[rvm:     vex.nds.128.66.0f38.w0 cf /r]		GFNI,AVX,FUTURE
+VGF2P8MULB		ymmreg,ymmreg*,ymmrm256			[rvm:     vex.nds.256.66.0f38.w0 cf /r]		GFNI,AVX,FUTURE
+VGF2P8MULB		xmmreg|mask|z,xmmreg*,xmmrm128		[rvm:fvm: evex.nds.128.66.0f38.w0 cf /r]	GFNI,AVX512VL,FUTURE
+VGF2P8MULB		ymmreg|mask|z,ymmreg*,ymmrm256		[rvm:fvm: evex.nds.256.66.0f38.w0 cf /r]	GFNI,AVX512VL,FUTURE
+VGF2P8MULB		zmmreg|mask|z,zmmreg*,zmmrm512		[rvm:fvm: evex.nds.512.66.0f38.w0 cf /r]	GFNI,AVX512,FUTURE
+
+;# AVX512 Vector Bit Manipulation Instructions 2
+VPCOMPRESSB     mem128|mask,xmmreg                      [mr:t1s8:  evex.128.66.0f38.w0 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSB     mem256|mask,ymmreg                      [mr:t1s8:  evex.256.66.0f38.w0 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSB     mem512|mask,zmmreg                      [mr:t1s8:  evex.512.66.0f38.w0 63 /r]		AVX512VBMI2,FUTURE
+VPCOMPRESSB     xmmreg|mask|z,xmmreg                    [mr:       evex.128.66.0f38.w0 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSB     ymmreg|mask|z,ymmreg                    [mr:       evex.256.66.0f38.w0 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSB     zmmreg|mask|z,zmmreg                    [mr:       evex.512.66.0f38.w0 63 /r]		AVX512VBMI2,FUTURE
+VPCOMPRESSW     mem128|mask,xmmreg                      [mr:t1s16: evex.128.66.0f38.w1 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSW     mem256|mask,ymmreg                      [mr:t1s16: evex.256.66.0f38.w1 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSW     mem512|mask,zmmreg                      [mr:t1s16: evex.512.66.0f38.w1 63 /r]		AVX512VBMI2,FUTURE
+VPCOMPRESSW     xmmreg|mask|z,xmmreg                    [mr:       evex.128.66.0f38.w1 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSW     ymmreg|mask|z,ymmreg                    [mr:       evex.256.66.0f38.w1 63 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPCOMPRESSW     zmmreg|mask|z,zmmreg                    [mr:       evex.512.66.0f38.w1 63 /r]		AVX512VBMI2,FUTURE
+VPEXPANDB       xmmreg|mask|z,xmmrm128                  [rm:t1s8:  evex.128.66.0f38.w0 62 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPEXPANDB       ymmreg|mask|z,ymmrm256                  [rm:t1s8:  evex.256.66.0f38.w0 62 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPEXPANDB       zmmreg|mask|z,zmmrm512                  [rm:t1s8:  evex.512.66.0f38.w0 62 /r]		AVX512VBMI2,FUTURE
+VPEXPANDW       xmmreg|mask|z,xmmrm128                  [rm:t1s16: evex.128.66.0f38.w1 62 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPEXPANDW       ymmreg|mask|z,ymmrm256                  [rm:t1s16: evex.256.66.0f38.w1 62 /r]		AVX512VBMI2,AVX512VL,FUTURE
+VPEXPANDW       zmmreg|mask|z,zmmrm512                  [rm:t1s16: evex.512.66.0f38.w1 62 /r]		AVX512VBMI2,FUTURE
+VPSHLDW		xmmreg|mask|z,xmmreg*,xmmrm128,imm8	[rvmi:fvm: evex.nds.128.66.0f3a.w1 70 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDW		ymmreg|mask|z,ymmreg*,ymmrm256,imm8	[rvmi:fvm: evex.nds.256.66.0f3a.w1 70 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDW		zmmreg|mask|z,zmmreg*,zmmrm512,imm8	[rvmi:fvm: evex.nds.512.66.0f3a.w1 70 /r ib]	AVX512VBMI2,FUTURE
+VPSHLDD		xmmreg|mask|z,xmmreg*,xmmrm128|b32,imm8	[rvmi:fv:  evex.nds.128.66.0f3a.w0 71 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDD		ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8	[rvmi:fv:  evex.nds.256.66.0f3a.w0 71 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDD		zmmreg|mask|z,zmmreg*,zmmrm512|b32,imm8	[rvmi:fv:  evex.nds.512.66.0f3a.w0 71 /r ib]	AVX512VBMI2,FUTURE
+VPSHLDQ		xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8	[rvmi:fv:  evex.nds.128.66.0f3a.w1 71 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDQ		ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8	[rvmi:fv:  evex.nds.256.66.0f3a.w1 71 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDQ		zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8	[rvmi:fv:  evex.nds.512.66.0f3a.w1 71 /r ib]	AVX512VBMI2,FUTURE
+VPSHLDVW	xmmreg|mask|z,xmmreg*,xmmrm128		[rvmi:fvm: evex.dds.128.66.0f38.w1 70 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDVW	ymmreg|mask|z,ymmreg*,ymmrm256		[rvmi:fvm: evex.dds.256.66.0f38.w1 70 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDVW	zmmreg|mask|z,zmmreg*,zmmrm512		[rvmi:fvm: evex.dds.512.66.0f38.w1 70 /r]	AVX512VBMI2,FUTURE
+VPSHLDVD	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvmi:fv:  evex.dds.128.66.0f38.w0 71 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDVD	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvmi:fv:  evex.dds.256.66.0f38.w0 71 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDVD	zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvmi:fv:  evex.dds.512.66.0f38.w0 71 /r]	AVX512VBMI2,FUTURE
+VPSHLDVQ	xmmreg|mask|z,xmmreg*,xmmrm128|b64	[rvmi:fv:  evex.dds.128.66.0f38.w1 71 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDVQ	ymmreg|mask|z,ymmreg*,ymmrm256|b64	[rvmi:fv:  evex.dds.256.66.0f38.w1 71 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHLDVQ	zmmreg|mask|z,zmmreg*,zmmrm512|b64	[rvmi:fv:  evex.dds.512.66.0f38.w1 71 /r]	AVX512VBMI2,FUTURE
+VPSHRDW		xmmreg|mask|z,xmmreg*,xmmrm128,imm8	[rvmi:fvm: evex.nds.128.66.0f3a.w1 72 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDW		ymmreg|mask|z,ymmreg*,ymmrm256,imm8	[rvmi:fvm: evex.nds.256.66.0f3a.w1 72 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDW		zmmreg|mask|z,zmmreg*,zmmrm512,imm8	[rvmi:fvm: evex.nds.512.66.0f3a.w1 72 /r ib]	AVX512VBMI2,FUTURE
+VPSHRDD		xmmreg|mask|z,xmmreg*,xmmrm128|b32,imm8	[rvmi:fv:  evex.nds.128.66.0f3a.w0 73 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDD		ymmreg|mask|z,ymmreg*,ymmrm256|b32,imm8	[rvmi:fv:  evex.nds.256.66.0f3a.w0 73 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDD		zmmreg|mask|z,zmmreg*,zmmrm512|b32,imm8	[rvmi:fv:  evex.nds.512.66.0f3a.w0 73 /r ib]	AVX512VBMI2,FUTURE
+VPSHRDQ		xmmreg|mask|z,xmmreg*,xmmrm128|b64,imm8	[rvmi:fv:  evex.nds.128.66.0f3a.w1 73 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDQ		ymmreg|mask|z,ymmreg*,ymmrm256|b64,imm8	[rvmi:fv:  evex.nds.256.66.0f3a.w1 73 /r ib]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDQ		zmmreg|mask|z,zmmreg*,zmmrm512|b64,imm8	[rvmi:fv:  evex.nds.512.66.0f3a.w1 73 /r ib]	AVX512VBMI2,FUTURE
+VPSHRDVW	xmmreg|mask|z,xmmreg*,xmmrm128    	[rvmi:fvm: evex.dds.128.66.0f38.w1 72 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDVW	ymmreg|mask|z,ymmreg*,ymmrm256		[rvmi:fvm: evex.dds.256.66.0f38.w1 72 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDVW	zmmreg|mask|z,zmmreg*,zmmrm512		[rvmi:fvm: evex.dds.512.66.0f38.w1 72 /r]	AVX512VBMI2,FUTURE
+VPSHRDVD	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvmi:fv:  evex.dds.128.66.0f38.w0 73 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDVD	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvmi:fv:  evex.dds.256.66.0f38.w0 73 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDVD	zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvmi:fv:  evex.dds.512.66.0f38.w0 73 /r]	AVX512VBMI2,FUTURE
+VPSHRDVQ	xmmreg|mask|z,xmmreg*,xmmrm128|b64	[rvmi:fv:  evex.dds.128.66.0f38.w1 73 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDVQ	ymmreg|mask|z,ymmreg*,ymmrm256|b64	[rvmi:fv:  evex.dds.256.66.0f38.w1 73 /r]	AVX512VBMI2,AVX512VL,FUTURE
+VPSHRDVQ	zmmreg|mask|z,zmmreg*,zmmrm512|b64	[rvmi:fv:  evex.dds.512.66.0f38.w1 73 /r]	AVX512VBMI2,FUTURE
+
+;# AVX512 VNNI
+VPDPBUSD		xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:  evex.dds.128.66.0f38.w0 50 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPBUSD		ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv:  evex.dds.256.66.0f38.w0 50 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPBUSD		zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvm:fv:  evex.dds.512.66.0f38.w0 50 /r]	AVX512VNNI,FUTURE
+VPDPBUSDS		xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:  evex.dds.128.66.0f38.w0 51 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPBUSDS		ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv:  evex.dds.256.66.0f38.w0 51 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPBUSDS		zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvm:fv:  evex.dds.512.66.0f38.w0 51 /r]	AVX512VNNI,FUTURE
+VPDPWSSD		xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:  evex.dds.128.66.0f38.w0 52 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPWSSD		ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv:  evex.dds.256.66.0f38.w0 52 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPWSSD		zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvm:fv:  evex.dds.512.66.0f38.w0 52 /r]	AVX512VNNI,FUTURE
+VPDPWSSDS		xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:  evex.dds.128.66.0f38.w0 53 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPWSSDS		ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv:  evex.dds.256.66.0f38.w0 53 /r]	AVX512VNNI,AVX512VL,FUTURE
+VPDPWSSDS		zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvm:fv:  evex.dds.512.66.0f38.w0 53 /r]	AVX512VNNI,FUTURE
+
+;# AVX512 Bit Algorithms
+VPOPCNTB		xmmreg|mask|z,xmmrm128			[rm:fvm:  evex.128.66.0f38.w0 54 /r]		AVX512BITALG,AVX512VL,FUTURE
+VPOPCNTB		ymmreg|mask|z,ymmrm256			[rm:fvm:  evex.256.66.0f38.w0 54 /r]		AVX512BITALG,AVX512VL,FUTURE
+VPOPCNTB		zmmreg|mask|z,zmmrm512			[rm:fvm:  evex.512.66.0f38.w0 54 /r]		AVX512BITALG,FUTURE
+VPOPCNTW		xmmreg|mask|z,xmmrm128			[rm:fvm:  evex.128.66.0f38.w1 54 /r]		AVX512BITALG,AVX512VL,FUTURE
+VPOPCNTW		ymmreg|mask|z,ymmrm256			[rm:fvm:  evex.256.66.0f38.w1 54 /r]		AVX512BITALG,AVX512VL,FUTURE
+VPOPCNTW		zmmreg|mask|z,zmmrm512			[rm:fvm:  evex.512.66.0f38.w1 54 /r]		AVX512BITALG,FUTURE
+VPOPCNTD		xmmreg|mask|z,xmmrm128			[rm:fv:   evex.128.66.0f38.w0 55 /r]		AVX512VPOPCNTDQ,AVX512VL,FUTURE
+VPOPCNTD		ymmreg|mask|z,ymmrm256			[rm:fv:   evex.256.66.0f38.w0 55 /r]		AVX512VPOPCNTDQ,AVX512VL,FUTURE
+VPOPCNTD		zmmreg|mask|z,zmmrm512			[rm:fv:   evex.512.66.0f38.w0 55 /r]		AVX512VPOPCNTDQ,FUTURE
+VPOPCNTQ		xmmreg|mask|z,xmmrm128			[rm:fv:   evex.128.66.0f38.w1 55 /r]		AVX512VPOPCNTDQ,AVX512VL,FUTURE
+VPOPCNTQ		ymmreg|mask|z,ymmrm256			[rm:fv:   evex.256.66.0f38.w1 55 /r]		AVX512VPOPCNTDQ,AVX512VL,FUTURE
+VPOPCNTQ		zmmreg|mask|z,zmmrm512			[rm:fv:   evex.512.66.0f38.w1 55 /r]		AVX512VPOPCNTDQ,FUTURE
+VPSHUFBITQMB		kreg|mask,xmmreg,xmmrm128		[rvm:fvm: evex.nds.128.66.0f38.w0 8f /r]	AVX512BITALG,AVX512VL,FUTURE
+VPSHUFBITQMB		kreg|mask,ymmreg,ymmrm256		[rvm:fvm: evex.nds.256.66.0f38.w0 8f /r]	AVX512BITALG,AVX512VL,FUTURE
+VPSHUFBITQMB		kreg|mask,zmmreg,zmmrm512		[rvm:fvm: evex.nds.512.66.0f38.w0 8f /r]	AVX512BITALG,FUTURE
+
+;# AVX512 4-iteration Multiply-Add
+V4FMADDPS		zmmreg|mask|z,zmmreg|rs4,mem		[rvm:m128:evex.dds.512.f2.0f38.w0 9a /r]	AVX5124FMAPS,FUTURE,SO
+V4FNMADDPS		zmmreg|mask|z,zmmreg|rs4,mem		[rvm:m128:evex.dds.512.f2.0f38.w0 aa /r]	AVX5124FMAPS,FUTURE,SO
+V4FMADDSS		zmmreg|mask|z,zmmreg|rs4,mem		[rvm:m128:evex.dds.lig.f2.0f38.w0 9b /r]	AVX5124FMAPS,FUTURE,SO
+V4FNMADDSS		zmmreg|mask|z,zmmreg|rs4,mem		[rvm:m128:evex.dds.lig.f2.0f38.w0 ab /r]	AVX5124FMAPS,FUTURE,SO
+
+;# AVX512 4-iteration Dot Product
+V4DPWSSDS		zmmreg|mask|z,zmmreg|rs4,mem		[rvm:m128:evex.dds.512.f2.0f38.w0 53 /r]	AVX5124VNNIW,FUTURE,SO
+V4DPWSSD		zmmreg|mask|z,zmmreg|rs4,mem		[rvm:m128:evex.dds.512.f2.0f38.w0 52 /r]	AVX5124VNNIW,FUTURE,SO
+
+;# Intel Software Guard Extensions (SGX)
+ENCLS			void					[         np 0f 01 cf]				SGX,FUTURE
+ENCLU			void					[ 	  np 0f 01 d7]				SGX,FUTURE
+ENCLV			void					[	  np 0f 01 c0]				SGX,FUTURE
+
+;# Intel Control-Flow Enforcement Technology (CET)
+CLRSSBSY	mem64				[m:	f3 0f ae /6]				CET,FUTURE
+ENDBR32		void				[	f3 0f 1e fb]				CET,FUTURE
+ENDBR64		void				[	f3 0f 1e fa]				CET,FUTURE
+INCSSPD		reg32				[m:	o32 f3 0f ae /5]			CET,FUTURE
+INCSSPQ		reg64				[m:	o64 f3 0f ae /5]			CET,FUTURE,LONG
+RDSSPD		reg32				[m:	o32 f3 0f 1e /1]			CET,FUTURE
+RDSSPQ		reg64				[m:	o64 f3 0f 1e /1]			CET,FUTURE,LONG
+RSTORSSP	mem64				[m:	f3 0f 01 /5]				CET,FUTURE
+SAVEPREVSSP	void				[	f3 0f 01 ea]				CET,FUTURE
+SETSSBSY	void				[	f3 0f 01 e8]				CET,FUTURE
+WRUSSD		mem32,reg32			[mr:	o32 66 0f 38 f5 /r]			CET,FUTURE
+WRUSSQ		mem64,reg64			[mr:	o64 66 0f 38 f5 /r]			CET,FUTURE,LONG
+WRSSD		mem32,reg32			[mr:	o32 0f 38 f6 /r]			CET,FUTURE
+WRSSQ		mem64,reg64			[mr:	o64 0f 38 f6 /r]			CET,FUTURE,LONG
+
+;# Instructions from ISE doc 319433-040, June 2020
+ENQCMD		reg16,mem512			[rm:	a16 f2 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,NOLONG
+ENQCMD		reg32,mem512			[rm:	a16 f2 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,NOLONG,ND
+ENQCMD		reg32,mem512			[rm:	a32 f2 0f 38 f8 /r]			ENQCMD,FUTURE,SZ
+ENQCMD		reg64,mem512			[rm:	a64 f2 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,LONG
+ENQCMDS		reg16,mem512			[rm:	a16 f3 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,NOLONG,PRIV
+ENQCMDS		reg32,mem512			[rm:	a16 f3 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,NOLONG,PRIV,ND
+ENQCMDS		reg32,mem512			[rm:	a32 f3 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,PRIV
+ENQCMDS		reg64,mem512			[rm:	a64 f3 0f 38 f8 /r]			ENQCMD,FUTURE,SZ,PRIV,LONG
+PCONFIG		void				[	np 0f 01 c5]				PCONFIG,FUTURE,PRIV
+SERIALIZE	void				[	np 0f 01 e8]				SERIALIZE,FUTURE
+WBNOINVD	void				[	f3 0f 09]				WBNOINVD,FUTURE,PRIV
+XRESLDTRK	void				[	f2 0f 01 e9]				TSXLDTRK,FUTURE
+XSUSLDTRK	void				[	f2 0f 01 e8]				TSXLDTRK,FUTURE
+
+;# AVX512 Bfloat16 instructions
+VCVTNE2PS2BF16	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:	evex.128.f2.0f38.w0 72 /r]	AVX512BF16,FUTURE
+VCVTNE2PS2BF16	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv:	evex.256.f2.0f38.w0 72 /r]	AVX512BF16,FUTURE
+VCVTNE2PS2BF16	zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvm:fv:	evex.512.f2.0f38.w0 72 /r]	AVX512BF16,FUTURE
+VCVTNEPS2BF16	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:	evex.128.f3.0f38.w0 72 /r]	AVX512BF16,FUTURE
+VCVTNEPS2BF16	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv:	evex.256.f3.0f38.w0 72 /r]	AVX512BF16,FUTURE
+VCVTNEPS2BF16	zmmreg|mask|z,zmmreg*,zmmrm512|b32	[rvm:fv:	evex.512.f3.0f38.w0 72 /r]	AVX512BF16,FUTURE
+VDPBF16PS	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv:	evex.128.f3.0f38.w0 52 /r]	AVX512BF16,FUTURE
+VDPBF16PS	ymmreg|mask|z,ymmreg*,ymmrm128|b32	[rvm:fv:	evex.256.f3.0f38.w0 52 /r]	AVX512BF16,FUTURE
+VDPBF16PS	zmmreg|mask|z,zmmreg*,zmmrm128|b32	[rvm:fv:	evex.512.f3.0f38.w0 52 /r]	AVX512BF16,FUTURE
+
+;# AVX512 mask intersect instructions
+VP2INTERSECTD	kreg|rs2,xmmreg,xmmrm128|b32		[rvm:fv:	evex.nds.128.f2.0f38.w0 68 /r]	AVX512BF16,FUTURE
+VP2INTERSECTD	kreg|rs2,ymmreg,ymmrm128|b32		[rvm:fv:	evex.nds.256.f2.0f38.w0 68 /r]	AVX512BF16,FUTURE
+VP2INTERSECTD	kreg|rs2,zmmreg,zmmrm128|b32		[rvm:fv:	evex.nds.512.f2.0f38.w0 68 /r]	AVX512BF16,FUTURE
+
+;# Intel Advanced Matrix Extensions (AMX)
+LDTILECFG	mem512				[m:	vex.128.np.0f38.w0 49 /0]		AMXTILE,FUTURE,SZ,LONG
+STTILECFG	mem512				[m:	vex.128.66.0f38.w0 49 /0]		AMXTILE,FUTURE,SZ,LONG
+TDPBF16PS	tmmreg,tmmreg,tmmreg		[rmv:	vex.128.f3.0f38.w0 5c /r]		AMXBF16,FUTURE,LONG
+TDPBSSD		tmmreg,tmmreg,tmmreg		[rmv:	vex.128.f2.0f38.w0 5e /r]		AMXINT8,FUTURE,LONG
+TDPBSUD		tmmreg,tmmreg,tmmreg		[rmv:	vex.128.f3.0f38.w0 5e /r]		AMXINT8,FUTURE,LONG
+TDPBUSD		tmmreg,tmmreg,tmmreg		[rmv:	vex.128.66.0f38.w0 5e /r]		AMXINT8,FUTURE,LONG
+TDPBUUD		tmmreg,tmmreg,tmmreg		[rmv:	vex.128.np.0f38.w0 5e /r]		AMXINT8,FUTURE,LONG
+TILELOADD	tmmreg,mem			[rm:	vex.128.f2.0f38.w0 4b /r]		AMXTILE,MIB,SIB,FUTURE,SX,LONG
+TILELOADDT1	tmmreg,mem			[rm:	vex.128.66.0f38.w0 4b /r]		AMXTILE,MIB,SIB,FUTURE,SX,LONG
+TILERELEASE	void				[	vex.128.np.0f38.w0 49 c0]		AMXTILE,FUTURE,LONG
+TILESTORED	mem,tmmreg			[mr:	vex.128.f3.0f38.w0 4b /r]		AMXTILE,MIB,SIB,FUTURE,SX,LONG
+TILEZERO	tmmreg				[r:	vex.128.f2.0f38.w0 49 /3r0]		AMXTILE,FUTURE,LONG
+
+;# Intel AVX512-FP16 instructions
+VADDPH		xmmreg|mask|z,xmmreg*,xmmrm16|b16	[rvm:fv:  evex.nds.128.np.map5.w0 58 /r]    AVX512FP16,AVX512VL,FUTURE
+VADDPH		ymmreg|mask|z,ymmreg*,ymmrm16|b16	[rvm:fv:  evex.nds.256.np.map5.w0 58 /r]    AVX512FP16,AVX512VL,FUTURE
+VADDPH		zmmreg|mask|z,zmmreg*,zmmrm16|b16|er	[rvm:fv:  evex.nds.512.np.map5.w0 58 /r]    AVX512FP16,FUTURE
+VADDSH		xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.f3.map5.w0 58 /r]    AVX512FP16,FUTURE
+VCMPPH		kreg|mask,xmmreg*,xmmrm16|b16,imm8	[rvmi:fv: evex.nds.128.np.0f3a.w0 C2 /r ib] AVX512FP16,AVX512VL,FUTURE
+VCMPPH		kreg|mask,ymmreg*,ymmrm16|b16,imm8	[rvmi:fv: evex.nds.256.np.0f3a.w0 C2 /r ib] AVX512FP16,AVX512VL,FUTURE
+VCMPPH		kreg|mask,zmmreg*,zmmrm16|b16|sae,imm8	[rvmi:fv: evex.nds.512.np.0f3a.w0 C2 /r ib] AVX512FP16,FUTURE
+VCMPSH		kreg|mask,xmmreg*,xmmrm16|sae,imm8	[rvmi:t1s: evex.nds.lig.f3.0f3a.w0 C2 /r ib] AVX512FP16,FUTURE
+VCOMISH		xmmreg,xmmrm16|sae			[rm:fv:	  evex.lig.np.map5.w0 2F /r]	    AVX512FP16,FUTURE
+VCVTDQ2PH	xmmreg|mask|z,xmmrm128|b32		[rm:fv:	  evex.128.np.map5.w0 5B /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTDQ2PH	ymmreg|mask|z,ymmrm256|b32		[rm:fv:	  evex.256.np.map5.w0 5B /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTDQ2PH	zmmreg|mask|z,zmmrm512|b32|er		[rm:fv:	  evex.512.np.map5.w0 5B /r]	    AVX512FP16,FUTURE
+VCVTPD2PH	xmmreg|mask|z,xmmrm128|b64		[rm:fv:	  evex.128.66.map5.w1 5A /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTPD2PH	ymmreg|mask|z,ymmrm256|b64		[rm:fv:	  evex.256.66.map5.w1 5A /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTPD2PH	zmmreg|mask|z,zmmrm512|b64|er		[rm:fv:	  evex.512.66.map5.w1 5A /r]	    AVX512FP16,FUTURE
+VCVTPH2DQ	xmmreg|mask|z,xmmrm64|b16		[rm:hv:	  evex.128.66.map5.w0 5B /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTPH2DQ	ymmreg|mask|z,xmmrm128|b16		[rm:hv:	  evex.256.66.map5.w0 5B /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTPH2DQ	zmmreg|mask|z,ymmrm256|b16|er		[rm:hv:	  evex.512.66.map5.w0 5B /r]	    AVX512FP16,FUTURE
+VCVTPH2PD	xmmreg|mask|z,xmmrm32|b16		[rm:qvm:  evex.128.np.map5.w0 5A /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTPH2PD	ymmreg|mask|z,xmmrm64|b16		[rm:qvm:  evex.256.np.map5.w0 5A /r]	    AVX512FP16,AVX512VL,FUTURE
+VCVTPH2PD	zmmreg|mask|z,xmmrm128|b16|sae		[rm:qvm:  evex.512.np.map5.w0 5A /r]	    AVX512FP16,FUTURE
+VCVTPH2PS	xmmreg,xmmrm64			[rm:	vex.128.66.0f38.w0 13 /r]	AVX512FC16,FUTURE
+VCVTPH2PS	ymmreg,xmmrm128			[rm:	vex.256.66.0f38.w0 13 /r]	AVX512FC16,FUTURE
+VCVTPH2PS	xmmreg|mask|z,xmmrm64		[rm:hvm:evex.128.66.0f38.w0 13 /r]	AVX512,AVX512VL,FUTURE
+VCVTPH2PS	ymmreg|mask|z,xmmrm128		[rm:hvm:evex.256.66.0f38.w0 13 /r]	AVX512,AVX512VL,FUTURE
+VCVTPH2PS	zmmreg|mask|z,ymmrm256|sae	[rm:hvm:evex.512.66.0f38.w0 13 /r]	AVX512,FUTURE
+VCVTPH2PSX	xmmreg|mask|z,xmmrm64|b16	[rm:hv: evex.128.66.map6.w0 13 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2PSX	ymmreg|mask|z,xmmrm128|b16	[rm:hv: evex.256.66.map6.w0 13 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2PSX	zmmreg|mask|z,ymmrm256|b16|sae	[rm:hv: evex.512.66.map6.w0 13 /r]	AVX512FP16,FUTURE
+VCVTPH2QQ	xmmreg|mask|z,xmmrm32|b16	[rm:qvm:evex.128.66.map5.w0 7b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2QQ	ymmreg|mask|z,xmmrm64|b16	[rm:qvm:evex.256.66.map5.w0 7b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2QQ	zmmreg|mask|z,xmmrm128|b16|er	[rm:qvm:evex.512.66.map5.w0 7b /r]	AVX512FP16,FUTURE
+VCVTPH2UDQ	xmmreg|mask|z,xmmrm32|b16	[rm:hv: evex.128.map5.w0 79 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2UDQ	ymmreg|mask|z,xmmrm64|b16	[rm:hv: evex.256.map5.w0 79 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2UDQ	zmmreg|mask|z,xmmrm128|b16|er	[rm:hv: evex.512.map5.w0 79 /r]	AVX512FP16,FUTURE
+VCVTPH2UQQ	xmmreg|mask|z,xmmrm32|b16	[rm:qvm:evex.128.66.map5.w0 79 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2UQQ	ymmreg|mask|z,xmmrm64|b16	[rm:qvm:evex.256.66.map5.w0 79 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2UQQ	zmmreg|mask|z,xmmrm128|b16|er	[rm:qvm:evex.512.66.map5.w0 79 /r]	AVX512FP16,FUTURE
+VCVTPH2UW	xmmreg|mask|z,xmmrm128|b16	[rm:fv: evex.128.np.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2UW	ymmreg|mask|z,ymmrm256|b16	[rm:fv: evex.256.np.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2UW	zmmreg|mask|z,zmmrm512|b16|er	[rm:fv: evex.512.np.map5.w0 7d /r]	AVX512FP16,FUTURE
+VCVTPH2W	xmmreg|mask|z,xmmrm128|b16	[rm:fv: evex.128.66.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2W	ymmreg|mask|z,ymmrm256|b16	[rm:fv: evex.256.66.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPH2W	zmmreg|mask|z,zmmrm512|b16|er	[rm:fv: evex.512.66.map5.w0 7d /r]	AVX512FP16,FUTURE
+VCVTPS2PH	xmmrm64,xmmreg,imm8		[mri:	vex.128.66.0f3a.w0 1d /r ib]	AVX512FC16,AVX512VL,FUTURE
+VCVTPS2PH	xmmrm128,ymmreg,imm8		[mri:	vex.256.66.0f3a.w0 1d /r ib]	AVX512FC16,AVX512VL,FUTURE
+VCVTPS2PH	xmmreg|mask|z,xmmreg,imm8	[mri:hvm: evex.128.66.0f3a.w0 1d /r ib]	AVX512,AVX512VL,FUTURE
+VCVTPS2PH	mem64|mask,xmmreg,imm8		[mri:hvm: evex.128.66.0f3a.w0 1d /r ib] AVX512,AVX512VL,FUTURE
+VCVTPS2PH	xmmreg|mask|z,ymmreg,imm8	[mri:hvm: evex.256.66.0f3a.w0 1d /r ib]	AVX512,AVX512VL,FUTURE
+VCVTPS2PH	mem128|mask,ymmreg,imm8		[mri:hvm: evex.256.66.0f3a.w0 1d /r ib] AVX512,AVX512VL,FUTURE
+VCVTPS2PH	ymmreg|mask|z,zmmreg|sae,imm8	[mri:hvm: evex.512.66.0f3a.w0 1d /r ib]	AVX512,FUTURE
+VCVTPS2PH	mem256|mask,zmmreg|sae,imm8	[mri:hvm: evex.512.66.0f3a.w0 1d /r ib] AVX512,FUTURE
+VCVTPS2PH	xmmreg|mask|z,xmmrm128|b32	[rm:fv: evex.128.66.map5.w0 1d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPS2PH	ymmreg|mask|z,ymmrm256|b32	[rm:fv: evex.256.66.map5.w0 1d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTPS2PH	zmmreg|mask|z,zmmrm512|b32|er	[rm:fv: evex.512.66.map5.w0 1d /r]	AVX512FP16,FUTURE
+VCVTQQ2PH	xmmreg|mask|z,xmmrm128|b64	[rm:fv: evex.128.np.map5.w1 5b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTQQ2PH	ymmreg|mask|z,ymmrm256|b64	[rm:fv: evex.256.np.map5.w1 5b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTQQ2PH	zmmreg|mask|z,zmmrm512|b64|er	[rm:fv: evex.512.np.map5.w1 5b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTSD2SH	xmmreg|mask|z,xmmreg*,xmmrm64|er [rvm:t1s: evex.nds.lig.f2.map5.w1 5a /r]	AVX512FP16,FUTURE
+VCVTSH2SD	xmmreg,xmmreg*,xmmrm16|sae	[rvm:t1s: evex.nds.lig.f3.map5.w0 5a /r]	AVX512FP16,FUTURE
+VCVTSH2SI	reg32,xmmrm16|er		[rm:t1s:evex.lig.f3.map5.w0 2d /r]	AVX512FP16,FUTURE
+VCVTSH2SI	reg64,xmmrm16|er		[rm:t1s:evex.lig.f3.map5.w1 2d /r]	AVX512FP16,FUTURE
+VCVTSH2SS	xmmreg|mask|z,xmmreg*,xmmrm16|sae [rvm:t1s: evex.nds.lig.map6.w0 13 /r]	AVX512FP16,FUTURE
+VCVTSH2USI	reg32,xmmrm16|er		[rm:t1s:evex.lig.f3.map5.w0 79 /r]	AVX512FP16,FUTURE
+VCVTSH2USI	reg64,xmmrm16|er		[rm:t1s:evex.lig.f3.map5.w1 79 /r]	AVX512FP16,FUTURE
+VCVTSI2SH	xmmreg,xmmreg*,rm32|er		[rvm:t1s: evex.nds.lig.f3.map5.w0 2a /r]	AVX512FP16,FUTURE
+VCVTSI2SH	xmmreg,xmmreg*,rm64|er		[rvm:t1s: evex.nds.lig.f3.map5.w1 2a /r]	AVX512FP16,FUTURE
+VCVTSS2SH	xmmreg,xmmreg*,xmmrm32|er	[rvm:t1s: evex.nds.lig.np.map5 1d /r]	AVX512FP16,FUTURE
+VCVTTPH2DQ	xmmreg|mask|z,xmmrm64|b16	[rm:hv:	evex.128.f3.map5.w0 5b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2DQ	ymmreg|mask|z,xmmrm128|b16	[rm:hv:	evex.256.f3.map5.w0 5b /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2DQ	zmmreg|mask|z,ymmrm256|b16|sae	[rm:hv:	evex.512.f3.map5.w0 5b /r]	AVX512FP16,FUTURE
+VCVTTPH2QQ	xmmreg|mask|z,xmmrm32|b16	[rm:t1s:evex.128.66.map5.w0 7a /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2QQ	ymmreg|mask|z,xmmrm64|b16	[rm:t1s:evex.256.66.map5.w0 7a /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2QQ	zmmreg|mask|z,xmmrm128|b16|sae	[rm:t1s:evex.512.66.map5.w0 7a /r]	AVX512FP16,FUTURE
+VCVTTPH2UDQ	xmmreg|mask|z,xmmrm64|b16	[rm:hv:	evex.128.np.map5.w0 78 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2UDQ	ymmreg|mask|z,xmmrm128|b16	[rm:hv:	evex.256.np.map5.w0 78 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2UDQ	zmmreg|mask|z,ymmrm256|b16|sae	[rm:hv:	evex.512.np.map5.w0 78 /r]	AVX512FP16,FUTURE
+VCVTTPH2UQQ	xmmreg|mask|z,xmmrm32|b16	[rm:t1s:	evex.128.66.map5.w0 78 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2UQQ	ymmreg|mask|z,xmmrm64|b16	[rm:t1s:	evex.256.66.map5.w0 78 /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2UQQ	zmmreg|mask|z,xmmrm128|b16|sae	[rm:t1s:	evex.512.66.map5.w0 78 /r]	AVX512FP16,FUTURE
+VCVTTPH2UW	xmmreg|mask|z,xmmrm128|b16	[rm:fv:	evex.128.np.map5.w0 7c /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2UW	ymmreg|mask|z,ymmrm256|b16	[rm:fv:	evex.256.np.map5.w0 7c /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2UW	zmmreg|mask|z,zmmrm512|b16|sae	[rm:fv:	evex.512.np.map5.w0 7c /r]	AVX512FP16,FUTURE
+VCVTTPH2W	xmmreg|mask|z,xmmrm128|b16	[rm:fv:	evex.128.66.map5.w0 7c /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2W	ymmreg|mask|z,ymmrm256|b16	[rm:fv:	evex.256.66.map5.w0 7c /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTTPH2W	zmmreg|mask|z,zmmrm512|b16|sae	[rm:fv:	evex.512.66.map5.w0 7c /r]	AVX512FP16,FUTURE
+VCVTTSH2SI	reg32,xmmrm16|sae		[rm:t1s:evex.lig.f3.map5.w0 2c /r]	AVX512FP16,FUTURE
+VCVTTSH2SI	reg64,xmmrm16|sae		[rm:t1s:evex.lig.f3.map5.w1 2c /r]	AVX512FP16,FUTURE
+VCVTTSH2USI	reg32,xmmrm16|sae		[rm:t1s:evex.lig.f3.map5.w0 78 /r]	AVX512FP16,FUTURE
+VCVTTSH2USI	reg64,xmmrm16|sae		[rm:t1s:evex.lig.f3.map5.w1 78 /r]	AVX512FP16,FUTURE
+VCVTUDQ2PH	xmmreg|mask|z,xmmrm128|b32	[rm:fv:	evex.128.f2.map5.w0 7a /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTUDQ2PH	ymmreg|mask|z,ymmrm256|b32	[rm:fv:	evex.256.f2.map5.w0 7a /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTUDQ2PH	zmmreg|mask|z,zmmrm512|b32	[rm:fv:	evex.512.f2.map5.w0 7a /r]	AVX512FP16,FUTURE
+VCVTUQQ2PH	xmmreg|mask|z,xmmrm128|b32	[rm:fv:	evex.128.f2.map5.w1 7a /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTUQQ2PH	ymmreg|mask|z,ymmrm256|b32	[rm:fv:	evex.256.f2.map5.w1 7a /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTUQQ2PH	zmmreg|mask|z,zmmrm512|b32	[rm:fv:	evex.512.f2.map5.w1 7a /r]	AVX512FP16,FUTURE
+VCVTUSI2SH	xmmreg,xmmreg|er,rm32|er	[rvm:t1s: evex.nds.lig.f3.map5.w0 7b /r] AVX512FP16,FUTURE
+VCVTUSI2SS	xmmreg,xmmreg|er,rm64|er	[rvm:t1s: evex.nds.lig.f3.map5.w1 7b /r] AVX512FP16,FUTURE
+VCVTUW2PH	xmmreg|mask|z,xmmrm128|b16	[rm:fv: evex.128.f2.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTUW2PH	ymmreg|mask|z,ymmrm256|b16	[rm:fv: evex.256.f2.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTUW2PH	zmmreg|mask|z,zmmrm512|b16|er	[rm:fv: evex.512.f2.map5.w0 7d /r]	AVX512FP16,FUTURE
+VCVTW2PH	xmmreg|mask|z,xmmrm128|b16	[rm:fv: evex.128.f3.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTW2PH	ymmreg|mask|z,ymmrm256|b16	[rm:fv: evex.256.f3.map5.w0 7d /r]	AVX512FP16,AVX512VL,FUTURE
+VCVTW2PH	zmmreg|mask|z,zmmrm512|b16|er	[rm:fv: evex.512.f3.map5.w0 7d /r]	AVX512FP16,FUTURE
+VDIVPH		xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.np.map5 5e /r]	AVX512FP16,AVX512VL,FUTURE
+VDIVPH		ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.np.map5 5e /r]	AVX512FP16,AVX512VL,FUTURE
+VDIVPH		zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.np.map5 5e /r]	AVX512FP16,FUTURE
+VDIVSH		xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.f3.map5 5e /r]	AVX512FP16,FUTURE
+VFCMADDCPH	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv: evex.nds.128.f2.map6.w0 56 /r]	AVX512FP16,AVX512VL,FUTURE
+VFCMADDCPH	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv: evex.nds.256.f2.map6.w0 56 /r]	AVX512FP16,AVX512VL,FUTURE
+VFCMADDCPH	zmmreg|mask|z,zmmreg*,zmmrm512|b32|er	[rvm:fv: evex.nds.512.f2.map6.w0 56 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDCPH	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv: evex.nds.128.f3.map6.w0 56 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDCPH	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv: evex.nds.256.f3.map6.w0 56 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDCPH	zmmreg|mask|z,zmmreg*,zmmrm512|b32|er	[rvm:fv: evex.nds.512.f3.map6.w0 56 /r]	AVX512FP16,AVX512VL,FUTURE
+VFCMADDCSH	xmmreg|mask|z,xmmreg*,xmmrm32|er	[rvm:t1s: evex.nds.lig.f2.map6.w0 57 /r]	AVX512FP16,FUTURE
+VFMADDCSH	xmmreg|mask|z,xmmreg*,xmmrm32|er	[rvm:t1s: evex.nds.lig.f3.map6.w0 57 /r]	AVX512FP16,FUTURE
+VFCMULCPCH	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv: evex.nds.128.f2.map6.w0 d6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFCMULCPCH	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv: evex.nds.256.f2.map6.w0 d6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFCMULCPCH	zmmreg|mask|z,zmmreg*,zmmrm512|b32|er	[rvm:fv: evex.nds.512.f2.map6.w0 d6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMULCPCH	xmmreg|mask|z,xmmreg*,xmmrm128|b32	[rvm:fv: evex.nds.128.f3.map6.w0 d6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMULCPCH	ymmreg|mask|z,ymmreg*,ymmrm256|b32	[rvm:fv: evex.nds.256.f3.map6.w0 d6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMULCPCH	zmmreg|mask|z,zmmreg*,zmmrm512|b32|er	[rvm:fv: evex.nds.512.f3.map6.w0 d6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFCMULCSH	xmmreg|mask|z,xmmreg*,xmmrm32|er	[rvm:t1s: evex.nds.lig.f2.map6.w0 d7 /r]	AVX512FP16,FUTURE
+VFMULCSH	xmmreg|mask|z,xmmreg*,xmmrm32|er	[rvm:t1s: evex.nds.lig.f3.map6.w0 d7 /r]	AVX512FP16,FUTURE
+VFMADDSUB132PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 96 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDSUB132PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 96 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDSUB132PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 96 /r]	AVX512FP16,FUTURE
+VFMADDSUB213PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 a6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDSUB213PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 a6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDSUB213PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 a6 /r]	AVX512FP16,FUTURE
+VFMADDSUB231PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 b6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDSUB231PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 b6 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADDSUB231PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 b6 /r]	AVX512FP16,FUTURE
+VFMSUBADD132PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 97 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUBADD132PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 97 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUBADD132PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 97 /r]	AVX512FP16,FUTURE
+VFMSUBADD213PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 a7 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUBADD213PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 a7 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUBADD213PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 a7 /r]	AVX512FP16,FUTURE
+VFMSUBADD231PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 b7 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUBADD231PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 b7 /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUBADD231PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 b7 /r]	AVX512FP16,FUTURE
+VPMADD132PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 98 /r]	AVX512FP16,AVX512VL,FUTURE
+VPMADD132PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 98 /r]	AVX512FP16,AVX512VL,FUTURE
+VPMADD132PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 98 /r]	AVX512FP16,FUTURE
+VPMADD213PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 a8 /r]	AVX512FP16,AVX512VL,FUTURE
+VPMADD213PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 a8 /r]	AVX512FP16,AVX512VL,FUTURE
+VPMADD213PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 a8 /r]	AVX512FP16,FUTURE
+VPMADD231PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 b8 /r]	AVX512FP16,AVX512VL,FUTURE
+VPMADD231PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 b8 /r]	AVX512FP16,AVX512VL,FUTURE
+VPMADD231PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 b8 /r]	AVX512FP16,FUTURE
+VFMADD132PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 9c /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADD132PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 9c /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADD132PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 9c /r]	AVX512FP16,FUTURE
+VFMADD213PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 ac /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADD213PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 ac /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADD213PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 ac /r]	AVX512FP16,FUTURE
+VFMADD231PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 bc /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADD231PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 bc /r]	AVX512FP16,AVX512VL,FUTURE
+VFMADD231PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 bc /r]	AVX512FP16,FUTURE
+VPMADD132SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 99 /r]	AVX512FP16,FUTURE
+VPMADD213SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 a9 /r]	AVX512FP16,FUTURE
+VPMADD231SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 b9 /r]	AVX512FP16,FUTURE
+VPNMADD132SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 9d /r]	AVX512FP16,FUTURE
+VPNMADD213SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 ad /r]	AVX512FP16,FUTURE
+VPNMADD231SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 bd /r]	AVX512FP16,FUTURE
+VPMSUB132PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 9a /r]	AVX512FP16,AVX512VL,FUTURE
+VPMSUB132PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 9a /r]	AVX512FP16,AVX512VL,FUTURE
+VPMSUB132PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 9a /r]	AVX512FP16,FUTURE
+VPMSUB213PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 aa /r]	AVX512FP16,AVX512VL,FUTURE
+VPMSUB213PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 aa /r]	AVX512FP16,AVX512VL,FUTURE
+VPMSUB213PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 aa /r]	AVX512FP16,FUTURE
+VPMSUB231PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 ba /r]	AVX512FP16,AVX512VL,FUTURE
+VPMSUB231PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 ba /r]	AVX512FP16,AVX512VL,FUTURE
+VPMSUB231PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 ba /r]	AVX512FP16,FUTURE
+VFMSUB132PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 9e /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUB132PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 9e /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUB132PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 9e /r]	AVX512FP16,FUTURE
+VFMSUB213PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 ae /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUB213PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 ae /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUB213PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 ae /r]	AVX512FP16,FUTURE
+VFMSUB231PH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 be /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUB231PH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 be /r]	AVX512FP16,AVX512VL,FUTURE
+VFMSUB231PH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 be /r]	AVX512FP16,FUTURE
+VPMSUB132SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 9b /r]	AVX512FP16,FUTURE
+VPMSUB213SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 ab /r]	AVX512FP16,FUTURE
+VPMSUB231SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 bb /r]	AVX512FP16,FUTURE
+VPNMSUB132SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 9f /r]	AVX512FP16,FUTURE
+VPNMSUB213SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 af /r]	AVX512FP16,FUTURE
+VPNMSUB231SH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 bf /r]	AVX512FP16,FUTURE
+VFPCLASSPH	kreg|mask,xmmrm128|b16,imm8		[rmi:fv: evex.128.np.0f3a.w0 66 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VFPCLASSPH	kreg|mask,ymmrm256|b16,imm8		[rmi:fv: evex.256.np.0f3a.w0 66 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VFPCLASSPH	kreg|mask,zmmrm512|b16,imm8		[rmi:fv: evex.512.np.0f3a.w0 66 /r ib]	AVX512FP16,FUTURE
+VFPCLASSSH	kreg|mask,xmmrm16,imm8			[rmi:t1s: evex.lig.np.0f3a.w0 67 /r ib]	AVX512FP16,FUTURE
+VGETEXPPH	xmmreg|mask|z,xmmrm128|b16		[rm:fv:	evex.128.66.map6.w0 42 /r]	AVX512FP16,AVX512VL,FUTURE
+VGETEXPPH	ymmreg|mask|z,ymmrm256|b16		[rm:fv:	evex.256.66.map6.w0 42 /r]	AVX512FP16,AVX512VL,FUTURE
+VGETEXPPH	zmmreg|mask|z,zmmrm512|b16|sae		[rm:fv:	evex.512.66.map6.w0 42 /r]	AVX512FP16,FUTURE
+VGETEXPSH	xmmreg|mask|z,xmmrm16|sae		[rm:t1s: evex.128.66.map6.w0 43 /r]	AVX512FP16,FUTURE
+VGETMANTPH	xmmreg|mask|z,xmmrm128|b16,imm8		[rmi:fv: evex.128.np.0f3a.w0 25 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VGETMANTPH	ymmreg|mask|z,ymmrm256|b16,imm8		[rmi:fv: evex.256.np.0f3a.w0 25 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VGETMANTPH	zmmreg|mask|z,zmmrm512|b16|sae,imm8	[rmi:fv: evex.512.np.0f3a.w0 25 /r ib]	AVX512FP16,FUTURE
+VGETMANTSH	xmmreg|mask|z,xmmrm16|sae,imm8		[rmi:t1s: evex.128.np.0f3a.w0 27 /r ib]	AVX512FP16,FUTURE
+VGETMAXPH	xmmreg|mask|z,xmmrm128|b16		[rm:fv:	evex.128.np.map5.w0 5f /r]	AVX512FP16,AVX512VL,FUTURE
+VGETMAXPH	ymmreg|mask|z,ymmrm256|b16		[rm:fv:	evex.256.np.map5.w0 5f /r]	AVX512FP16,AVX512VL,FUTURE
+VGETMAXPH	zmmreg|mask|z,zmmrm512|b16|sae		[rm:fv:	evex.512.np.map5.w0 5f /r]	AVX512FP16,FUTURE
+VGETMAXSH	xmmreg|mask|z,xmmrm16|sae		[rm:t1s: evex.lig.f3.map5.w0 5f /r]	AVX512FP16,FUTURE
+VGETMINPH	xmmreg|mask|z,xmmrm128|b16		[rm:fv:	evex.128.np.map5.w0 5d /r]	AVX512FP16,AVX512VL,FUTURE
+VGETMINPH	ymmreg|mask|z,xmmrm256|b16		[rm:fv:	evex.256.np.map5.w0 5d /r]	AVX512FP16,AVX512VL,FUTURE
+VGETMINPH	zmmreg|mask|z,zmmrm512|b16|sae		[rm:fv:	evex.512.np.map5.w0 5d /r]	AVX512FP16,FUTURE
+VGETMINSH	xmmreg|mask|z,xmmrm16|sae		[rm:t1s: evex.lig.f3.map5.w0 5d /r]	AVX512FP16,FUTURE
+VMOVSH		xmmreg|mask|z,mem16			[rm:t1s: evex.lig.f3.map5.w0 10 /r]	AVX512FP16,FUTURE
+VMOVSH		mem16|mask,xmmreg			[mr:t1s: evex.lig.f3.map5.w0 11 /r]	AVX512FP16,FUTURE
+VMOVSH		xmmreg|mask|z,xmmreg*,xmmreg		[rvm:	evex.nds.lig.f3.map5.w0 10 /r]	AVX512FP16,FUTURE
+VMOVSH		xmmreg|mask|z,xmmreg*,xmmreg		[rvm:	evex.nds.lig.f3.map5.w0 11 /r]	AVX512FP16,FUTURE
+VMOVW		xmmreg|mask|z,rm16			[rm:t1s: evex.128.66.map5.wig 6e /r]	AVX512FP16,FUTURE
+VMOVW		rm16,xmmreg				[mr:t1s: evex.128.66.map5.wig 7e /r]	AVX512FP16,FUTURE
+VMULPH		xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.np.map5.w0 59 /r]	AVX512FP16,AVX512VL,FUTURE
+VMULPH		ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.np.map5.w0 59 /r]	AVX512FP16,AVX512VL,FUTURE
+VMULPH		zmmreg|mask|z,zmmreg*,zmmrm512|b16	[rvm:fv: evex.nds.512.np.map5.w0 59 /r]	AVX512FP16,FUTURE
+VMULSH		xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.f3.map5.w0 59 /r]	AVX512FP16,FUTURE
+VRCPPH		xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 4c /r]	AVX512FP16,AVX512VL,FUTURE
+VRCPPH		ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 4c /r]	AVX512FP16,AVX512VL,FUTURE
+VRCPPH		zmmreg|mask|z,zmmreg*,zmmrm512|b16	[rvm:fv: evex.nds.512.66.map6.w0 4c /r]	AVX512FP16,FUTURE
+VRCPSH		xmmreg|mask|z,xmmreg*,xmmrm16|sae	[rvm:t1s: evex.nds.lig.66.map6.w0 4d /r]	AVX512FP16,FUTURE
+VREDUCEPH	xmmreg|mask|z,xmmrm128|b16,imm8		[rmi:fv: evex.128.np.0f3a.w0 56 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VREDUCEPH	ymmreg|mask|z,ymmrm256|b16,imm8		[rmi:fv: evex.256.np.0f3a.w0 56 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VREDUCEPH	zmmreg|mask|z,zmmrm512|b16|sae,imm8	[rmi:fv: evex.512.np.0f3a.w0 56 /r ib]	AVX512FP16,FUTURE
+VREDUCESH	xmmreg|mask|z,xmmreg*,xmmrm16|sae,imm8	[rmvi:t1s: evex.nds.lig.np.0f3a.w0 57 /r ib]	AVX512FP16,FUTURE
+VENDSCALEPH	xmmreg|mask|z,xmmrm128|b16,imm8		[rmi:fv: evex.128.np.0f3a.w0 08 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VENDSCALEPH	ymmreg|mask|z,ymmrm256|b16,imm8		[rmi:fv: evex.256.np.0f3a.w0 08 /r ib]	AVX512FP16,AVX512VL,FUTURE
+VENDSCALEPH	zmmreg|mask|z,zmmrm512|b16|sae,imm8	[rmi:fv: evex.512.np.0f3a.w0 08 /r ib]	AVX512FP16,FUTURE
+VENDSCALESH	xmmreg|mask|z,xmmreg*,xmmrm16|sae,imm8	[rvmi:t1s: evex.nds.lig.np.0f3a.w0 0a /r ib]	AVX512FP16,FUTURE
+VRSQRTPH	xmmreg|mask|z,xmmrm128|b16,imm8		[rmi:fv: evex.128.66.map6.w0 4e /r ib]	AVX512FP16,AVX512VL,FUTURE
+VRSQRTPH	ymmreg|mask|z,ymmrm256|b16,imm8		[rmi:fv: evex.256.66.map6.w0 4e /r ib]	AVX512FP16,AVX512VL,FUTURE
+VRSQRTPH	zmmreg|mask|z,zmmrm512|b16|sae,imm8	[rmi:fv: evex.512.66.map6.w0 4e /r ib]	AVX512FP16,FUTURE
+VRSQRTSH	xmmreg|mask|z,xmmreg*,xmmrm16|sae,imm8	[rvmi:t1s: evex.nds.lig.66.map6.w0 4f /r ib]	AVX512FP16,FUTURE
+VSCALEFPH	xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.66.map6.w0 2c /r]	AVX512FP16,AVX512VL,FUTURE
+VSCALEFPH	ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.66.map6.w0 2c /r]	AVX512FP16,AVX512VL,FUTURE
+VSCALEFPH	zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.66.map6.w0 2c /r]	AVX512FP16,FUTURE
+VSCALEFSH	xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.66.map6.w0 2d /r]	AVX512FP16,FUTURE
+VSQRTPH		xmmreg|mask|z,xmmrm128|b16		[rm:fv: evex.128.np.map5.w0 51 /r]	AVX512FP16,AVX512VL,FUTURE
+VSQRTPH		ymmreg|mask|z,ymmrm256|b16		[rm:fv: evex.256.np.map5.w0 51 /r]	AVX512FP16,AVX512VL,FUTURE
+VSQRTPH		zmmreg|mask|z,zmmrm512|b16|er		[rm:fv: evex.512.np.map5.w0 51 /r]	AVX512FP16,FUTURE
+VSQRTSH		xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.f3.map5.w0 51 /r]	AVX512FP16,FUTURE
+VSUBPH		xmmreg|mask|z,xmmreg*,xmmrm128|b16	[rvm:fv: evex.nds.128.np.map5.w0 5c /r]	AVX512FP16,AVX512VL,FUTURE
+VSUBPH		ymmreg|mask|z,ymmreg*,ymmrm256|b16	[rvm:fv: evex.nds.256.np.map5.w0 5c /r]	AVX512FP16,AVX512VL,FUTURE
+VSUBPH		zmmreg|mask|z,zmmreg*,zmmrm512|b16|er	[rvm:fv: evex.nds.512.np.map5.w0 5c /r]	AVX512FP16,FUTURE
+VSUBSH		xmmreg|mask|z,xmmreg*,xmmrm16|er	[rvm:t1s: evex.nds.lig.f3.map5.w0 5c /r]	AVX512FP16,FUTURE
+VUCOMISH	xmmreg,xmmrm16|sae			[rm:t1s: evex.lig.np.map5.w0 2e /r]	AVX512FP16,FUTURE
+
+;# RAO-INT weakly ordered atomic operations
+AADD	   	mem32,reg32				[mr:	norexw np 0f 38 fc /r	]	RAOINT,FUTURE,SD
+AADD	   	mem64,reg64				[mr:	o64 np 0f 38 fc /r	]	RAOINT,FUTURE,SQ,LONG
+AAND	   	mem32,reg32				[mr:	norexw 66 0f 38 fc /r	]	RAOINT,FUTURE,SD
+AAND	   	mem64,reg64				[mr:	o64 66 0f 38 fc /r	]	RAOINT,FUTURE,SQ,LONG
+AXOR	   	mem32,reg32				[mr:	norexw f3 0f 38 fc /r	]	RAOINT,FUTURE,SD
+AXOR	   	mem64,reg64				[mr:	o64 f3 0f 38 fc /r	]	RAOINT,FUTURE,SQ,LONG
+
+;# User interrupts
+CLUI		void					[	f3 0f 01 ee		]	UINTR,FUTURE,LONG
+SENDUIPI	reg64					[m:	o64nw f3 0f c7 /6	]	UINTR,FUTURE,LONG
+STUI		void					[	f3 0f 01 ef		]	UINTR,FUTURE,LONG
+TESTUI		void					[	f3 0f 01 ed		]	UINTR,FUTURE,LONG
+UIRET		void					[	f3 0f 01 ec		]	UINTR,FUTURE,LONG
+
+;# Compare, exchange and add conditional
+CMPccXADD       mem32,reg32,reg32			[mrv:	vex.128.66.0f38.w0 e0+c /r]	CMPCCXADD,FUTURE,LONG,SD
+CMPccXADD       mem64,reg64,reg64			[mrv:	vex.128.66.0f38.w1 e0+c /r]	CMPCCXADD,FUTURE,LONG,SQ
+
+;# WRMSRNS and MSRLIST instructions
+WRMSRNS		void					[	np 0f 01 c6		]	WRMSRNS,FUTURE,PRIV,LONG
+RDMSRLIST	void					[	f2 0f 01 c6		]	MSRLIST,FUTURE,PRIV,LONG
+WRMSRLIST	void					[	f3 0f 01 c6		]	MSRLIST,FUTURE,PRIV,LONG
+
+;# History reset
+HRESET		imm,reg_eax				[i-:	f3 0f 3a f0 c0 ib	]	HRESET,FUTURE,PRIV,SB
+HRESET		imm					[i:	f3 0f 3a f0 c0 ib	]	HRESET,FUTURE,PRIV,SB,ND
+
+;# Systematic names for the hinting nop instructions
+; These should be last in the file
+HINT_NOP0	rm16				[m:	o16 0f 18 /0]				P6,UNDOC
+HINT_NOP0	rm32				[m:	o32 0f 18 /0]				P6,UNDOC
+HINT_NOP0	rm64				[m:	o64 0f 18 /0]				X86_64,LONG,UNDOC
+HINT_NOP1	rm16				[m:	o16 0f 18 /1]				P6,UNDOC
+HINT_NOP1	rm32				[m:	o32 0f 18 /1]				P6,UNDOC
+HINT_NOP1	rm64				[m:	o64 0f 18 /1]				X86_64,LONG,UNDOC
+HINT_NOP2	rm16				[m:	o16 0f 18 /2]				P6,UNDOC
+HINT_NOP2	rm32				[m:	o32 0f 18 /2]				P6,UNDOC
+HINT_NOP2	rm64				[m:	o64 0f 18 /2]				X86_64,LONG,UNDOC
+HINT_NOP3	rm16				[m:	o16 0f 18 /3]				P6,UNDOC
+HINT_NOP3	rm32				[m:	o32 0f 18 /3]				P6,UNDOC
+HINT_NOP3	rm64				[m:	o64 0f 18 /3]				X86_64,LONG,UNDOC
+HINT_NOP4	rm16				[m:	o16 0f 18 /4]				P6,UNDOC
+HINT_NOP4	rm32				[m:	o32 0f 18 /4]				P6,UNDOC
+HINT_NOP4	rm64				[m:	o64 0f 18 /4]				X86_64,LONG,UNDOC
+HINT_NOP5	rm16				[m:	o16 0f 18 /5]				P6,UNDOC
+HINT_NOP5	rm32				[m:	o32 0f 18 /5]				P6,UNDOC
+HINT_NOP5	rm64				[m:	o64 0f 18 /5]				X86_64,LONG,UNDOC
+HINT_NOP6	rm16				[m:	o16 0f 18 /6]				P6,UNDOC
+HINT_NOP6	rm32				[m:	o32 0f 18 /6]				P6,UNDOC
+HINT_NOP6	rm64				[m:	o64 0f 18 /6]				X86_64,LONG,UNDOC
+HINT_NOP7	rm16				[m:	o16 0f 18 /7]				P6,UNDOC
+HINT_NOP7	rm32				[m:	o32 0f 18 /7]				P6,UNDOC
+HINT_NOP7	rm64				[m:	o64 0f 18 /7]				X86_64,LONG,UNDOC
+HINT_NOP8	rm16				[m:	o16 0f 19 /0]				P6,UNDOC
+HINT_NOP8	rm32				[m:	o32 0f 19 /0]				P6,UNDOC
+HINT_NOP8	rm64				[m:	o64 0f 19 /0]				X86_64,LONG,UNDOC
+HINT_NOP9	rm16				[m:	o16 0f 19 /1]				P6,UNDOC
+HINT_NOP9	rm32				[m:	o32 0f 19 /1]				P6,UNDOC
+HINT_NOP9	rm64				[m:	o64 0f 19 /1]				X86_64,LONG,UNDOC
+HINT_NOP10	rm16				[m:	o16 0f 19 /2]				P6,UNDOC
+HINT_NOP10	rm32				[m:	o32 0f 19 /2]				P6,UNDOC
+HINT_NOP10	rm64				[m:	o64 0f 19 /2]				X86_64,LONG,UNDOC
+HINT_NOP11	rm16				[m:	o16 0f 19 /3]				P6,UNDOC
+HINT_NOP11	rm32				[m:	o32 0f 19 /3]				P6,UNDOC
+HINT_NOP11	rm64				[m:	o64 0f 19 /3]				X86_64,LONG,UNDOC
+HINT_NOP12	rm16				[m:	o16 0f 19 /4]				P6,UNDOC
+HINT_NOP12	rm32				[m:	o32 0f 19 /4]				P6,UNDOC
+HINT_NOP12	rm64				[m:	o64 0f 19 /4]				X86_64,LONG,UNDOC
+HINT_NOP13	rm16				[m:	o16 0f 19 /5]				P6,UNDOC
+HINT_NOP13	rm32				[m:	o32 0f 19 /5]				P6,UNDOC
+HINT_NOP13	rm64				[m:	o64 0f 19 /5]				X86_64,LONG,UNDOC
+HINT_NOP14	rm16				[m:	o16 0f 19 /6]				P6,UNDOC
+HINT_NOP14	rm32				[m:	o32 0f 19 /6]				P6,UNDOC
+HINT_NOP14	rm64				[m:	o64 0f 19 /6]				X86_64,LONG,UNDOC
+HINT_NOP15	rm16				[m:	o16 0f 19 /7]				P6,UNDOC
+HINT_NOP15	rm32				[m:	o32 0f 19 /7]				P6,UNDOC
+HINT_NOP15	rm64				[m:	o64 0f 19 /7]				X86_64,LONG,UNDOC
+HINT_NOP16	rm16				[m:	o16 0f 1a /0]				P6,UNDOC
+HINT_NOP16	rm32				[m:	o32 0f 1a /0]				P6,UNDOC
+HINT_NOP16	rm64				[m:	o64 0f 1a /0]				X86_64,LONG,UNDOC
+HINT_NOP17	rm16				[m:	o16 0f 1a /1]				P6,UNDOC
+HINT_NOP17	rm32				[m:	o32 0f 1a /1]				P6,UNDOC
+HINT_NOP17	rm64				[m:	o64 0f 1a /1]				X86_64,LONG,UNDOC
+HINT_NOP18	rm16				[m:	o16 0f 1a /2]				P6,UNDOC
+HINT_NOP18	rm32				[m:	o32 0f 1a /2]				P6,UNDOC
+HINT_NOP18	rm64				[m:	o64 0f 1a /2]				X86_64,LONG,UNDOC
+HINT_NOP19	rm16				[m:	o16 0f 1a /3]				P6,UNDOC
+HINT_NOP19	rm32				[m:	o32 0f 1a /3]				P6,UNDOC
+HINT_NOP19	rm64				[m:	o64 0f 1a /3]				X86_64,LONG,UNDOC
+HINT_NOP20	rm16				[m:	o16 0f 1a /4]				P6,UNDOC
+HINT_NOP20	rm32				[m:	o32 0f 1a /4]				P6,UNDOC
+HINT_NOP20	rm64				[m:	o64 0f 1a /4]				X86_64,LONG,UNDOC
+HINT_NOP21	rm16				[m:	o16 0f 1a /5]				P6,UNDOC
+HINT_NOP21	rm32				[m:	o32 0f 1a /5]				P6,UNDOC
+HINT_NOP21	rm64				[m:	o64 0f 1a /5]				X86_64,LONG,UNDOC
+HINT_NOP22	rm16				[m:	o16 0f 1a /6]				P6,UNDOC
+HINT_NOP22	rm32				[m:	o32 0f 1a /6]				P6,UNDOC
+HINT_NOP22	rm64				[m:	o64 0f 1a /6]				X86_64,LONG,UNDOC
+HINT_NOP23	rm16				[m:	o16 0f 1a /7]				P6,UNDOC
+HINT_NOP23	rm32				[m:	o32 0f 1a /7]				P6,UNDOC
+HINT_NOP23	rm64				[m:	o64 0f 1a /7]				X86_64,LONG,UNDOC
+HINT_NOP24	rm16				[m:	o16 0f 1b /0]				P6,UNDOC
+HINT_NOP24	rm32				[m:	o32 0f 1b /0]				P6,UNDOC
+HINT_NOP24	rm64				[m:	o64 0f 1b /0]				X86_64,LONG,UNDOC
+HINT_NOP25	rm16				[m:	o16 0f 1b /1]				P6,UNDOC
+HINT_NOP25	rm32				[m:	o32 0f 1b /1]				P6,UNDOC
+HINT_NOP25	rm64				[m:	o64 0f 1b /1]				X86_64,LONG,UNDOC
+HINT_NOP26	rm16				[m:	o16 0f 1b /2]				P6,UNDOC
+HINT_NOP26	rm32				[m:	o32 0f 1b /2]				P6,UNDOC
+HINT_NOP26	rm64				[m:	o64 0f 1b /2]				X86_64,LONG,UNDOC
+HINT_NOP27	rm16				[m:	o16 0f 1b /3]				P6,UNDOC
+HINT_NOP27	rm32				[m:	o32 0f 1b /3]				P6,UNDOC
+HINT_NOP27	rm64				[m:	o64 0f 1b /3]				X86_64,LONG,UNDOC
+HINT_NOP28	rm16				[m:	o16 0f 1b /4]				P6,UNDOC
+HINT_NOP28	rm32				[m:	o32 0f 1b /4]				P6,UNDOC
+HINT_NOP28	rm64				[m:	o64 0f 1b /4]				X86_64,LONG,UNDOC
+HINT_NOP29	rm16				[m:	o16 0f 1b /5]				P6,UNDOC
+HINT_NOP29	rm32				[m:	o32 0f 1b /5]				P6,UNDOC
+HINT_NOP29	rm64				[m:	o64 0f 1b /5]				X86_64,LONG,UNDOC
+HINT_NOP30	rm16				[m:	o16 0f 1b /6]				P6,UNDOC
+HINT_NOP30	rm32				[m:	o32 0f 1b /6]				P6,UNDOC
+HINT_NOP30	rm64				[m:	o64 0f 1b /6]				X86_64,LONG,UNDOC
+HINT_NOP31	rm16				[m:	o16 0f 1b /7]				P6,UNDOC
+HINT_NOP31	rm32				[m:	o32 0f 1b /7]				P6,UNDOC
+HINT_NOP31	rm64				[m:	o64 0f 1b /7]				X86_64,LONG,UNDOC
+HINT_NOP32	rm16				[m:	o16 0f 1c /0]				P6,UNDOC
+HINT_NOP32	rm32				[m:	o32 0f 1c /0]				P6,UNDOC
+HINT_NOP32	rm64				[m:	o64 0f 1c /0]				X86_64,LONG,UNDOC
+HINT_NOP33	rm16				[m:	o16 0f 1c /1]				P6,UNDOC
+HINT_NOP33	rm32				[m:	o32 0f 1c /1]				P6,UNDOC
+HINT_NOP33	rm64				[m:	o64 0f 1c /1]				X86_64,LONG,UNDOC
+HINT_NOP34	rm16				[m:	o16 0f 1c /2]				P6,UNDOC
+HINT_NOP34	rm32				[m:	o32 0f 1c /2]				P6,UNDOC
+HINT_NOP34	rm64				[m:	o64 0f 1c /2]				X86_64,LONG,UNDOC
+HINT_NOP35	rm16				[m:	o16 0f 1c /3]				P6,UNDOC
+HINT_NOP35	rm32				[m:	o32 0f 1c /3]				P6,UNDOC
+HINT_NOP35	rm64				[m:	o64 0f 1c /3]				X86_64,LONG,UNDOC
+HINT_NOP36	rm16				[m:	o16 0f 1c /4]				P6,UNDOC
+HINT_NOP36	rm32				[m:	o32 0f 1c /4]				P6,UNDOC
+HINT_NOP36	rm64				[m:	o64 0f 1c /4]				X86_64,LONG,UNDOC
+HINT_NOP37	rm16				[m:	o16 0f 1c /5]				P6,UNDOC
+HINT_NOP37	rm32				[m:	o32 0f 1c /5]				P6,UNDOC
+HINT_NOP37	rm64				[m:	o64 0f 1c /5]				X86_64,LONG,UNDOC
+HINT_NOP38	rm16				[m:	o16 0f 1c /6]				P6,UNDOC
+HINT_NOP38	rm32				[m:	o32 0f 1c /6]				P6,UNDOC
+HINT_NOP38	rm64				[m:	o64 0f 1c /6]				X86_64,LONG,UNDOC
+HINT_NOP39	rm16				[m:	o16 0f 1c /7]				P6,UNDOC
+HINT_NOP39	rm32				[m:	o32 0f 1c /7]				P6,UNDOC
+HINT_NOP39	rm64				[m:	o64 0f 1c /7]				X86_64,LONG,UNDOC
+HINT_NOP40	rm16				[m:	o16 0f 1d /0]				P6,UNDOC
+HINT_NOP40	rm32				[m:	o32 0f 1d /0]				P6,UNDOC
+HINT_NOP40	rm64				[m:	o64 0f 1d /0]				X86_64,LONG,UNDOC
+HINT_NOP41	rm16				[m:	o16 0f 1d /1]				P6,UNDOC
+HINT_NOP41	rm32				[m:	o32 0f 1d /1]				P6,UNDOC
+HINT_NOP41	rm64				[m:	o64 0f 1d /1]				X86_64,LONG,UNDOC
+HINT_NOP42	rm16				[m:	o16 0f 1d /2]				P6,UNDOC
+HINT_NOP42	rm32				[m:	o32 0f 1d /2]				P6,UNDOC
+HINT_NOP42	rm64				[m:	o64 0f 1d /2]				X86_64,LONG,UNDOC
+HINT_NOP43	rm16				[m:	o16 0f 1d /3]				P6,UNDOC
+HINT_NOP43	rm32				[m:	o32 0f 1d /3]				P6,UNDOC
+HINT_NOP43	rm64				[m:	o64 0f 1d /3]				X86_64,LONG,UNDOC
+HINT_NOP44	rm16				[m:	o16 0f 1d /4]				P6,UNDOC
+HINT_NOP44	rm32				[m:	o32 0f 1d /4]				P6,UNDOC
+HINT_NOP44	rm64				[m:	o64 0f 1d /4]				X86_64,LONG,UNDOC
+HINT_NOP45	rm16				[m:	o16 0f 1d /5]				P6,UNDOC
+HINT_NOP45	rm32				[m:	o32 0f 1d /5]				P6,UNDOC
+HINT_NOP45	rm64				[m:	o64 0f 1d /5]				X86_64,LONG,UNDOC
+HINT_NOP46	rm16				[m:	o16 0f 1d /6]				P6,UNDOC
+HINT_NOP46	rm32				[m:	o32 0f 1d /6]				P6,UNDOC
+HINT_NOP46	rm64				[m:	o64 0f 1d /6]				X86_64,LONG,UNDOC
+HINT_NOP47	rm16				[m:	o16 0f 1d /7]				P6,UNDOC
+HINT_NOP47	rm32				[m:	o32 0f 1d /7]				P6,UNDOC
+HINT_NOP47	rm64				[m:	o64 0f 1d /7]				X86_64,LONG,UNDOC
+HINT_NOP48	rm16				[m:	o16 0f 1e /0]				P6,UNDOC
+HINT_NOP48	rm32				[m:	o32 0f 1e /0]				P6,UNDOC
+HINT_NOP48	rm64				[m:	o64 0f 1e /0]				X86_64,LONG,UNDOC
+HINT_NOP49	rm16				[m:	o16 0f 1e /1]				P6,UNDOC
+HINT_NOP49	rm32				[m:	o32 0f 1e /1]				P6,UNDOC
+HINT_NOP49	rm64				[m:	o64 0f 1e /1]				X86_64,LONG,UNDOC
+HINT_NOP50	rm16				[m:	o16 0f 1e /2]				P6,UNDOC
+HINT_NOP50	rm32				[m:	o32 0f 1e /2]				P6,UNDOC
+HINT_NOP50	rm64				[m:	o64 0f 1e /2]				X86_64,LONG,UNDOC
+HINT_NOP51	rm16				[m:	o16 0f 1e /3]				P6,UNDOC
+HINT_NOP51	rm32				[m:	o32 0f 1e /3]				P6,UNDOC
+HINT_NOP51	rm64				[m:	o64 0f 1e /3]				X86_64,LONG,UNDOC
+HINT_NOP52	rm16				[m:	o16 0f 1e /4]				P6,UNDOC
+HINT_NOP52	rm32				[m:	o32 0f 1e /4]				P6,UNDOC
+HINT_NOP52	rm64				[m:	o64 0f 1e /4]				X86_64,LONG,UNDOC
+HINT_NOP53	rm16				[m:	o16 0f 1e /5]				P6,UNDOC
+HINT_NOP53	rm32				[m:	o32 0f 1e /5]				P6,UNDOC
+HINT_NOP53	rm64				[m:	o64 0f 1e /5]				X86_64,LONG,UNDOC
+HINT_NOP54	rm16				[m:	o16 0f 1e /6]				P6,UNDOC
+HINT_NOP54	rm32				[m:	o32 0f 1e /6]				P6,UNDOC
+HINT_NOP54	rm64				[m:	o64 0f 1e /6]				X86_64,LONG,UNDOC
+HINT_NOP55	rm16				[m:	o16 0f 1e /7]				P6,UNDOC
+HINT_NOP55	rm32				[m:	o32 0f 1e /7]				P6,UNDOC
+HINT_NOP55	rm64				[m:	o64 0f 1e /7]				X86_64,LONG,UNDOC
+HINT_NOP56	rm16				[m:	o16 0f 1f /0]				P6,UNDOC
+HINT_NOP56	rm32				[m:	o32 0f 1f /0]				P6,UNDOC
+HINT_NOP56	rm64				[m:	o64 0f 1f /0]				X86_64,LONG,UNDOC
+HINT_NOP57	rm16				[m:	o16 0f 1f /1]				P6,UNDOC
+HINT_NOP57	rm32				[m:	o32 0f 1f /1]				P6,UNDOC
+HINT_NOP57	rm64				[m:	o64 0f 1f /1]				X86_64,LONG,UNDOC
+HINT_NOP58	rm16				[m:	o16 0f 1f /2]				P6,UNDOC
+HINT_NOP58	rm32				[m:	o32 0f 1f /2]				P6,UNDOC
+HINT_NOP58	rm64				[m:	o64 0f 1f /2]				X86_64,LONG,UNDOC
+HINT_NOP59	rm16				[m:	o16 0f 1f /3]				P6,UNDOC
+HINT_NOP59	rm32				[m:	o32 0f 1f /3]				P6,UNDOC
+HINT_NOP59	rm64				[m:	o64 0f 1f /3]				X86_64,LONG,UNDOC
+HINT_NOP60	rm16				[m:	o16 0f 1f /4]				P6,UNDOC
+HINT_NOP60	rm32				[m:	o32 0f 1f /4]				P6,UNDOC
+HINT_NOP60	rm64				[m:	o64 0f 1f /4]				X86_64,LONG,UNDOC
+HINT_NOP61	rm16				[m:	o16 0f 1f /5]				P6,UNDOC
+HINT_NOP61	rm32				[m:	o32 0f 1f /5]				P6,UNDOC
+HINT_NOP61	rm64				[m:	o64 0f 1f /5]				X86_64,LONG,UNDOC
+HINT_NOP62	rm16				[m:	o16 0f 1f /6]				P6,UNDOC
+HINT_NOP62	rm32				[m:	o32 0f 1f /6]				P6,UNDOC
+HINT_NOP62	rm64				[m:	o64 0f 1f /6]				X86_64,LONG,UNDOC
+HINT_NOP63	rm16				[m:	o16 0f 1f /7]				P6,UNDOC
+HINT_NOP63	rm32				[m:	o32 0f 1f /7]				P6,UNDOC
+HINT_NOP63	rm64				[m:	o64 0f 1f /7]				X86_64,LONG,UNDOC
diff --git a/vere/ext/nasm/x86/insns.pl b/vere/ext/nasm/x86/insns.pl
new file mode 100755
index 0000000..1663428
--- /dev/null
+++ b/vere/ext/nasm/x86/insns.pl
@@ -0,0 +1,1167 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##
+##   Copyright 1996-2020 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# insns.pl
+#
+# Parse insns.dat and produce generated source code files
+
+require 'x86/insns-iflags.ph';
+
+# Opcode prefixes which need their own opcode tables
+# LONGER PREFIXES FIRST!
+@disasm_prefixes = qw(0F24 0F25 0F38 0F3A 0F7A 0FA6 0FA7 0F);
+
+# This should match MAX_OPERANDS from nasm.h
+$MAX_OPERANDS = 5;
+
+# Add VEX/XOP prefixes
+@vex_class = ( 'vex', 'xop', 'evex' );
+$vex_classes = scalar(@vex_class);
+@vexlist = ();
+%vexmap = ();
+for ($c = 0; $c < $vex_classes; $c++) {
+    $vexmap{$vex_class[$c]} = $c;
+    for ($m = 0; $m < 32; $m++) {
+        for ($p = 0; $p < 4; $p++) {
+            push(@vexlist, sprintf("%s%02X%01X", $vex_class[$c], $m, $p));
+        }
+    }
+}
+@disasm_prefixes = (@vexlist, @disasm_prefixes, '');
+%disasm_prefixes = map { $_ => 1 } @disasm_prefixes;
+
+@bytecode_count = (0) x 256;
+
+# Push to an array reference, creating the array if needed
+sub xpush($@) {
+    my $ref = shift @_;
+
+    $$ref = [] unless (defined($$ref));
+    return push(@$$ref, @_);
+}
+
+# Generate relaxed form patterns if applicable
+sub relaxed_forms(@) {
+    my @field_list = @_;
+
+    foreach my $fields (@_) {
+	next unless ($fields->[1] =~ /\*/);
+
+	# This instruction has relaxed form(s)
+	if ($fields->[2] !~ /^\[/) {
+	    warn "$fname:$line: has an * operand but uses raw bytecodes\n";
+	    next;
+	}
+
+	my $opmask = 0;
+	my @ops = split(/,/, $fields->[1]);
+	for (my $oi = 0; $oi < scalar @ops; $oi++) {
+	    if ($ops[$oi] =~ /\*$/) {
+		if ($oi == 0) {
+		    warn "$fname:$line: has a first operand with a *\n";
+		    next;
+		}
+		$opmask |= 1 << $oi;
+	    }
+	}
+
+	for (my $oi = 1; $oi < (1 << scalar @ops); $oi++) {
+	    if (($oi & ~$opmask) == 0) {
+		my @xops = ();
+		my $omask = ~$oi;
+		for ($oj = 0; $oj < scalar(@ops); $oj++) {
+		    if ($omask & 1) {
+			push(@xops, $ops[$oj]);
+		    }
+		    $omask >>= 1;
+		}
+		my @ff = @$fields;
+		$ff[1] = join(',', @xops);
+		$ff[4] = $oi;
+		push(@field_list, [@ff]);
+	    }
+	}
+    }
+
+    return @field_list;
+}
+
+# Condition codes used by the disassembler
+my %condd = ( 'o'   =>  0, 'no'  =>  1, 'c'   =>  2,  'nc'  =>  3,
+	      'z'   =>  4, 'nz'  =>  5, 'na'  =>  6,  'a'   =>  7,
+	      's'   =>  8, 'ns'  =>  9, 'pe'  => 10,  'po'  => 11,
+	      'l'   => 12, 'nl'  => 13, 'ng'  => 14,  'g'   => 15 );
+
+# All condition code aliases
+my %conds = ( %condd,
+	      'ae'  =>  3, 'b'   =>  2, 'be'  =>  6,  'e'   =>  4,
+	      'ge'  => 13, 'le'  => 14, 'nae' =>  2,  'nb'  =>  3,
+	      'nbe' =>  7, 'ne'  =>  5, 'nge' => 12,  'nle' => 15,
+	      'np'  => 11, 'p'   => 10 );
+
+my @conds = sort keys(%conds);
+
+# Generate conditional form patterns if applicable
+sub conditional_forms(@) {
+    my @field_list = ();
+
+    foreach my $fields (@_) {
+	# This is a case sensitive match!
+	if ($fields->[0] !~ /cc/) {
+	    # Not a conditional instruction pattern
+	    push(@field_list, $fields);
+	    next;
+	}
+
+	if ($fields->[2] !~ /^\[/) {
+	    warn "$fname:$line: conditional instruction using raw bytecodes\n";
+	    next;
+	}
+
+	foreach my $cc (@conds) {
+	    my @ff = @$fields;
+
+	    $ff[0] =~ s/cc/\U$cc/;
+
+	    unless ($ff[2] =~ /^(\[.*?)\b([0-9a-f]{2})\+c\b(.*\])$/) {
+		warn "$fname:$line: invalid conditional encoding";
+		next;
+	    }
+	    $ff[2] = $1.sprintf('%02x', hex($2)^$conds{$cc}).$3;
+
+	    unless (defined($condd{$cc}) || $ff[3] =~ /\bND\b/) {
+		$ff[3] .= ',ND';
+	    }
+
+	    push(@field_list, [@ff]);
+	}
+    }
+    return @field_list;
+}
+
+print STDERR "Reading insns.dat...\n";
+
+@args   = ();
+undef $output;
+foreach $arg ( @ARGV ) {
+    if ( $arg =~ /^\-/ ) {
+        if  ( $arg =~ /^\-([abdin]|f[hc])$/ ) {
+            $output = $1;
+        } else {
+            die "$0: Unknown option: ${arg}\n";
+        }
+    } else {
+        push (@args, $arg);
+    }
+}
+
+die if (scalar(@args) != 2);	# input output
+($fname, $oname) = @args;
+
+open(F, '<', $fname) || die "unable to open $fname";
+
+%dinstables = ();
+@bytecode_list = ();
+%aname = ();
+
+$line = 0;
+$insns = 0;
+$n_opcodes = 0;
+my @allpatterns = ();
+
+while (<F>) {
+    $line++;
+    chomp;
+    next if ( /^\s*(\;.*|)$/ );   # comments or blank lines
+
+    unless (/^\s*(\S+)\s+(\S+)\s+(\S+|\[.*\])\s+(\S+)\s*$/) {
+        warn "line $line does not contain four fields\n";
+        next;
+    }
+    my @field_list = ([$1, $2, $3, $4, 0]);
+    @field_list = relaxed_forms(@field_list);
+    @field_list = conditional_forms(@field_list);
+
+    foreach my $fields (@field_list) {
+        ($formatted, $nd) = format_insn(@$fields);
+        if ($formatted) {
+            $insns++;
+	    xpush(\$aname{$fields->[0]}, $formatted);
+        }
+	if (!defined($k_opcodes{$fields->[0]})) {
+	    $k_opcodes{$fields->[0]} = $n_opcodes++;
+	}
+        if ($formatted && !$nd) {
+            push @big, $formatted;
+            my @sseq = startseq($fields->[2], $fields->[4]);
+            foreach my $i (@sseq) {
+                xpush(\$dinstables{$i}, $#big);
+            }
+        }
+    }
+}
+
+close F;
+
+#
+# Generate the bytecode array.  At this point, @bytecode_list contains
+# the full set of bytecodes.
+#
+
+# Sort by descending length
+@bytecode_list = sort { scalar(@$b) <=> scalar(@$a) } @bytecode_list;
+@bytecode_array = ();
+%bytecode_pos = ();
+$bytecode_next = 0;
+foreach $bl (@bytecode_list) {
+    my $h = hexstr(@$bl);
+    next if (defined($bytecode_pos{$h}));
+
+    push(@bytecode_array, $bl);
+    while ($h ne '') {
+        $bytecode_pos{$h} = $bytecode_next;
+        $h = substr($h, 2);
+        $bytecode_next++;
+    }
+}
+undef @bytecode_list;
+
+@opcodes = sort { $k_opcodes{$a} <=> $k_opcodes{$b} } keys(%k_opcodes);
+
+if ( $output eq 'b') {
+    print STDERR "Writing $oname...\n";
+
+    open(B, '>', $oname);
+
+    print B "/* This file auto-generated from insns.dat by insns.pl" .
+        " - don't edit it */\n\n";
+
+    print B "#include \"nasm.h\"\n";
+    print B "#include \"insns.h\"\n\n";
+
+    print B "const uint8_t nasm_bytecodes[$bytecode_next] = {\n";
+
+    $p = 0;
+    foreach $bl (@bytecode_array) {
+        printf B "    /* %5d */ ", $p;
+        foreach $d (@$bl) {
+            printf B "%#o,", $d;
+            $p++;
+        }
+        printf B "\n";
+    }
+    print B "};\n";
+
+    print B "\n";
+    print B "/*\n";
+    print B " * Bytecode frequencies (including reuse):\n";
+    print B " *\n";
+    for ($i = 0; $i < 32; $i++) {
+        print B " *";
+        for ($j = 0; $j < 256; $j += 32) {
+            print B " |" if ($j);
+            printf B " %3o:%4d", $i+$j, $bytecode_count[$i+$j];
+        }
+        print B "\n";
+    }
+    print B " */\n";
+
+    close B;
+}
+
+if ( $output eq 'a' ) {
+    print STDERR "Writing $oname...\n";
+
+    open(A, '>', $oname);
+
+    print A "/* This file auto-generated from insns.dat by insns.pl" .
+        " - don't edit it */\n\n";
+
+    print A "#include \"nasm.h\"\n";
+    print A "#include \"insns.h\"\n\n";
+
+    foreach $i (@opcodes) {
+        print A "static const struct itemplate instrux_${i}[] = {\n";
+        foreach $j (@{$aname{$i}}) {
+            print A "    ", codesubst($j), "\n";
+        }
+        print A "    ITEMPLATE_END\n};\n\n";
+    }
+    print A "const struct itemplate * const nasm_instructions[] = {\n";
+    foreach $i (@opcodes) {
+        print A "    instrux_${i},\n";
+    }
+    print A "};\n";
+
+    close A;
+}
+
+if ( $output eq 'd' ) {
+    print STDERR "Writing $oname...\n";
+
+    open(D, '>', $oname);
+
+    print D "/* This file auto-generated from insns.dat by insns.pl" .
+        " - don't edit it */\n\n";
+
+    print D "#include \"nasm.h\"\n";
+    print D "#include \"insns.h\"\n\n";
+
+    print D "static const struct itemplate instrux[] = {\n";
+    $n = 0;
+    foreach $j (@big) {
+        printf D "    /* %4d */ %s\n", $n++, codesubst($j);
+    }
+    print D "};\n";
+
+    foreach $h (sort(keys(%dinstables))) {
+        next if ($h eq ''); # Skip pseudo-instructions
+	print D "\nstatic const struct itemplate * const itable_${h}[] = {\n";
+        foreach $j (@{$dinstables{$h}}) {
+            print D "    instrux + $j,\n";
+        }
+        print D "};\n";
+    }
+
+    @prefix_list = ();
+    foreach $h (@disasm_prefixes) {
+        for ($c = 0; $c < 256; $c++) {
+            $nn = sprintf("%s%02X", $h, $c);
+            if ($is_prefix{$nn} || defined($dinstables{$nn})) {
+                # At least one entry in this prefix table
+                push(@prefix_list, $h);
+                $is_prefix{$h} = 1;
+                last;
+            }
+        }
+    }
+
+    foreach $h (@prefix_list) {
+        print D "\n";
+        print D "static " unless ($h eq '');
+        print D "const struct disasm_index ";
+        print D ($h eq '') ? 'itable' : "itable_$h";
+        print D "[256] = {\n";
+        for ($c = 0; $c < 256; $c++) {
+            $nn = sprintf("%s%02X", $h, $c);
+            if ($is_prefix{$nn}) {
+		if ($dinstables{$nn}) {
+		    print STDERR "$fname: ambiguous decoding, prefix $nn aliases:\n";
+		    foreach my $dc (@{$dinstables{$nn}}) {
+			print STDERR codesubst($big[$dc]), "\n";
+		    }
+		    exit 1;
+		}
+                printf D "    /* 0x%02x */ { itable_%s, -1 },\n", $c, $nn;
+            } elsif ($dinstables{$nn}) {
+                printf D "    /* 0x%02x */ { itable_%s, %u },\n", $c,
+                       $nn, scalar(@{$dinstables{$nn}});
+            } else {
+                printf D "    /* 0x%02x */ { NULL, 0 },\n", $c;
+            }
+        }
+        print D "};\n";
+    }
+
+    printf D "\nconst struct disasm_index * const itable_vex[NASM_VEX_CLASSES][32][4] =\n";
+    print D "{\n";
+    for ($c = 0; $c < $vex_classes; $c++) {
+        print D "    {\n";
+        for ($m = 0; $m < 32; $m++) {
+            print D "        { ";
+            for ($p = 0; $p < 4; $p++) {
+                $vp = sprintf("%s%02X%01X", $vex_class[$c], $m, $p);
+                printf D "%-15s",
+                       ($is_prefix{$vp} ? sprintf("itable_%s,", $vp) : 'NULL,');
+            }
+            print D "},\n";
+        }
+        print D "    },\n";
+    }
+    print D "};\n";
+
+    close D;
+}
+
+if ( $output eq 'i' ) {
+    print STDERR "Writing $oname...\n";
+
+    open(I, '>', $oname);
+
+    print I "/* This file is auto-generated from insns.dat by insns.pl" .
+        " - don't edit it */\n\n";
+    print I "/* This file in included by nasm.h */\n\n";
+
+    print I "/* Instruction names */\n\n";
+    print I "#ifndef NASM_INSNSI_H\n";
+    print I "#define NASM_INSNSI_H 1\n\n";
+    print I "enum opcode {\n";
+    $maxlen = 0;
+    foreach $i (@opcodes) {
+        print I "\tI_${i},\n";
+        $len = length($i);
+        $maxlen = $len if ( $len > $maxlen );
+    }
+    print I "\tI_none = -1\n";
+    print I "};\n\n";
+    print I "#define MAX_INSLEN ", $maxlen, "\n";
+    print I "#define NASM_VEX_CLASSES ", $vex_classes, "\n";
+    print I "#define NO_DECORATOR\t{", join(',',(0) x $MAX_OPERANDS), "}\n";
+    print I "#endif /* NASM_INSNSI_H */\n";
+
+    close I;
+}
+
+if ( $output eq 'n' ) {
+    print STDERR "Writing $oname...\n";
+
+    open(N, '>', $oname);
+
+    print N "/* This file is auto-generated from insns.dat by insns.pl" .
+        " - don't edit it */\n\n";
+    print N "#include \"tables.h\"\n\n";
+
+    print N "const char * const nasm_insn_names[] = {";
+    foreach $i (@opcodes) {
+        print N "\n\t\"\L$i\"";
+	print N ',' if ($i < $#opcodes);
+    }
+    print N "\n};\n";
+    close N;
+}
+
+if ( $output eq 'fh') {
+    write_iflaggen_h();
+}
+
+if ( $output eq 'fc') {
+    write_iflag_c();
+}
+
+printf STDERR "Done: %d instructions\n", $insns;
+
+# Count primary bytecodes, for statistics
+sub count_bytecodes(@) {
+    my $skip = 0;
+    foreach my $bc (@_) {
+        if ($skip) {
+            $skip--;
+            next;
+        }
+        $bytecode_count[$bc]++;
+        if ($bc >= 01 && $bc <= 04) {
+            $skip = $bc;
+        } elsif (($bc & ~03) == 010) {
+            $skip = 1;
+        } elsif (($bc & ~013) == 0144) {
+            $skip = 1;
+        } elsif ($bc == 0172 || $bc == 0173) {
+            $skip = 1;
+        } elsif (($bc & ~3) == 0260 || $bc == 0270) {   # VEX
+            $skip = 2;
+        } elsif (($bc & ~3) == 0240 || $bc == 0250) {   # EVEX
+            $skip = 3;
+        } elsif ($bc == 0330) {
+            $skip = 1;
+        }
+    }
+}
+
+sub format_insn($$$$$) {
+    my ($opcode, $operands, $codes, $flags, $relax) = @_;
+    my $nd = 0;
+    my ($num, $flagsindex);
+    my @bytecode;
+    my ($op, @ops, @opsize, $opp, @opx, @oppx, @decos, @opevex);
+
+    return (undef, undef) if $operands eq "ignore";
+
+    # format the operands
+    $operands =~ s/\*//g;
+    $operands =~ s/:/|colon,/g;
+    @ops = ();
+    @opsize = ();
+    @decos = ();
+    if ($operands ne 'void') {
+        foreach $op (split(/,/, $operands)) {
+	    my $opsz = 0;
+            @opx = ();
+            @opevex = ();
+            foreach $opp (split(/\|/, $op)) {
+                @oppx = ();
+                if ($opp =~ s/^(b(16|32|64)|mask|z|er|sae)$//) {
+                    push(@opevex, $1);
+                }
+
+                if ($opp =~ s/(?<!\d)(8|16|32|64|80|128|256|512)$//) {
+                    push(@oppx, "bits$1");
+		    $opsz = $1 + 0;
+                }
+                $opp =~ s/^mem$/memory/;
+                $opp =~ s/^memory_offs$/mem_offs/;
+                $opp =~ s/^imm$/immediate/;
+                $opp =~ s/^([a-z]+)rm$/rm_$1/;
+                $opp =~ s/^rm$/rm_gpr/;
+                $opp =~ s/^reg$/reg_gpr/;
+                # only for evex insns, high-16 regs are allowed
+                if ($codes !~ /(^|\s)evex\./) {
+                    $opp =~ s/^(rm_[xyz]mm)$/$1_l16/;
+                    $opp =~ s/^([xyz]mm)reg$/$1_l16/;
+                }
+                push(@opx, $opp, @oppx) if $opp;
+            }
+            $op = join('|', @opx);
+            push(@ops, $op);
+	    push(@opsize, $opsz);
+            push(@decos, (@opevex ? join('|', @opevex) : '0'));
+        }
+    }
+
+    $num = scalar(@ops);
+    while (scalar(@ops) < $MAX_OPERANDS) {
+        push(@ops, '0');
+	push(@opsize, 0);
+        push(@decos, '0');
+    }
+    $operands = join(',', @ops);
+    $operands =~ tr/a-z/A-Z/;
+
+    $decorators = "{" . join(',', @decos) . "}";
+    if ($decorators =~ /^{(0,)+0}$/) {
+        $decorators = "NO_DECORATOR";
+    }
+    $decorators =~ tr/a-z/A-Z/;
+
+    # Remember if we have an ARx flag
+    my $arx = undef;
+
+    # expand and uniqify the flags
+    my %flags;
+    foreach my $flag (split(',', $flags)) {
+	next if ($flag eq '');
+
+	if ($flag eq 'ND') {
+	    $nd = 1;
+	} else {
+	    $flags{$flag}++;
+	}
+
+	if ($flag eq 'NEVER' || $flag eq 'NOP') {
+	    # These flags imply OBSOLETE
+	    $flags{'OBSOLETE'}++;
+	}
+
+	if ($flag =~ /^AR([0-9]+)$/) {
+	    $arx = $1+0;
+	}
+    }
+
+    if ($codes =~ /evex\./) {
+	$flags{'EVEX'}++;
+    } elsif ($codes =~ /(vex|xop)\./) {
+	$flags{'VEX'}++;
+    }
+
+    # Look for SM flags clearly inconsistent with operand bitsizes
+    if ($flags{'SM'} || $flags{'SM2'}) {
+	my $ssize = 0;
+	my $e = $flags{'SM2'} ? 2 : $MAX_OPERANDS;
+	for (my $i = 0; $i < $e; $i++) {
+	    next if (!$opsize[$i]);
+	    if (!$ssize) {
+		$ssize = $opsize[$i];
+	    } elsif ($opsize[$i] != $ssize) {
+		die "$fname:$line: inconsistent SM flag for argument $i\n";
+	    }
+	}
+    }
+
+    # Look for Sx flags that can never match operand bitsizes. If the
+    # intent is to never match (require explicit sizes), use the SX flag.
+    # This doesn't apply to registers that pre-define specific sizes;
+    # this should really be derived from include/opflags.h...
+    my %sflags = ( 'SB' => 8, 'SW' => 16, 'SD' => 32, 'SQ' => 64,
+		   'SO' => 128, 'SY' => 256, 'SZ' => 512 );
+    my $s = defined($arx) ? $arx : 0;
+    my $e = defined($arx) ? $arx : $MAX_OPERANDS - 1;
+
+    foreach my $sf (keys(%sflags)) {
+	next if (!$flags{$sf});
+	for (my $i = $s; $i <= $e; $i++) {
+	    if ($opsize[$i] && $ops[$i] !~ /\breg_(gpr|[cdts]reg)\b/) {
+		die "$fname:$line: inconsistent $sf flag for argument $i ($ops[$i])\n"
+		    if ($opsize[$i] != $sflags{$sf});
+	    }
+	}
+    }
+
+    $flagsindex = insns_flag_index(keys %flags);
+    die "$fname:$line: error in flags $flags\n" unless (defined($flagsindex));
+
+    @bytecode = (decodify($codes, $relax), 0);
+    push(@bytecode_list, [@bytecode]);
+    $codes = hexstr(@bytecode);
+    count_bytecodes(@bytecode);
+
+    ("{I_$opcode, $num, {$operands}, $decorators, \@\@CODES-$codes\@\@, $flagsindex},", $nd);
+}
+
+#
+# Look for @@CODES-xxx@@ sequences and replace them with the appropriate
+# offset into nasm_bytecodes
+#
+sub codesubst($) {
+    my($s) = @_;
+    my $n;
+
+    while ($s =~ /\@\@CODES-([0-9A-F]+)\@\@/) {
+        my $pos = $bytecode_pos{$1};
+        if (!defined($pos)) {
+            die "$fname:$line: no position assigned to byte code $1\n";
+        }
+        $s = $` . "nasm_bytecodes+${pos}" . "$'";
+    }
+    return $s;
+}
+
+sub addprefix ($@) {
+    my ($prefix, @list) = @_;
+    my $x;
+    my @l = ();
+
+    foreach $x (@list) {
+        push(@l, sprintf("%s%02X", $prefix, $x));
+    }
+
+    return @l;
+}
+
+#
+# Turn a code string into a sequence of bytes
+#
+sub decodify($$) {
+  # Although these are C-syntax strings, by convention they should have
+  # only octal escapes (for directives) and hexadecimal escapes
+  # (for verbatim bytes)
+    my($codestr, $relax) = @_;
+
+    if ($codestr =~ /^\s*\[([^\]]*)\]\s*$/) {
+        return byte_code_compile($1, $relax);
+    }
+
+    my $c = $codestr;
+    my @codes = ();
+
+    unless ($codestr eq 'ignore') {
+        while ($c ne '') {
+            if ($c =~ /^\\x([0-9a-f]+)(.*)$/i) {
+                push(@codes, hex $1);
+                $c = $2;
+                next;
+            } elsif ($c =~ /^\\([0-7]{1,3})(.*)$/) {
+                push(@codes, oct $1);
+                $c = $2;
+                next;
+            } else {
+                die "$fname:$line: unknown code format in \"$codestr\"\n";
+            }
+        }
+    }
+
+    return @codes;
+}
+
+# Turn a numeric list into a hex string
+sub hexstr(@) {
+    my $s = '';
+    my $c;
+
+    foreach $c (@_) {
+        $s .= sprintf("%02X", $c);
+    }
+    return $s;
+}
+
+# Here we determine the range of possible starting bytes for a given
+# instruction. We need only consider the codes:
+# \[1234]      mean literal bytes, of course
+# \1[0123]     mean byte plus register value
+# \0 or \340   mean give up and return empty set
+# \34[4567]    mean PUSH/POP of segment registers: special case
+# \17[234]     skip is4 control byte
+# \26x \270    skip VEX control bytes
+# \24x \250    skip EVEX control bytes
+sub startseq($$) {
+    my ($codestr, $relax) = @_;
+    my $word;
+    my @codes = ();
+    my $c = $codestr;
+    my($c0, $c1, $i);
+    my $prefix = '';
+
+    @codes = decodify($codestr, $relax);
+
+    while (defined($c0 = shift(@codes))) {
+        $c1 = $codes[0];
+        if ($c0 >= 01 && $c0 <= 04) {
+            # Fixed byte string
+            my $fbs = $prefix;
+            while (defined($c0)) {
+                if ($c0 >= 01 && $c0 <= 04) {
+                    while ($c0--) {
+                        $fbs .= sprintf("%02X", shift(@codes));
+                    }
+                } else {
+                    last;
+                }
+                $c0 = shift(@codes);
+            }
+
+            foreach $pfx (@disasm_prefixes) {
+		my $len = length($pfx);
+                if (substr($fbs, 0, $len) eq $pfx) {
+                    $prefix = $pfx;
+                    $fbs = substr($fbs, $len, 2);
+                    last;
+                }
+            }
+
+            if ($fbs ne '') {
+                return ($prefix.$fbs);
+            }
+
+            unshift(@codes, $c0);
+        } elsif ($c0 >= 010 && $c0 <= 013) {
+            return addprefix($prefix, $c1..($c1+7));
+        } elsif (($c0 & ~013) == 0144) {
+            return addprefix($prefix, $c1, $c1|2);
+        } elsif ($c0 == 0 || $c0 == 0340) {
+            return $prefix;
+        } elsif (($c0 & ~3) == 0260 || $c0 == 0270 ||
+                 ($c0 & ~3) == 0240 || $c0 == 0250) {
+            my($c,$m,$wlp);
+            $m   = shift(@codes);
+            $wlp = shift(@codes);
+            $c = ($m >> 6);
+            $m = $m & 31;
+            $prefix .= sprintf('%s%02X%01X', $vex_class[$c], $m, $wlp & 3);
+            if ($c0 < 0260) {
+                my $tuple = shift(@codes);
+            }
+        } elsif ($c0 >= 0172 && $c0 <= 173) {
+            shift(@codes);      # Skip is4 control byte
+        } else {
+            # We really need to be able to distinguish "forbidden"
+            # and "ignorable" codes here
+        }
+    }
+    return ();
+}
+
+# EVEX tuple types offset is 0300. e.g. 0301 is for full vector(fv).
+sub tupletype($) {
+    my ($tuplestr) = @_;
+    my %tuple_codes = (
+        ''      => 000,
+        'fv'    => 001,
+        'hv'    => 002,
+        'fvm'   => 003,
+        't1s8'  => 004,
+        't1s16' => 005,
+        't1s'   => 006,
+        't1f32' => 007,
+        't1f64' => 010,
+        't2'    => 011,
+        't4'    => 012,
+        't8'    => 013,
+        'hvm'   => 014,
+        'qvm'   => 015,
+        'ovm'   => 016,
+        'm128'  => 017,
+        'dup'   => 020,
+    );
+
+    if (defined $tuple_codes{$tuplestr}) {
+        return 0300 + $tuple_codes{$tuplestr};
+    } else {
+        die "$fname:$line: undefined tuple type : $tuplestr\n";
+    }
+}
+
+#
+# This function takes a series of byte codes in a format which is more
+# typical of the Intel documentation, and encode it.
+#
+# The format looks like:
+#
+# [operands: opcodes]
+#
+# The operands word lists the order of the operands:
+#
+# r = register field in the modr/m
+# m = modr/m
+# v = VEX "v" field
+# i = immediate
+# s = register field of is4/imz2 field
+# - = implicit (unencoded) operand
+# x = indeX register of mib. 014..017 bytecodes are used.
+#
+# For an operand that should be filled into more than one field,
+# enter it as e.g. "r+v".
+#
+sub byte_code_compile($$) {
+    my($str, $relax) = @_;
+    my $opr;
+    my $opc;
+    my @codes = ();
+    my $litix = undef;
+    my %oppos = ();
+    my $i;
+    my ($op, $oq);
+    my $opex;
+
+    my %imm_codes = (
+        'ib'        => 020,     # imm8
+        'ib,u'      => 024,     # Unsigned imm8
+        'iw'        => 030,     # imm16
+        'ib,s'      => 0274,    # imm8 sign-extended to opsize or bits
+        'iwd'       => 034,     # imm16 or imm32, depending on opsize
+        'id'        => 040,     # imm32
+        'id,s'      => 0254,    # imm32 sign-extended to 64 bits
+        'iwdq'      => 044,     # imm16/32/64, depending on addrsize
+        'rel8'      => 050,
+        'iq'        => 054,
+        'rel16'     => 060,
+        'rel'       => 064,     # 16 or 32 bit relative operand
+        'rel32'     => 070,
+        'seg'       => 074,
+    );
+    my %plain_codes = (
+        'o16'       => 0320,    # 16-bit operand size
+        'o32'       => 0321,    # 32-bit operand size
+        'odf'       => 0322,    # Operand size is default
+        'o64'       => 0324,    # 64-bit operand size requiring REX.W
+        'o64nw'     => 0323,    # Implied 64-bit operand size (no REX.W)
+        'a16'       => 0310,
+        'a32'       => 0311,
+        'adf'       => 0312,    # Address size is default
+        'a64'       => 0313,
+        '!osp'      => 0364,
+        '!asp'      => 0365,
+        'f2i'       => 0332,    # F2 prefix, but 66 for operand size is OK
+        'f3i'       => 0333,    # F3 prefix, but 66 for operand size is OK
+        'mustrep'   => 0336,
+        'mustrepne' => 0337,
+        'rex.l'     => 0334,
+        'norexb'    => 0314,
+        'norexx'    => 0315,
+        'norexr'    => 0316,
+        'norexw'    => 0317,
+        'repe'      => 0335,
+        'nohi'      => 0325,    # Use spl/bpl/sil/dil even without REX
+        'nof3'      => 0326,    # No REP 0xF3 prefix permitted
+        'norep'     => 0331,    # No REP prefix permitted
+        'wait'      => 0341,    # Needs a wait prefix
+        'resb'      => 0340,
+        'np'        => 0360,    # No prefix
+        'jcc8'      => 0370,    # Match only if Jcc possible with single byte
+        'jmp8'      => 0371,    # Match only if JMP possible with single byte
+        'jlen'      => 0373,    # Length of jump
+        'hlexr'     => 0271,
+        'hlenl'     => 0272,
+        'hle'       => 0273,
+
+        # This instruction takes XMM VSIB
+        'vsibx'     => 0374,
+        'vm32x'     => 0374,
+        'vm64x'     => 0374,
+
+        # This instruction takes YMM VSIB
+        'vsiby'     => 0375,
+        'vm32y'     => 0375,
+        'vm64y'     => 0375,
+
+        # This instruction takes ZMM VSIB
+        'vsibz'     => 0376,
+        'vm32z'     => 0376,
+        'vm64z'     => 0376,
+    );
+
+    unless ($str =~ /^(([^\s:]*)\:*([^\s:]*)\:|)\s*(.*\S)\s*$/) {
+        die "$fname:$line: cannot parse: [$str]\n";
+    }
+    $opr = lc($2);
+    $tuple = lc($3);    # Tuple type for AVX512
+    $opc = lc($4);
+
+    $op = 0;
+    for ($i = 0; $i < length($opr); $i++) {
+        my $c = substr($opr,$i,1);
+        if ($c eq '+') {
+            $op--;
+        } else {
+            if ($relax & 1) {
+                $op--;
+            }
+            $relax >>= 1;
+            $oppos{$c} = $op++;
+        }
+    }
+    $tup = tupletype($tuple);
+
+    my $last_imm = 'h';
+    my $prefix_ok = 1;
+    foreach $op (split(/\s*(?:\s|(?=[\/\\]))/, $opc)) {
+        my $pc = $plain_codes{$op};
+
+        if (defined $pc) {
+            # Plain code
+            push(@codes, $pc);
+        } elsif ($prefix_ok && $op =~ /^(66|f2|f3)$/) {
+            # 66/F2/F3 prefix used as an opcode extension
+            if ($op eq '66') {
+                push(@codes, 0361);
+            } elsif ($op eq 'f2') {
+                push(@codes, 0332);
+            } else {
+                push(@codes, 0333);
+            }
+        } elsif ($op =~ /^[0-9a-f]{2}$/) {
+            if (defined($litix) && $litix+$codes[$litix]+1 == scalar @codes &&
+                $codes[$litix] < 4) {
+                $codes[$litix]++;
+                push(@codes, hex $op);
+            } else {
+                $litix = scalar(@codes);
+                push(@codes, 01, hex $op);
+            }
+            $prefix_ok = 0;
+        } elsif ($op eq '/r') {
+            if (!defined($oppos{'r'}) || !defined($oppos{'m'})) {
+                die "$fname:$line: $op requires r and m operands\n";
+            }
+            $opex = (($oppos{'m'} & 4) ? 06 : 0) |
+                (($oppos{'r'} & 4) ? 05 : 0);
+            push(@codes, $opex) if ($opex);
+            # if mib is composed with two separate operands - ICC style
+            push(@codes, 014 + ($oppos{'x'} & 3)) if (defined($oppos{'x'}));
+            push(@codes, 0100 + (($oppos{'m'} & 3) << 3) + ($oppos{'r'} & 3));
+            $prefix_ok = 0;
+        } elsif ($op =~ m:^/([0-7])$:) {
+            if (!defined($oppos{'m'})) {
+                die "$fname:$line: $op requires an m operand\n";
+            }
+            push(@codes, 06) if ($oppos{'m'} & 4);
+            push(@codes, 0200 + (($oppos{'m'} & 3) << 3) + $1);
+            $prefix_ok = 0;
+	} elsif ($op =~ m:^/([0-3]?)r([0-7])$:) {
+	    if (!defined($oppos{'r'})) {
+                die "$fname:$line: $op requires an r operand\n";
+	    }
+	    push(@codes, 05) if ($oppos{'r'} & 4);
+	    push(@codes, 0171);
+	    push(@codes, (($1+0) << 6) + (($oppos{'r'} & 3) << 3) + $2);
+	    $prefix_ok = 0;
+        } elsif ($op =~ /^(vex|xop)(|\..*)$/) {
+            my $vexname = $1;
+            my $c = $vexmap{$vexname};
+            my ($m,$w,$l,$p) = (undef,2,undef,0);
+            my $has_nds = 0;
+            my @subops = split(/\./, $op);
+            shift @subops;      # Drop prefix
+                foreach $oq (@subops) {
+                    if ($oq eq '128' || $oq eq 'l0' || $oq eq 'lz') {
+                        $l = 0;
+                    } elsif ($oq eq '256' || $oq eq 'l1') {
+                        $l = 1;
+                    } elsif ($oq eq 'lig') {
+                        $l = 2;
+                    } elsif ($oq eq 'w0') {
+                        $w = 0;
+                    } elsif ($oq eq 'w1') {
+                        $w = 1;
+                    } elsif ($oq eq 'wig') {
+                        $w = 2;
+                    } elsif ($oq eq 'ww') {
+                        $w = 3;
+                    } elsif ($oq eq 'np' || $oq eq 'p0') {
+                        $p = 0;
+                    } elsif ($oq eq '66' || $oq eq 'p1') {
+                        $p = 1;
+                    } elsif ($oq eq 'f3' || $oq eq 'p2') {
+                        $p = 2;
+                    } elsif ($oq eq 'f2' || $oq eq 'p3') {
+                        $p = 3;
+                    } elsif ($oq eq '0f') {
+                        $m = 1;
+                    } elsif ($oq eq '0f38') {
+                        $m = 2;
+                    } elsif ($oq eq '0f3a') {
+                        $m = 3;
+                    } elsif ($oq =~ /^(m|map)([0-9]+)$/) {
+                        $m = $2+0;
+                    } elsif ($oq eq 'nds' || $oq eq 'ndd' || $oq eq 'dds') {
+                        if (!defined($oppos{'v'})) {
+                            die "$fname:$line: $vexname.$oq without 'v' operand\n";
+                        }
+                        $has_nds = 1;
+                    } else {
+                        die "$fname:$line: undefined \U$vexname\E subcode: $oq\n";
+                    }
+                }
+            if (!defined($m) || !defined($w) || !defined($l) || !defined($p)) {
+                die "$fname:$line: missing fields in \U$vexname\E specification\n";
+            }
+	    my $minmap = ($c == 1) ? 8 : 0; # 0-31 for VEX, 8-31 for XOP
+	    if ($m < $minmap || $m > 31) {
+		die "$fname:$line: Only maps ${minmap}-31 are valid for \U${vexname}\n";
+	    }
+            push(@codes, defined($oppos{'v'}) ? 0260+($oppos{'v'} & 3) : 0270,
+                 ($c << 6)+$m, ($w << 4)+($l << 2)+$p);
+            $prefix_ok = 0;
+        } elsif ($op =~ /^(evex)(|\..*)$/) {
+            my $c = $vexmap{$1};
+            my ($m,$w,$l,$p) = (undef,2,undef,0);
+            my $has_nds = 0;
+            my @subops = split(/\./, $op);
+            shift @subops;      # Drop prefix
+                foreach $oq (@subops) {
+                    if ($oq eq '128' || $oq eq 'l0' || $oq eq 'lz' || $oq eq 'lig') {
+                        $l = 0;
+                    } elsif ($oq eq '256' || $oq eq 'l1') {
+                        $l = 1;
+                    } elsif ($oq eq '512' || $oq eq 'l2') {
+                        $l = 2;
+                    } elsif ($oq eq 'w0') {
+                        $w = 0;
+                    } elsif ($oq eq 'w1') {
+                        $w = 1;
+                    } elsif ($oq eq 'wig') {
+                        $w = 2;
+                    } elsif ($oq eq 'ww') {
+                        $w = 3;
+                    } elsif ($oq eq 'np' || $oq eq 'p0') {
+                        $p = 0;
+                    } elsif ($oq eq '66' || $oq eq 'p1') {
+                        $p = 1;
+                    } elsif ($oq eq 'f3' || $oq eq 'p2') {
+                        $p = 2;
+                    } elsif ($oq eq 'f2' || $oq eq 'p3') {
+                        $p = 3;
+                    } elsif ($oq eq '0f') {
+                        $m = 1;
+                    } elsif ($oq eq '0f38') {
+                        $m = 2;
+                    } elsif ($oq eq '0f3a') {
+                        $m = 3;
+                    } elsif ($oq eq 'map5') {
+                        $m = 5;
+                    } elsif ($oq eq 'map6') {
+                        $m = 6;
+                    } elsif ($oq =~ /^m([0-9]+)$/) {
+                        $m = $1+0;
+                    } elsif ($oq eq 'nds' || $oq eq 'ndd' || $oq eq 'dds') {
+                        if (!defined($oppos{'v'})) {
+                            die "$fname:$line: evex.$oq without 'v' operand\n";
+                        }
+                        $has_nds = 1;
+                    } else {
+                        die "$fname:$line: undefined EVEX subcode: $oq\n";
+                    }
+                }
+            if (!defined($m) || !defined($w) || !defined($l) || !defined($p)) {
+                die "$fname:$line: missing fields in EVEX specification\n";
+            }
+	    if ($m > 15) {
+		die "$fname:$line: Only maps 0-15 are valid for EVEX\n";
+	    }
+            push(@codes, defined($oppos{'v'}) ? 0240+($oppos{'v'} & 3) : 0250,
+                 ($c << 6)+$m, ($w << 4)+($l << 2)+$p, $tup);
+            $prefix_ok = 0;
+        } elsif (defined $imm_codes{$op}) {
+            if ($op eq 'seg') {
+                if ($last_imm lt 'i') {
+                    die "$fname:$line: seg without an immediate operand\n";
+                }
+            } else {
+                $last_imm++;
+                if ($last_imm gt 'j') {
+                    die "$fname:$line: too many immediate operands\n";
+                }
+            }
+            if (!defined($oppos{$last_imm})) {
+                die "$fname:$line: $op without '$last_imm' operand\n";
+            }
+            push(@codes, 05) if ($oppos{$last_imm} & 4);
+            push(@codes, $imm_codes{$op} + ($oppos{$last_imm} & 3));
+            $prefix_ok = 0;
+        } elsif ($op eq '/is4') {
+            if (!defined($oppos{'s'})) {
+                die "$fname:$line: $op without 's' operand\n";
+            }
+            if (defined($oppos{'i'})) {
+                push(@codes, 0172, ($oppos{'s'} << 3)+$oppos{'i'});
+            } else {
+                push(@codes, 05) if ($oppos{'s'} & 4);
+                push(@codes, 0174+($oppos{'s'} & 3));
+            }
+            $prefix_ok = 0;
+        } elsif ($op =~ /^\/is4\=([0-9]+)$/) {
+            my $imm = $1;
+            if (!defined($oppos{'s'})) {
+                die "$fname:$line: $op without 's' operand\n";
+            }
+            if ($imm < 0 || $imm > 15) {
+                die "$fname:$line: invalid imm4 value for $op: $imm\n";
+            }
+            push(@codes, 0173, ($oppos{'s'} << 4) + $imm);
+            $prefix_ok = 0;
+        } elsif ($op =~ /^([0-9a-f]{2})\+r$/) {
+            if (!defined($oppos{'r'})) {
+                die "$fname:$line: $op without 'r' operand\n";
+            }
+            push(@codes, 05) if ($oppos{'r'} & 4);
+            push(@codes, 010 + ($oppos{'r'} & 3), hex $1);
+            $prefix_ok = 0;
+        } elsif ($op =~ /^\\([0-7]+|x[0-9a-f]{2})$/) {
+            # Escape to enter literal bytecodes
+            push(@codes, oct $1);
+        } else {
+            die "$fname:$line: unknown operation: $op\n";
+        }
+    }
+
+    return @codes;
+}
diff --git a/vere/ext/nasm/x86/insnsa.c b/vere/ext/nasm/x86/insnsa.c
new file mode 100644
index 0000000..668ac07
--- /dev/null
+++ b/vere/ext/nasm/x86/insnsa.c
@@ -0,0 +1,19532 @@
+/* This file auto-generated from insns.dat by insns.pl - don't edit it */
+
+#include "nasm.h"
+#include "insns.h"
+
+static const struct itemplate instrux_DB[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DW[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DD[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DQ[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DT[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DO[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DY[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DZ[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESB[] = {
+    {I_RESB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESW[] = {
+    {I_RESW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESD[] = {
+    {I_RESD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESQ[] = {
+    {I_RESQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_REST[] = {
+    {I_REST, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESO[] = {
+    {I_RESO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESY[] = {
+    {I_RESY, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RESZ[] = {
+    {I_RESZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INCBIN[] = {
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AAA[] = {
+    {I_AAA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50187, 1},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AAD[] = {
+    {I_AAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49187, 1},
+    {I_AAD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49191, 2},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AAM[] = {
+    {I_AAM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49195, 1},
+    {I_AAM, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49199, 2},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AAS[] = {
+    {I_AAS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50190, 1},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADC[] = {
+    {I_ADC, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47247, 3},
+    {I_ADC, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47248, 0},
+    {I_ADC, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42741, 3},
+    {I_ADC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42742, 0},
+    {I_ADC, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42747, 4},
+    {I_ADC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42748, 5},
+    {I_ADC, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42753, 6},
+    {I_ADC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42754, 7},
+    {I_ADC, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+36381, 8},
+    {I_ADC, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+36381, 0},
+    {I_ADC, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47252, 8},
+    {I_ADC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47252, 0},
+    {I_ADC, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47257, 9},
+    {I_ADC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47257, 5},
+    {I_ADC, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47262, 10},
+    {I_ADC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47262, 7},
+    {I_ADC, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32864, 11},
+    {I_ADC, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32871, 12},
+    {I_ADC, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32878, 13},
+    {I_ADC, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49203, 8},
+    {I_ADC, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32865, 8},
+    {I_ADC, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47267, 8},
+    {I_ADC, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32872, 9},
+    {I_ADC, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47272, 9},
+    {I_ADC, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32879, 10},
+    {I_ADC, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47277, 10},
+    {I_ADC, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42759, 3},
+    {I_ADC, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32864, 3},
+    {I_ADC, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32885, 3},
+    {I_ADC, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32871, 4},
+    {I_ADC, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32892, 4},
+    {I_ADC, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32878, 6},
+    {I_ADC, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32899, 6},
+    {I_ADC, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42759, 3},
+    {I_ADC, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32864, 3},
+    {I_ADC, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32885, 3},
+    {I_ADC, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32871, 4},
+    {I_ADC, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32892, 4},
+    {I_ADC, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42765, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADD[] = {
+    {I_ADD, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47282, 3},
+    {I_ADD, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47283, 0},
+    {I_ADD, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42771, 3},
+    {I_ADD, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42772, 0},
+    {I_ADD, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42777, 4},
+    {I_ADD, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42778, 5},
+    {I_ADD, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42783, 6},
+    {I_ADD, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42784, 7},
+    {I_ADD, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40154, 8},
+    {I_ADD, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40154, 0},
+    {I_ADD, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47287, 8},
+    {I_ADD, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47287, 0},
+    {I_ADD, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47292, 9},
+    {I_ADD, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47292, 5},
+    {I_ADD, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47297, 10},
+    {I_ADD, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47297, 7},
+    {I_ADD, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32906, 11},
+    {I_ADD, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32913, 12},
+    {I_ADD, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32920, 13},
+    {I_ADD, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49207, 8},
+    {I_ADD, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32907, 8},
+    {I_ADD, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47302, 8},
+    {I_ADD, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32914, 9},
+    {I_ADD, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47307, 9},
+    {I_ADD, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32921, 10},
+    {I_ADD, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47312, 10},
+    {I_ADD, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42789, 3},
+    {I_ADD, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32906, 3},
+    {I_ADD, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32927, 3},
+    {I_ADD, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32913, 4},
+    {I_ADD, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32934, 4},
+    {I_ADD, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32920, 6},
+    {I_ADD, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32941, 6},
+    {I_ADD, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42789, 3},
+    {I_ADD, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32906, 3},
+    {I_ADD, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32927, 3},
+    {I_ADD, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32913, 4},
+    {I_ADD, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32934, 4},
+    {I_ADD, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42795, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AND[] = {
+    {I_AND, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47317, 3},
+    {I_AND, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47318, 0},
+    {I_AND, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42801, 3},
+    {I_AND, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42802, 0},
+    {I_AND, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42807, 4},
+    {I_AND, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42808, 5},
+    {I_AND, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42813, 6},
+    {I_AND, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42814, 7},
+    {I_AND, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40434, 8},
+    {I_AND, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40434, 0},
+    {I_AND, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47322, 8},
+    {I_AND, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47322, 0},
+    {I_AND, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47327, 9},
+    {I_AND, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47327, 5},
+    {I_AND, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47332, 10},
+    {I_AND, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47332, 7},
+    {I_AND, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32948, 11},
+    {I_AND, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32955, 12},
+    {I_AND, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32962, 13},
+    {I_AND, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49211, 8},
+    {I_AND, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32949, 8},
+    {I_AND, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47337, 8},
+    {I_AND, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32956, 9},
+    {I_AND, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47342, 9},
+    {I_AND, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32963, 10},
+    {I_AND, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47347, 10},
+    {I_AND, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42819, 3},
+    {I_AND, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32948, 3},
+    {I_AND, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32969, 3},
+    {I_AND, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32955, 4},
+    {I_AND, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32976, 4},
+    {I_AND, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+32962, 6},
+    {I_AND, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32983, 6},
+    {I_AND, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42819, 3},
+    {I_AND, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32948, 3},
+    {I_AND, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32969, 3},
+    {I_AND, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32955, 4},
+    {I_AND, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32976, 4},
+    {I_AND, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42825, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ARPL[] = {
+    {I_ARPL, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+29252, 15},
+    {I_ARPL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+29252, 16},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BB0_RESET[] = {
+    {I_BB0_RESET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49215, 17},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BB1_RESET[] = {
+    {I_BB1_RESET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49219, 17},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BOUND[] = {
+    {I_BOUND, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47352, 18},
+    {I_BOUND, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47357, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BSF[] = {
+    {I_BSF, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+32990, 9},
+    {I_BSF, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32990, 5},
+    {I_BSF, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+32997, 9},
+    {I_BSF, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32997, 5},
+    {I_BSF, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33004, 10},
+    {I_BSF, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33004, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BSR[] = {
+    {I_BSR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33011, 9},
+    {I_BSR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33011, 5},
+    {I_BSR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33018, 9},
+    {I_BSR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33018, 5},
+    {I_BSR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33025, 10},
+    {I_BSR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33025, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BSWAP[] = {
+    {I_BSWAP, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42831, 20},
+    {I_BSWAP, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42837, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BT[] = {
+    {I_BT, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42843, 9},
+    {I_BT, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42843, 5},
+    {I_BT, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42849, 9},
+    {I_BT, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42849, 5},
+    {I_BT, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42855, 10},
+    {I_BT, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42855, 7},
+    {I_BT, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33032, 5},
+    {I_BT, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33039, 5},
+    {I_BT, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33046, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BTC[] = {
+    {I_BTC, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33053, 4},
+    {I_BTC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33054, 5},
+    {I_BTC, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33060, 4},
+    {I_BTC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33061, 5},
+    {I_BTC, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33067, 6},
+    {I_BTC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33068, 7},
+    {I_BTC, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12304, 12},
+    {I_BTC, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12312, 12},
+    {I_BTC, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12320, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BTR[] = {
+    {I_BTR, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33074, 4},
+    {I_BTR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33075, 5},
+    {I_BTR, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33081, 4},
+    {I_BTR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33082, 5},
+    {I_BTR, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33088, 6},
+    {I_BTR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33089, 7},
+    {I_BTR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12328, 12},
+    {I_BTR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12336, 12},
+    {I_BTR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12344, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BTS[] = {
+    {I_BTS, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33095, 4},
+    {I_BTS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33096, 5},
+    {I_BTS, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33102, 4},
+    {I_BTS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33103, 5},
+    {I_BTS, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33109, 6},
+    {I_BTS, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33110, 7},
+    {I_BTS, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12352, 12},
+    {I_BTS, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12360, 12},
+    {I_BTS, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12368, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CALL[] = {
+    {I_CALL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47362, 21},
+    {I_CALL, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47362, 21},
+    {I_CALL, 1, {IMMEDIATE|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42861, 1},
+    {I_CALL, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47367, 22},
+    {I_CALL, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47367, 22},
+    {I_CALL, 1, {IMMEDIATE|BITS16|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42867, 1},
+    {I_CALL, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47372, 23},
+    {I_CALL, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47372, 23},
+    {I_CALL, 1, {IMMEDIATE|BITS32|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42873, 19},
+    {I_CALL, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47377, 24},
+    {I_CALL, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47377, 24},
+    {I_CALL, 2, {IMMEDIATE|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42879, 1},
+    {I_CALL, 2, {IMMEDIATE|BITS16|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42885, 1},
+    {I_CALL, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42885, 1},
+    {I_CALL, 2, {IMMEDIATE|BITS32|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42891, 19},
+    {I_CALL, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42891, 19},
+    {I_CALL, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47382, 1},
+    {I_CALL, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47387, 7},
+    {I_CALL, 1, {MEMORY|BITS16|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47392, 0},
+    {I_CALL, 1, {MEMORY|BITS32|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47397, 5},
+    {I_CALL, 1, {MEMORY|BITS64|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47387, 7},
+    {I_CALL, 1, {MEMORY|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47402, 21},
+    {I_CALL, 1, {RM_GPR|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47407, 22},
+    {I_CALL, 1, {RM_GPR|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47412, 23},
+    {I_CALL, 1, {RM_GPR|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47417, 24},
+    {I_CALL, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47402, 21},
+    {I_CALL, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47407, 22},
+    {I_CALL, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47412, 23},
+    {I_CALL, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47417, 24},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CBW[] = {
+    {I_CBW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49223, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CDQ[] = {
+    {I_CDQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49227, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CDQE[] = {
+    {I_CDQE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49231, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLC[] = {
+    {I_CLC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48819, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLD[] = {
+    {I_CLD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45984, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLI[] = {
+    {I_CLI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48134, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLTS[] = {
+    {I_CLTS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49235, 25},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMC[] = {
+    {I_CMC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50193, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMP[] = {
+    {I_CMP, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+49239, 8},
+    {I_CMP, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+49239, 0},
+    {I_CMP, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47422, 8},
+    {I_CMP, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47422, 0},
+    {I_CMP, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47427, 9},
+    {I_CMP, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47427, 5},
+    {I_CMP, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47432, 10},
+    {I_CMP, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47432, 7},
+    {I_CMP, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40392, 8},
+    {I_CMP, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40392, 0},
+    {I_CMP, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47437, 8},
+    {I_CMP, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47437, 0},
+    {I_CMP, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47442, 9},
+    {I_CMP, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47442, 5},
+    {I_CMP, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47447, 10},
+    {I_CMP, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47447, 7},
+    {I_CMP, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42897, 0},
+    {I_CMP, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42903, 5},
+    {I_CMP, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42909, 7},
+    {I_CMP, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49243, 8},
+    {I_CMP, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+42897, 8},
+    {I_CMP, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47452, 8},
+    {I_CMP, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+42903, 9},
+    {I_CMP, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47457, 9},
+    {I_CMP, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+42909, 10},
+    {I_CMP, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47462, 10},
+    {I_CMP, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47467, 8},
+    {I_CMP, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+42897, 8},
+    {I_CMP, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42915, 8},
+    {I_CMP, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+42903, 9},
+    {I_CMP, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42921, 9},
+    {I_CMP, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+42909, 10},
+    {I_CMP, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42927, 10},
+    {I_CMP, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47467, 8},
+    {I_CMP, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42897, 8},
+    {I_CMP, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42915, 8},
+    {I_CMP, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42903, 9},
+    {I_CMP, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42921, 9},
+    {I_CMP, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47472, 26},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPSB[] = {
+    {I_CMPSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49247, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPSD[] = {
+    {I_CMPSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47477, 5},
+    {I_CMPSD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+34292, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPSQ[] = {
+    {I_CMPSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47482, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPSW[] = {
+    {I_CMPSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47487, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPXCHG[] = {
+    {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42933, 27},
+    {I_CMPXCHG, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42934, 28},
+    {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33116, 27},
+    {I_CMPXCHG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33117, 28},
+    {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33123, 27},
+    {I_CMPXCHG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33124, 28},
+    {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33130, 6},
+    {I_CMPXCHG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33131, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPXCHG486[] = {
+    {I_CMPXCHG486, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47492, 29},
+    {I_CMPXCHG486, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47492, 30},
+    {I_CMPXCHG486, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42939, 29},
+    {I_CMPXCHG486, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42939, 30},
+    {I_CMPXCHG486, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42945, 29},
+    {I_CMPXCHG486, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42945, 30},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPXCHG8B[] = {
+    {I_CMPXCHG8B, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33137, 31},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPXCHG16B[] = {
+    {I_CMPXCHG16B, 1, {MEMORY|BITS128,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42951, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CPUID[] = {
+    {I_CPUID, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49251, 28},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CPU_READ[] = {
+    {I_CPU_READ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49255, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CPU_WRITE[] = {
+    {I_CPU_WRITE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49259, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CQO[] = {
+    {I_CQO, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49263, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CWD[] = {
+    {I_CWD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49267, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CWDE[] = {
+    {I_CWDE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49271, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DAA[] = {
+    {I_DAA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50196, 1},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DAS[] = {
+    {I_DAS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50199, 1},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DEC[] = {
+    {I_DEC, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49275, 1},
+    {I_DEC, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49279, 19},
+    {I_DEC, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47497, 11},
+    {I_DEC, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42957, 11},
+    {I_DEC, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42963, 12},
+    {I_DEC, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42969, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DIV[] = {
+    {I_DIV, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49283, 0},
+    {I_DIV, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47502, 0},
+    {I_DIV, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47507, 5},
+    {I_DIV, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47512, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DMINT[] = {
+    {I_DMINT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49287, 33},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_EMMS[] = {
+    {I_EMMS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49291, 34},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENTER[] = {
+    {I_ENTER, 2, {IMMEDIATE,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47517, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_EQU[] = {
+    {I_EQU, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50228, 0},
+    {I_EQU, 2, {IMMEDIATE|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50228, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_F2XM1[] = {
+    {I_F2XM1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49295, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FABS[] = {
+    {I_FABS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49299, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FADD[] = {
+    {I_FADD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49303, 36},
+    {I_FADD, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49307, 36},
+    {I_FADD, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47522, 36},
+    {I_FADD, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47527, 36},
+    {I_FADD, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47522, 36},
+    {I_FADD, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47532, 36},
+    {I_FADD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49311, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FADDP[] = {
+    {I_FADDP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47537, 36},
+    {I_FADDP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47537, 36},
+    {I_FADDP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49311, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FBLD[] = {
+    {I_FBLD, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49315, 36},
+    {I_FBLD, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49315, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FBSTP[] = {
+    {I_FBSTP, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49319, 36},
+    {I_FBSTP, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49319, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCHS[] = {
+    {I_FCHS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49323, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCLEX[] = {
+    {I_FCLEX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47542, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVB[] = {
+    {I_FCMOVB, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47547, 37},
+    {I_FCMOVB, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47552, 37},
+    {I_FCMOVB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49327, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVBE[] = {
+    {I_FCMOVBE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47557, 37},
+    {I_FCMOVBE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47562, 37},
+    {I_FCMOVBE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49331, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVE[] = {
+    {I_FCMOVE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47567, 37},
+    {I_FCMOVE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47572, 37},
+    {I_FCMOVE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49335, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVNB[] = {
+    {I_FCMOVNB, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47577, 37},
+    {I_FCMOVNB, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47582, 37},
+    {I_FCMOVNB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49339, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVNBE[] = {
+    {I_FCMOVNBE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47587, 37},
+    {I_FCMOVNBE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47592, 37},
+    {I_FCMOVNBE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49343, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVNE[] = {
+    {I_FCMOVNE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47597, 37},
+    {I_FCMOVNE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47602, 37},
+    {I_FCMOVNE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49347, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVNU[] = {
+    {I_FCMOVNU, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47607, 37},
+    {I_FCMOVNU, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47612, 37},
+    {I_FCMOVNU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49351, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCMOVU[] = {
+    {I_FCMOVU, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47617, 37},
+    {I_FCMOVU, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47622, 37},
+    {I_FCMOVU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49355, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCOM[] = {
+    {I_FCOM, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49359, 36},
+    {I_FCOM, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49363, 36},
+    {I_FCOM, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47627, 36},
+    {I_FCOM, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47632, 36},
+    {I_FCOM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49367, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCOMI[] = {
+    {I_FCOMI, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47637, 37},
+    {I_FCOMI, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47642, 37},
+    {I_FCOMI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49371, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCOMIP[] = {
+    {I_FCOMIP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47647, 37},
+    {I_FCOMIP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47652, 37},
+    {I_FCOMIP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49375, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCOMP[] = {
+    {I_FCOMP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49379, 36},
+    {I_FCOMP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49383, 36},
+    {I_FCOMP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47657, 36},
+    {I_FCOMP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47662, 36},
+    {I_FCOMP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49387, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCOMPP[] = {
+    {I_FCOMPP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49391, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FCOS[] = {
+    {I_FCOS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49395, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FDECSTP[] = {
+    {I_FDECSTP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49399, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FDISI[] = {
+    {I_FDISI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47667, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FDIV[] = {
+    {I_FDIV, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49403, 36},
+    {I_FDIV, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49407, 36},
+    {I_FDIV, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47672, 36},
+    {I_FDIV, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47677, 36},
+    {I_FDIV, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47672, 36},
+    {I_FDIV, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47682, 36},
+    {I_FDIV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49411, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FDIVP[] = {
+    {I_FDIVP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47687, 36},
+    {I_FDIVP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47687, 36},
+    {I_FDIVP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49411, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FDIVR[] = {
+    {I_FDIVR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49415, 36},
+    {I_FDIVR, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49419, 36},
+    {I_FDIVR, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47692, 36},
+    {I_FDIVR, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47692, 36},
+    {I_FDIVR, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47697, 36},
+    {I_FDIVR, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47702, 36},
+    {I_FDIVR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49423, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FDIVRP[] = {
+    {I_FDIVRP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47707, 36},
+    {I_FDIVRP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47707, 36},
+    {I_FDIVRP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49423, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FEMMS[] = {
+    {I_FEMMS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49427, 39},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FENI[] = {
+    {I_FENI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47712, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FFREE[] = {
+    {I_FFREE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47717, 36},
+    {I_FFREE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49431, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FFREEP[] = {
+    {I_FFREEP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47722, 40},
+    {I_FFREEP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49435, 40},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FIADD[] = {
+    {I_FIADD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49439, 36},
+    {I_FIADD, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49443, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FICOM[] = {
+    {I_FICOM, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49447, 36},
+    {I_FICOM, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49451, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FICOMP[] = {
+    {I_FICOMP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49455, 36},
+    {I_FICOMP, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49459, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FIDIV[] = {
+    {I_FIDIV, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49463, 36},
+    {I_FIDIV, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49467, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FIDIVR[] = {
+    {I_FIDIVR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49471, 36},
+    {I_FIDIVR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49475, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FILD[] = {
+    {I_FILD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49479, 36},
+    {I_FILD, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49483, 36},
+    {I_FILD, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49487, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FIMUL[] = {
+    {I_FIMUL, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49491, 36},
+    {I_FIMUL, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49495, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FINCSTP[] = {
+    {I_FINCSTP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49499, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FINIT[] = {
+    {I_FINIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47727, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FIST[] = {
+    {I_FIST, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49503, 36},
+    {I_FIST, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49507, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FISTP[] = {
+    {I_FISTP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49511, 36},
+    {I_FISTP, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49515, 36},
+    {I_FISTP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49519, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FISTTP[] = {
+    {I_FISTTP, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49523, 41},
+    {I_FISTTP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49527, 41},
+    {I_FISTTP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49531, 41},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FISUB[] = {
+    {I_FISUB, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49535, 36},
+    {I_FISUB, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49539, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FISUBR[] = {
+    {I_FISUBR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49543, 36},
+    {I_FISUBR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49547, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLD[] = {
+    {I_FLD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49551, 36},
+    {I_FLD, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49555, 36},
+    {I_FLD, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49559, 36},
+    {I_FLD, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47732, 36},
+    {I_FLD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49563, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLD1[] = {
+    {I_FLD1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49567, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDCW[] = {
+    {I_FLDCW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49571, 42},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDENV[] = {
+    {I_FLDENV, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49575, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDL2E[] = {
+    {I_FLDL2E, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49579, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDL2T[] = {
+    {I_FLDL2T, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49583, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDLG2[] = {
+    {I_FLDLG2, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49587, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDLN2[] = {
+    {I_FLDLN2, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49591, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDPI[] = {
+    {I_FLDPI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49595, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FLDZ[] = {
+    {I_FLDZ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49599, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FMUL[] = {
+    {I_FMUL, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49603, 36},
+    {I_FMUL, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49607, 36},
+    {I_FMUL, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47737, 36},
+    {I_FMUL, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47737, 36},
+    {I_FMUL, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47742, 36},
+    {I_FMUL, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47747, 36},
+    {I_FMUL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49611, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FMULP[] = {
+    {I_FMULP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47752, 36},
+    {I_FMULP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47752, 36},
+    {I_FMULP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49611, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNCLEX[] = {
+    {I_FNCLEX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47543, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNDISI[] = {
+    {I_FNDISI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47668, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNENI[] = {
+    {I_FNENI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47713, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNINIT[] = {
+    {I_FNINIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47728, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNOP[] = {
+    {I_FNOP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49615, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNSAVE[] = {
+    {I_FNSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47758, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNSTCW[] = {
+    {I_FNSTCW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47768, 42},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNSTENV[] = {
+    {I_FNSTENV, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47773, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FNSTSW[] = {
+    {I_FNSTSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47783, 42},
+    {I_FNSTSW, 1, {REG_AX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47788, 43},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FPATAN[] = {
+    {I_FPATAN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49619, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FPREM[] = {
+    {I_FPREM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49623, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FPREM1[] = {
+    {I_FPREM1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49627, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FPTAN[] = {
+    {I_FPTAN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49631, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FRNDINT[] = {
+    {I_FRNDINT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49635, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FRSTOR[] = {
+    {I_FRSTOR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49639, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSAVE[] = {
+    {I_FSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47757, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSCALE[] = {
+    {I_FSCALE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49643, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSETPM[] = {
+    {I_FSETPM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49647, 43},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSIN[] = {
+    {I_FSIN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49651, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSINCOS[] = {
+    {I_FSINCOS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49655, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSQRT[] = {
+    {I_FSQRT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49659, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FST[] = {
+    {I_FST, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49663, 36},
+    {I_FST, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49667, 36},
+    {I_FST, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47762, 36},
+    {I_FST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49671, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSTCW[] = {
+    {I_FSTCW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47767, 42},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSTENV[] = {
+    {I_FSTENV, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47772, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSTP[] = {
+    {I_FSTP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49675, 36},
+    {I_FSTP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49679, 36},
+    {I_FSTP, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49683, 36},
+    {I_FSTP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47777, 36},
+    {I_FSTP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49687, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSTSW[] = {
+    {I_FSTSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47782, 42},
+    {I_FSTSW, 1, {REG_AX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47787, 43},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSUB[] = {
+    {I_FSUB, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49691, 36},
+    {I_FSUB, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49695, 36},
+    {I_FSUB, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47792, 36},
+    {I_FSUB, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47792, 36},
+    {I_FSUB, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47797, 36},
+    {I_FSUB, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47802, 36},
+    {I_FSUB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49699, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSUBP[] = {
+    {I_FSUBP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47807, 36},
+    {I_FSUBP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47807, 36},
+    {I_FSUBP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49699, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSUBR[] = {
+    {I_FSUBR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49703, 36},
+    {I_FSUBR, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49707, 36},
+    {I_FSUBR, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47812, 36},
+    {I_FSUBR, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47812, 36},
+    {I_FSUBR, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47817, 36},
+    {I_FSUBR, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47822, 36},
+    {I_FSUBR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49711, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FSUBRP[] = {
+    {I_FSUBRP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47827, 36},
+    {I_FSUBRP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47827, 36},
+    {I_FSUBRP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49711, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FTST[] = {
+    {I_FTST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49715, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FUCOM[] = {
+    {I_FUCOM, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47832, 38},
+    {I_FUCOM, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47837, 38},
+    {I_FUCOM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49719, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FUCOMI[] = {
+    {I_FUCOMI, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47842, 37},
+    {I_FUCOMI, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47847, 37},
+    {I_FUCOMI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49723, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FUCOMIP[] = {
+    {I_FUCOMIP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47852, 37},
+    {I_FUCOMIP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47857, 37},
+    {I_FUCOMIP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49727, 37},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FUCOMP[] = {
+    {I_FUCOMP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47862, 38},
+    {I_FUCOMP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47867, 38},
+    {I_FUCOMP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49731, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FUCOMPP[] = {
+    {I_FUCOMPP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49735, 38},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXAM[] = {
+    {I_FXAM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49739, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXCH[] = {
+    {I_FXCH, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47872, 36},
+    {I_FXCH, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47872, 36},
+    {I_FXCH, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47877, 36},
+    {I_FXCH, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49743, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXTRACT[] = {
+    {I_FXTRACT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49747, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FYL2X[] = {
+    {I_FYL2X, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49751, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FYL2XP1[] = {
+    {I_FYL2XP1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49755, 36},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HLT[] = {
+    {I_HLT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50202, 44},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IBTS[] = {
+    {I_IBTS, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42939, 45},
+    {I_IBTS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42939, 46},
+    {I_IBTS, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42945, 47},
+    {I_IBTS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42945, 46},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ICEBP[] = {
+    {I_ICEBP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50205, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IDIV[] = {
+    {I_IDIV, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49759, 0},
+    {I_IDIV, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47882, 0},
+    {I_IDIV, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47887, 5},
+    {I_IDIV, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47892, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IMUL[] = {
+    {I_IMUL, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49763, 0},
+    {I_IMUL, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47897, 0},
+    {I_IMUL, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47902, 5},
+    {I_IMUL, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47907, 7},
+    {I_IMUL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42975, 9},
+    {I_IMUL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42975, 5},
+    {I_IMUL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42981, 9},
+    {I_IMUL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42981, 5},
+    {I_IMUL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42987, 10},
+    {I_IMUL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42987, 7},
+    {I_IMUL, 3, {REG_GPR|BITS16,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+42993, 48},
+    {I_IMUL, 3, {REG_GPR|BITS16,MEMORY,SBYTEWORD,0,0}, NO_DECORATOR, nasm_bytecodes+42993, 49},
+    {I_IMUL, 3, {REG_GPR|BITS16,MEMORY,IMMEDIATE|BITS16,0,0}, NO_DECORATOR, nasm_bytecodes+42999, 49},
+    {I_IMUL, 3, {REG_GPR|BITS16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+42999, 49},
+    {I_IMUL, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+42993, 35},
+    {I_IMUL, 3, {REG_GPR|BITS16,REG_GPR|BITS16,SBYTEWORD,0,0}, NO_DECORATOR, nasm_bytecodes+42993, 49},
+    {I_IMUL, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE|BITS16,0,0}, NO_DECORATOR, nasm_bytecodes+42999, 35},
+    {I_IMUL, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+42999, 49},
+    {I_IMUL, 3, {REG_GPR|BITS32,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43005, 50},
+    {I_IMUL, 3, {REG_GPR|BITS32,MEMORY,SBYTEDWORD,0,0}, NO_DECORATOR, nasm_bytecodes+43005, 9},
+    {I_IMUL, 3, {REG_GPR|BITS32,MEMORY,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43011, 9},
+    {I_IMUL, 3, {REG_GPR|BITS32,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+43011, 9},
+    {I_IMUL, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43005, 5},
+    {I_IMUL, 3, {REG_GPR|BITS32,REG_GPR|BITS32,SBYTEDWORD,0,0}, NO_DECORATOR, nasm_bytecodes+43005, 9},
+    {I_IMUL, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43011, 5},
+    {I_IMUL, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+43011, 9},
+    {I_IMUL, 3, {REG_GPR|BITS64,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43017, 51},
+    {I_IMUL, 3, {REG_GPR|BITS64,MEMORY,SBYTEDWORD,0,0}, NO_DECORATOR, nasm_bytecodes+43017, 10},
+    {I_IMUL, 3, {REG_GPR|BITS64,MEMORY,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43023, 51},
+    {I_IMUL, 3, {REG_GPR|BITS64,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+43029, 10},
+    {I_IMUL, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43017, 7},
+    {I_IMUL, 3, {REG_GPR|BITS64,REG_GPR|BITS64,SBYTEDWORD,0,0}, NO_DECORATOR, nasm_bytecodes+43017, 10},
+    {I_IMUL, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43023, 7},
+    {I_IMUL, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+43029, 10},
+    {I_IMUL, 2, {REG_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43035, 35},
+    {I_IMUL, 2, {REG_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+43035, 49},
+    {I_IMUL, 2, {REG_GPR|BITS16,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43041, 35},
+    {I_IMUL, 2, {REG_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43041, 49},
+    {I_IMUL, 2, {REG_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43047, 5},
+    {I_IMUL, 2, {REG_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+43047, 9},
+    {I_IMUL, 2, {REG_GPR|BITS32,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43053, 5},
+    {I_IMUL, 2, {REG_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43053, 9},
+    {I_IMUL, 2, {REG_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43059, 7},
+    {I_IMUL, 2, {REG_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+43059, 10},
+    {I_IMUL, 2, {REG_GPR|BITS64,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43065, 7},
+    {I_IMUL, 2, {REG_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43065, 10},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IN[] = {
+    {I_IN, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49767, 52},
+    {I_IN, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47912, 52},
+    {I_IN, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47917, 53},
+    {I_IN, 2, {REG_AL,REG_DX,0,0,0}, NO_DECORATOR, nasm_bytecodes+46092, 0},
+    {I_IN, 2, {REG_AX,REG_DX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49771, 0},
+    {I_IN, 2, {REG_EAX,REG_DX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49775, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INC[] = {
+    {I_INC, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49779, 1},
+    {I_INC, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49783, 19},
+    {I_INC, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47922, 11},
+    {I_INC, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43071, 11},
+    {I_INC, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43077, 12},
+    {I_INC, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43083, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INSB[] = {
+    {I_INSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50208, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INSD[] = {
+    {I_INSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49787, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INSW[] = {
+    {I_INSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49791, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INT[] = {
+    {I_INT, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49795, 52},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INT01[] = {
+    {I_INT01, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50205, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INT1[] = {
+    {I_INT1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50205, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INT03[] = {
+    {I_INT03, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50211, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INT3[] = {
+    {I_INT3, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50211, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INTO[] = {
+    {I_INTO, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50214, 1},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INVD[] = {
+    {I_INVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49799, 54},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INVPCID[] = {
+    {I_INVPCID, 2, {REG_GPR|BITS32,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+33144, 55},
+    {I_INVPCID, 2, {REG_GPR|BITS64,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+33144, 56},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INVLPG[] = {
+    {I_INVLPG, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47927, 54},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INVLPGA[] = {
+    {I_INVLPGA, 2, {REG_AX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43089, 57},
+    {I_INVLPGA, 2, {REG_EAX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43095, 58},
+    {I_INVLPGA, 2, {REG_RAX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33151, 59},
+    {I_INVLPGA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43096, 58},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IRET[] = {
+    {I_IRET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49803, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IRETD[] = {
+    {I_IRETD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49807, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IRETQ[] = {
+    {I_IRETQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49811, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_IRETW[] = {
+    {I_IRETW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49815, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JCXZ[] = {
+    {I_JCXZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47932, 1},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JECXZ[] = {
+    {I_JECXZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47937, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JRCXZ[] = {
+    {I_JRCXZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43101, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JMP[] = {
+    {I_JMP, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47943, 0},
+    {I_JMP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47942, 0},
+    {I_JMP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47947, 21},
+    {I_JMP, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47947, 21},
+    {I_JMP, 1, {IMMEDIATE|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43107, 1},
+    {I_JMP, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47952, 22},
+    {I_JMP, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47952, 22},
+    {I_JMP, 1, {IMMEDIATE|BITS16|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43113, 1},
+    {I_JMP, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47957, 23},
+    {I_JMP, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47957, 23},
+    {I_JMP, 1, {IMMEDIATE|BITS32|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43119, 19},
+    {I_JMP, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47962, 24},
+    {I_JMP, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47962, 24},
+    {I_JMP, 2, {IMMEDIATE|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43125, 1},
+    {I_JMP, 2, {IMMEDIATE|BITS16|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43131, 1},
+    {I_JMP, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43131, 1},
+    {I_JMP, 2, {IMMEDIATE|BITS32|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43137, 19},
+    {I_JMP, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43137, 19},
+    {I_JMP, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47967, 1},
+    {I_JMP, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47972, 7},
+    {I_JMP, 1, {MEMORY|BITS16|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47977, 0},
+    {I_JMP, 1, {MEMORY|BITS32|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47982, 5},
+    {I_JMP, 1, {MEMORY|BITS64|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47972, 7},
+    {I_JMP, 1, {MEMORY|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47987, 21},
+    {I_JMP, 1, {RM_GPR|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47992, 22},
+    {I_JMP, 1, {RM_GPR|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47997, 23},
+    {I_JMP, 1, {RM_GPR|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48002, 24},
+    {I_JMP, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47987, 21},
+    {I_JMP, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47992, 22},
+    {I_JMP, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47997, 23},
+    {I_JMP, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48002, 24},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JMPE[] = {
+    {I_JMPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43143, 60},
+    {I_JMPE, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43149, 60},
+    {I_JMPE, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43155, 60},
+    {I_JMPE, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43161, 60},
+    {I_JMPE, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43167, 60},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LAHF[] = {
+    {I_LAHF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50217, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LAR[] = {
+    {I_LAR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43173, 61},
+    {I_LAR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43173, 62},
+    {I_LAR, 2, {REG_GPR|BITS16,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43173, 63},
+    {I_LAR, 2, {REG_GPR|BITS16,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33158, 64},
+    {I_LAR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43179, 65},
+    {I_LAR, 2, {REG_GPR|BITS32,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43179, 63},
+    {I_LAR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43179, 63},
+    {I_LAR, 2, {REG_GPR|BITS32,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33165, 64},
+    {I_LAR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 66},
+    {I_LAR, 2, {REG_GPR|BITS64,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 64},
+    {I_LAR, 2, {REG_GPR|BITS64,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 64},
+    {I_LAR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 64},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LDS[] = {
+    {I_LDS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48007, 1},
+    {I_LDS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48012, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LEA[] = {
+    {I_LEA, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48017, 67},
+    {I_LEA, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48022, 68},
+    {I_LEA, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48027, 69},
+    {I_LEA, 2, {REG_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48017, 67},
+    {I_LEA, 2, {REG_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48022, 68},
+    {I_LEA, 2, {REG_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48027, 69},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LEAVE[] = {
+    {I_LEAVE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48279, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LES[] = {
+    {I_LES, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48032, 1},
+    {I_LES, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48037, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LFENCE[] = {
+    {I_LFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43191, 59},
+    {I_LFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43191, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LFS[] = {
+    {I_LFS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43197, 5},
+    {I_LFS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43203, 5},
+    {I_LFS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43209, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LGDT[] = {
+    {I_LGDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48042, 25},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LGS[] = {
+    {I_LGS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43215, 5},
+    {I_LGS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43221, 5},
+    {I_LGS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43227, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LIDT[] = {
+    {I_LIDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48047, 25},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LLDT[] = {
+    {I_LLDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48052, 70},
+    {I_LLDT, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48052, 70},
+    {I_LLDT, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48052, 70},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LMSW[] = {
+    {I_LMSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48057, 25},
+    {I_LMSW, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48057, 25},
+    {I_LMSW, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48057, 25},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOADALL[] = {
+    {I_LOADALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49819, 46},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOADALL286[] = {
+    {I_LOADALL286, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49823, 71},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LODSB[] = {
+    {I_LODSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50220, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LODSD[] = {
+    {I_LODSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49827, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LODSQ[] = {
+    {I_LODSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49831, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LODSW[] = {
+    {I_LODSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49835, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOOP[] = {
+    {I_LOOP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48062, 0},
+    {I_LOOP, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48067, 1},
+    {I_LOOP, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48072, 5},
+    {I_LOOP, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48077, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOOPE[] = {
+    {I_LOOPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48082, 0},
+    {I_LOOPE, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48087, 1},
+    {I_LOOPE, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48092, 5},
+    {I_LOOPE, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48097, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOOPNE[] = {
+    {I_LOOPNE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48102, 0},
+    {I_LOOPNE, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48107, 1},
+    {I_LOOPNE, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48112, 5},
+    {I_LOOPNE, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48117, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOOPNZ[] = {
+    {I_LOOPNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48102, 0},
+    {I_LOOPNZ, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48107, 1},
+    {I_LOOPNZ, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48112, 5},
+    {I_LOOPNZ, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48117, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LOOPZ[] = {
+    {I_LOOPZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48082, 0},
+    {I_LOOPZ, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48087, 1},
+    {I_LOOPZ, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48092, 5},
+    {I_LOOPZ, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48097, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LSL[] = {
+    {I_LSL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43233, 61},
+    {I_LSL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43233, 62},
+    {I_LSL, 2, {REG_GPR|BITS16,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43233, 63},
+    {I_LSL, 2, {REG_GPR|BITS16,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33172, 64},
+    {I_LSL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43239, 65},
+    {I_LSL, 2, {REG_GPR|BITS32,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43239, 63},
+    {I_LSL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43239, 63},
+    {I_LSL, 2, {REG_GPR|BITS32,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33179, 64},
+    {I_LSL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 66},
+    {I_LSL, 2, {REG_GPR|BITS64,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 64},
+    {I_LSL, 2, {REG_GPR|BITS64,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 64},
+    {I_LSL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 64},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LSS[] = {
+    {I_LSS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43251, 5},
+    {I_LSS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43257, 5},
+    {I_LSS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43263, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LTR[] = {
+    {I_LTR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48122, 70},
+    {I_LTR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48122, 70},
+    {I_LTR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48122, 70},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MFENCE[] = {
+    {I_MFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43269, 59},
+    {I_MFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43269, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MONITOR[] = {
+    {I_MONITOR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48127, 72},
+    {I_MONITOR, 3, {REG_EAX,REG_ECX,REG_EDX,0,0}, NO_DECORATOR, nasm_bytecodes+48127, 73},
+    {I_MONITOR, 3, {REG_RAX,REG_ECX,REG_EDX,0,0}, NO_DECORATOR, nasm_bytecodes+48127, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MONITORX[] = {
+    {I_MONITORX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48132, 74},
+    {I_MONITORX, 3, {REG_RAX,REG_ECX,REG_EDX,0,0}, NO_DECORATOR, nasm_bytecodes+48132, 59},
+    {I_MONITORX, 3, {REG_EAX,REG_ECX,REG_EDX,0,0}, NO_DECORATOR, nasm_bytecodes+48132, 74},
+    {I_MONITORX, 3, {REG_AX,REG_ECX,REG_EDX,0,0}, NO_DECORATOR, nasm_bytecodes+48132, 74},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOV[] = {
+    {I_MOV, 2, {MEMORY,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48153, 75},
+    {I_MOV, 2, {REG_GPR|BITS16,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48137, 0},
+    {I_MOV, 2, {REG_GPR|BITS32,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48142, 5},
+    {I_MOV, 2, {REG_GPR|BITS64,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48147, 76},
+    {I_MOV, 2, {RM_GPR|BITS64,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48152, 7},
+    {I_MOV, 2, {REG_SREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48173, 75},
+    {I_MOV, 2, {REG_SREG,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48173, 77},
+    {I_MOV, 2, {REG_SREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48173, 78},
+    {I_MOV, 2, {REG_SREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48157, 76},
+    {I_MOV, 2, {REG_SREG,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48162, 0},
+    {I_MOV, 2, {REG_SREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48167, 5},
+    {I_MOV, 2, {REG_SREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48172, 7},
+    {I_MOV, 2, {REG_AL,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+49839, 8},
+    {I_MOV, 2, {REG_AX,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+48177, 8},
+    {I_MOV, 2, {REG_EAX,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+48182, 9},
+    {I_MOV, 2, {REG_RAX,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+48187, 10},
+    {I_MOV, 2, {MEM_OFFS,REG_AL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49843, 79},
+    {I_MOV, 2, {MEM_OFFS,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48192, 79},
+    {I_MOV, 2, {MEM_OFFS,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48197, 80},
+    {I_MOV, 2, {MEM_OFFS,REG_RAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48202, 81},
+    {I_MOV, 2, {REG_GPR|BITS32,REG_CREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43275, 82},
+    {I_MOV, 2, {REG_GPR|BITS64,REG_CREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43281, 83},
+    {I_MOV, 2, {REG_CREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43287, 82},
+    {I_MOV, 2, {REG_CREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43293, 83},
+    {I_MOV, 2, {REG_GPR|BITS32,REG_DREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43300, 82},
+    {I_MOV, 2, {REG_GPR|BITS64,REG_DREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43299, 83},
+    {I_MOV, 2, {REG_DREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43306, 82},
+    {I_MOV, 2, {REG_DREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43305, 83},
+    {I_MOV, 2, {REG_GPR|BITS32,REG_TREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48207, 19},
+    {I_MOV, 2, {REG_TREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48212, 19},
+    {I_MOV, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48217, 8},
+    {I_MOV, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48218, 0},
+    {I_MOV, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43311, 8},
+    {I_MOV, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43312, 0},
+    {I_MOV, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43317, 9},
+    {I_MOV, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43318, 5},
+    {I_MOV, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43323, 10},
+    {I_MOV, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43324, 7},
+    {I_MOV, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+49847, 8},
+    {I_MOV, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+49847, 0},
+    {I_MOV, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48222, 8},
+    {I_MOV, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48222, 0},
+    {I_MOV, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48227, 9},
+    {I_MOV, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48227, 5},
+    {I_MOV, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48232, 10},
+    {I_MOV, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48232, 7},
+    {I_MOV, 2, {REG_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49851, 8},
+    {I_MOV, 2, {REG_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48237, 8},
+    {I_MOV, 2, {REG_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48242, 9},
+    {I_MOV, 2, {REG_GPR|BITS64,UDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+48247, 84},
+    {I_MOV, 2, {REG_GPR|BITS64,SDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33201, 84},
+    {I_MOV, 2, {REG_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48252, 10},
+    {I_MOV, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43329, 8},
+    {I_MOV, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33186, 8},
+    {I_MOV, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33193, 9},
+    {I_MOV, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33200, 10},
+    {I_MOV, 2, {RM_GPR|BITS64,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33200, 7},
+    {I_MOV, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43329, 8},
+    {I_MOV, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33186, 8},
+    {I_MOV, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33193, 9},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVD[] = {
+    {I_MOVD, 2, {MMXREG,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43335, 85},
+    {I_MOVD, 2, {RM_GPR|BITS32,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43341, 85},
+    {I_MOVD, 2, {MMXREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33207, 86},
+    {I_MOVD, 2, {RM_GPR|BITS64,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+33214, 86},
+    {I_MOVD, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34138, 148},
+    {I_MOVD, 2, {XMM_L16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34145, 148},
+    {I_MOVD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34145, 144},
+    {I_MOVD, 2, {RM_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34138, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVQ[] = {
+    {I_MOVQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43347, 87},
+    {I_MOVQ, 2, {RM_MMX,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43353, 87},
+    {I_MOVQ, 2, {MMXREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33207, 88},
+    {I_MOVQ, 2, {RM_GPR|BITS64,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+33214, 88},
+    {I_MOVQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44985, 144},
+    {I_MOVQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44991, 144},
+    {I_MOVQ, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44991, 149},
+    {I_MOVQ, 2, {XMM_L16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44985, 149},
+    {I_MOVQ, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34152, 150},
+    {I_MOVQ, 2, {RM_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34159, 150},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSB[] = {
+    {I_MOVSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12437, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSD[] = {
+    {I_MOVSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49855, 5},
+    {I_MOVSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45543, 144},
+    {I_MOVSD, 2, {RM_XMM_L16|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45549, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSQ[] = {
+    {I_MOVSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49859, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSW[] = {
+    {I_MOVSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49863, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSX[] = {
+    {I_MOVSX, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43359, 53},
+    {I_MOVSX, 2, {REG_GPR|BITS16,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43359, 5},
+    {I_MOVSX, 2, {REG_GPR|BITS32,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43365, 5},
+    {I_MOVSX, 2, {REG_GPR|BITS32,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43371, 5},
+    {I_MOVSX, 2, {REG_GPR|BITS64,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43377, 7},
+    {I_MOVSX, 2, {REG_GPR|BITS64,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43383, 7},
+    {I_MOVSX, 2, {REG_GPR|BITS64,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48257, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSXD[] = {
+    {I_MOVSXD, 2, {REG_GPR|BITS64,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48257, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVZX[] = {
+    {I_MOVZX, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43389, 53},
+    {I_MOVZX, 2, {REG_GPR|BITS16,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43389, 5},
+    {I_MOVZX, 2, {REG_GPR|BITS32,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43395, 5},
+    {I_MOVZX, 2, {REG_GPR|BITS32,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43401, 5},
+    {I_MOVZX, 2, {REG_GPR|BITS64,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43407, 7},
+    {I_MOVZX, 2, {REG_GPR|BITS64,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43413, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MUL[] = {
+    {I_MUL, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49867, 0},
+    {I_MUL, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48262, 0},
+    {I_MUL, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48267, 5},
+    {I_MUL, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48272, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MWAIT[] = {
+    {I_MWAIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48277, 72},
+    {I_MWAIT, 2, {REG_EAX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48277, 72},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MWAITX[] = {
+    {I_MWAITX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48282, 74},
+    {I_MWAITX, 2, {REG_EAX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48282, 74},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_NEG[] = {
+    {I_NEG, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48287, 11},
+    {I_NEG, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43419, 11},
+    {I_NEG, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43425, 12},
+    {I_NEG, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43431, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_NOP[] = {
+    {I_NOP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48292, 0},
+    {I_NOP, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43437, 89},
+    {I_NOP, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43443, 89},
+    {I_NOP, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43449, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_NOT[] = {
+    {I_NOT, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48297, 11},
+    {I_NOT, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43455, 11},
+    {I_NOT, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43461, 12},
+    {I_NOT, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43467, 13},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_OR[] = {
+    {I_OR, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48302, 3},
+    {I_OR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48303, 0},
+    {I_OR, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43473, 3},
+    {I_OR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43474, 0},
+    {I_OR, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43479, 4},
+    {I_OR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43480, 5},
+    {I_OR, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43485, 6},
+    {I_OR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43486, 7},
+    {I_OR, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40679, 8},
+    {I_OR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40679, 0},
+    {I_OR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48307, 8},
+    {I_OR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48307, 0},
+    {I_OR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48312, 9},
+    {I_OR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48312, 5},
+    {I_OR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48317, 10},
+    {I_OR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48317, 7},
+    {I_OR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33221, 11},
+    {I_OR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33228, 12},
+    {I_OR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33235, 13},
+    {I_OR, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49871, 8},
+    {I_OR, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33222, 8},
+    {I_OR, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48322, 8},
+    {I_OR, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33229, 9},
+    {I_OR, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48327, 9},
+    {I_OR, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33236, 10},
+    {I_OR, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48332, 10},
+    {I_OR, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43491, 3},
+    {I_OR, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33221, 3},
+    {I_OR, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33242, 3},
+    {I_OR, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33228, 4},
+    {I_OR, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33249, 4},
+    {I_OR, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33235, 6},
+    {I_OR, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33256, 6},
+    {I_OR, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43491, 3},
+    {I_OR, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33221, 3},
+    {I_OR, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33242, 3},
+    {I_OR, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33228, 4},
+    {I_OR, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33249, 4},
+    {I_OR, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43497, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_OUT[] = {
+    {I_OUT, 2, {IMMEDIATE,REG_AL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49875, 52},
+    {I_OUT, 2, {IMMEDIATE,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48337, 52},
+    {I_OUT, 2, {IMMEDIATE,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48342, 53},
+    {I_OUT, 2, {REG_DX,REG_AL,0,0,0}, NO_DECORATOR, nasm_bytecodes+46074, 0},
+    {I_OUT, 2, {REG_DX,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49879, 0},
+    {I_OUT, 2, {REG_DX,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49883, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_OUTSB[] = {
+    {I_OUTSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50223, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_OUTSD[] = {
+    {I_OUTSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49887, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_OUTSW[] = {
+    {I_OUTSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49891, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PACKSSDW[] = {
+    {I_PACKSSDW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33263, 87},
+    {I_PACKSSDW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45009, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PACKSSWB[] = {
+    {I_PACKSSWB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33270, 87},
+    {I_PACKSSWB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45003, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PACKUSWB[] = {
+    {I_PACKUSWB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33277, 87},
+    {I_PACKUSWB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45015, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDB[] = {
+    {I_PADDB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33284, 87},
+    {I_PADDB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45021, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDD[] = {
+    {I_PADDD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33291, 87},
+    {I_PADDD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45033, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDSB[] = {
+    {I_PADDSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33298, 87},
+    {I_PADDSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45051, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDSIW[] = {
+    {I_PADDSIW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43503, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDSW[] = {
+    {I_PADDSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33305, 87},
+    {I_PADDSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45057, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDUSB[] = {
+    {I_PADDUSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33312, 87},
+    {I_PADDUSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45063, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDUSW[] = {
+    {I_PADDUSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33319, 87},
+    {I_PADDUSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45069, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDW[] = {
+    {I_PADDW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33326, 87},
+    {I_PADDW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45027, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PAND[] = {
+    {I_PAND, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33333, 87},
+    {I_PAND, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45075, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PANDN[] = {
+    {I_PANDN, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33340, 87},
+    {I_PANDN, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45081, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PAUSE[] = {
+    {I_PAUSE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49895, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PAVEB[] = {
+    {I_PAVEB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43509, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PAVGUSB[] = {
+    {I_PAVGUSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12376, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPEQB[] = {
+    {I_PCMPEQB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33347, 87},
+    {I_PCMPEQB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45099, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPEQD[] = {
+    {I_PCMPEQD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33354, 87},
+    {I_PCMPEQD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45111, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPEQW[] = {
+    {I_PCMPEQW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33361, 87},
+    {I_PCMPEQW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45105, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPGTB[] = {
+    {I_PCMPGTB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33368, 87},
+    {I_PCMPGTB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45117, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPGTD[] = {
+    {I_PCMPGTD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33375, 87},
+    {I_PCMPGTD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45129, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPGTW[] = {
+    {I_PCMPGTW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33382, 87},
+    {I_PCMPGTW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45123, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PDISTIB[] = {
+    {I_PDISTIB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45376, 92},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PF2ID[] = {
+    {I_PF2ID, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12384, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFACC[] = {
+    {I_PFACC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12392, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFADD[] = {
+    {I_PFADD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12400, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFCMPEQ[] = {
+    {I_PFCMPEQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12408, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFCMPGE[] = {
+    {I_PFCMPGE, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12416, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFCMPGT[] = {
+    {I_PFCMPGT, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12424, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFMAX[] = {
+    {I_PFMAX, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12432, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFMIN[] = {
+    {I_PFMIN, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12440, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFMUL[] = {
+    {I_PFMUL, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12448, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRCP[] = {
+    {I_PFRCP, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12456, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRCPIT1[] = {
+    {I_PFRCPIT1, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12464, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRCPIT2[] = {
+    {I_PFRCPIT2, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12472, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRSQIT1[] = {
+    {I_PFRSQIT1, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12480, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRSQRT[] = {
+    {I_PFRSQRT, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12488, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFSUB[] = {
+    {I_PFSUB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12496, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFSUBR[] = {
+    {I_PFSUBR, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12504, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PI2FD[] = {
+    {I_PI2FD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12512, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMACHRIW[] = {
+    {I_PMACHRIW, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45472, 92},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMADDWD[] = {
+    {I_PMADDWD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33389, 87},
+    {I_PMADDWD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45135, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAGW[] = {
+    {I_PMAGW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43515, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULHRIW[] = {
+    {I_PMULHRIW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43521, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULHRWA[] = {
+    {I_PMULHRWA, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12520, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULHRWC[] = {
+    {I_PMULHRWC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43527, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULHW[] = {
+    {I_PMULHW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33396, 87},
+    {I_PMULHW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45177, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULLW[] = {
+    {I_PMULLW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33403, 87},
+    {I_PMULLW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45183, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMVGEZB[] = {
+    {I_PMVGEZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45604, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMVLZB[] = {
+    {I_PMVLZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45460, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMVNZB[] = {
+    {I_PMVNZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45442, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMVZB[] = {
+    {I_PMVZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45364, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POP[] = {
+    {I_POP, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49899, 0},
+    {I_POP, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49903, 19},
+    {I_POP, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49907, 7},
+    {I_POP, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48347, 0},
+    {I_POP, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48352, 19},
+    {I_POP, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48357, 7},
+    {I_POP, 1, {REG_ES,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12813, 1},
+    {I_POP, 1, {REG_CS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7495, 93},
+    {I_POP, 1, {REG_SS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7621, 1},
+    {I_POP, 1, {REG_DS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7765, 1},
+    {I_POP, 1, {REG_FS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49911, 5},
+    {I_POP, 1, {REG_GS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49915, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPA[] = {
+    {I_POPA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49919, 18},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPAD[] = {
+    {I_POPAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49923, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPAW[] = {
+    {I_POPAW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49927, 18},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPF[] = {
+    {I_POPF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49931, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPFD[] = {
+    {I_POPFD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49935, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPFQ[] = {
+    {I_POPFQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49935, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPFW[] = {
+    {I_POPFW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49939, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POR[] = {
+    {I_POR, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33410, 87},
+    {I_POR, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45195, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCH[] = {
+    {I_PREFETCH, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48362, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHW[] = {
+    {I_PREFETCHW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48367, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSLLD[] = {
+    {I_PSLLD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33417, 87},
+    {I_PSLLD, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33424, 34},
+    {I_PSLLD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45213, 145},
+    {I_PSLLD, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34222, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSLLQ[] = {
+    {I_PSLLQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33431, 87},
+    {I_PSLLQ, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33438, 34},
+    {I_PSLLQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45219, 145},
+    {I_PSLLQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34229, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSLLW[] = {
+    {I_PSLLW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33445, 87},
+    {I_PSLLW, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33452, 34},
+    {I_PSLLW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45207, 145},
+    {I_PSLLW, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34215, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSRAD[] = {
+    {I_PSRAD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33459, 87},
+    {I_PSRAD, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33466, 34},
+    {I_PSRAD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45231, 145},
+    {I_PSRAD, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34243, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSRAW[] = {
+    {I_PSRAW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33473, 87},
+    {I_PSRAW, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33480, 34},
+    {I_PSRAW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45225, 145},
+    {I_PSRAW, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34236, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSRLD[] = {
+    {I_PSRLD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33487, 87},
+    {I_PSRLD, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33494, 34},
+    {I_PSRLD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45243, 145},
+    {I_PSRLD, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34264, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSRLQ[] = {
+    {I_PSRLQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33501, 87},
+    {I_PSRLQ, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33508, 34},
+    {I_PSRLQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45249, 145},
+    {I_PSRLQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34271, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSRLW[] = {
+    {I_PSRLW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33515, 87},
+    {I_PSRLW, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33522, 34},
+    {I_PSRLW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45237, 145},
+    {I_PSRLW, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34257, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBB[] = {
+    {I_PSUBB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33529, 87},
+    {I_PSUBB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45255, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBD[] = {
+    {I_PSUBD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33536, 87},
+    {I_PSUBD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45267, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBSB[] = {
+    {I_PSUBSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33543, 87},
+    {I_PSUBSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45279, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBSIW[] = {
+    {I_PSUBSIW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43533, 90},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBSW[] = {
+    {I_PSUBSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33550, 87},
+    {I_PSUBSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45285, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBUSB[] = {
+    {I_PSUBUSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33557, 87},
+    {I_PSUBUSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45291, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBUSW[] = {
+    {I_PSUBUSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33564, 87},
+    {I_PSUBUSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45297, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBW[] = {
+    {I_PSUBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33571, 87},
+    {I_PSUBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45261, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKHBW[] = {
+    {I_PUNPCKHBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33578, 87},
+    {I_PUNPCKHBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45303, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKHDQ[] = {
+    {I_PUNPCKHDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33585, 87},
+    {I_PUNPCKHDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45315, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKHWD[] = {
+    {I_PUNPCKHWD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33592, 87},
+    {I_PUNPCKHWD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45309, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKLBW[] = {
+    {I_PUNPCKLBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33599, 87},
+    {I_PUNPCKLBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45327, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKLDQ[] = {
+    {I_PUNPCKLDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33606, 87},
+    {I_PUNPCKLDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45339, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKLWD[] = {
+    {I_PUNPCKLWD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33613, 87},
+    {I_PUNPCKLWD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45333, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSH[] = {
+    {I_PUSH, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49943, 0},
+    {I_PUSH, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49947, 19},
+    {I_PUSH, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49951, 7},
+    {I_PUSH, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48372, 0},
+    {I_PUSH, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48377, 19},
+    {I_PUSH, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48382, 7},
+    {I_PUSH, 1, {REG_ES,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12781, 1},
+    {I_PUSH, 1, {REG_CS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7477, 1},
+    {I_PUSH, 1, {REG_SS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7603, 1},
+    {I_PUSH, 1, {REG_DS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7747, 1},
+    {I_PUSH, 1, {REG_FS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49955, 5},
+    {I_PUSH, 1, {REG_GS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49959, 5},
+    {I_PUSH, 1, {IMMEDIATE|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48408, 35},
+    {I_PUSH, 1, {SBYTEWORD|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48387, 94},
+    {I_PUSH, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48392, 94},
+    {I_PUSH, 1, {SBYTEDWORD|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48397, 95},
+    {I_PUSH, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48402, 95},
+    {I_PUSH, 1, {SBYTEDWORD|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48397, 96},
+    {I_PUSH, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48402, 96},
+    {I_PUSH, 1, {SBYTEDWORD|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48407, 97},
+    {I_PUSH, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48412, 97},
+    {I_PUSH, 1, {SBYTEDWORD|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48407, 97},
+    {I_PUSH, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48412, 97},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHA[] = {
+    {I_PUSHA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49963, 18},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHAD[] = {
+    {I_PUSHAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49967, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHAW[] = {
+    {I_PUSHAW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49971, 18},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHF[] = {
+    {I_PUSHF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49975, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHFD[] = {
+    {I_PUSHFD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49979, 19},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHFQ[] = {
+    {I_PUSHFQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49979, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUSHFW[] = {
+    {I_PUSHFW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49983, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PXOR[] = {
+    {I_PXOR, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33620, 87},
+    {I_PXOR, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45351, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RCL[] = {
+    {I_RCL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+49987, 0},
+    {I_RCL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49991, 0},
+    {I_RCL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48417, 35},
+    {I_RCL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48422, 0},
+    {I_RCL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48427, 0},
+    {I_RCL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43539, 35},
+    {I_RCL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48432, 5},
+    {I_RCL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48437, 5},
+    {I_RCL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43545, 5},
+    {I_RCL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48442, 7},
+    {I_RCL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48447, 7},
+    {I_RCL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43551, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RCR[] = {
+    {I_RCR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+49995, 0},
+    {I_RCR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49999, 0},
+    {I_RCR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48452, 35},
+    {I_RCR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48457, 0},
+    {I_RCR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48462, 0},
+    {I_RCR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43557, 35},
+    {I_RCR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48467, 5},
+    {I_RCR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48472, 5},
+    {I_RCR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43563, 5},
+    {I_RCR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48477, 7},
+    {I_RCR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48482, 7},
+    {I_RCR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43569, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDSHR[] = {
+    {I_RDSHR, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43575, 98},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDMSR[] = {
+    {I_RDMSR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50003, 99},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDPMC[] = {
+    {I_RDPMC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50007, 89},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDTSC[] = {
+    {I_RDTSC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50011, 28},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDTSCP[] = {
+    {I_RDTSCP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48487, 100},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RET[] = {
+    {I_RET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50032, 21},
+    {I_RET, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48513, 101},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETF[] = {
+    {I_RETF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50036, 0},
+    {I_RETF, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48518, 75},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETN[] = {
+    {I_RETN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50032, 21},
+    {I_RETN, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48513, 101},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETW[] = {
+    {I_RETW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50015, 21},
+    {I_RETW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48513, 101},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETFW[] = {
+    {I_RETFW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50019, 0},
+    {I_RETFW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48492, 75},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETNW[] = {
+    {I_RETNW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50015, 21},
+    {I_RETNW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48497, 101},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETD[] = {
+    {I_RETD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50023, 22},
+    {I_RETD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48502, 102},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETFD[] = {
+    {I_RETFD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50027, 0},
+    {I_RETFD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48507, 75},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETND[] = {
+    {I_RETND, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50023, 22},
+    {I_RETND, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48502, 102},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETQ[] = {
+    {I_RETQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50031, 24},
+    {I_RETQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48512, 103},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETFQ[] = {
+    {I_RETFQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50035, 7},
+    {I_RETFQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48517, 104},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RETNQ[] = {
+    {I_RETNQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50031, 24},
+    {I_RETNQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48512, 103},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ROL[] = {
+    {I_ROL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50039, 0},
+    {I_ROL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50043, 0},
+    {I_ROL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48522, 35},
+    {I_ROL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48527, 0},
+    {I_ROL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48532, 0},
+    {I_ROL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43581, 35},
+    {I_ROL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48537, 5},
+    {I_ROL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48542, 5},
+    {I_ROL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43587, 5},
+    {I_ROL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48547, 7},
+    {I_ROL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48552, 7},
+    {I_ROL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43593, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ROR[] = {
+    {I_ROR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50047, 0},
+    {I_ROR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50051, 0},
+    {I_ROR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48557, 35},
+    {I_ROR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48562, 0},
+    {I_ROR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48567, 0},
+    {I_ROR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43599, 35},
+    {I_ROR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48572, 5},
+    {I_ROR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48577, 5},
+    {I_ROR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43605, 5},
+    {I_ROR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48582, 7},
+    {I_ROR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48587, 7},
+    {I_ROR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43611, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDM[] = {
+    {I_RDM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49215, 33},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSDC[] = {
+    {I_RSDC, 2, {REG_SREG,MEMORY|BITS80,0,0,0}, NO_DECORATOR, nasm_bytecodes+45742, 105},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSLDT[] = {
+    {I_RSLDT, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48592, 105},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSM[] = {
+    {I_RSM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50055, 106},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSTS[] = {
+    {I_RSTS, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48597, 105},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SAHF[] = {
+    {I_SAHF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12405, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SAL[] = {
+    {I_SAL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50059, 0},
+    {I_SAL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50063, 0},
+    {I_SAL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48602, 35},
+    {I_SAL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48607, 0},
+    {I_SAL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48612, 0},
+    {I_SAL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43617, 35},
+    {I_SAL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48617, 5},
+    {I_SAL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48622, 5},
+    {I_SAL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43623, 5},
+    {I_SAL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48627, 7},
+    {I_SAL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48632, 7},
+    {I_SAL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43629, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SALC[] = {
+    {I_SALC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49174, 107},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SAR[] = {
+    {I_SAR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50067, 0},
+    {I_SAR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50071, 0},
+    {I_SAR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48637, 35},
+    {I_SAR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48642, 0},
+    {I_SAR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48647, 0},
+    {I_SAR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43635, 35},
+    {I_SAR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48652, 5},
+    {I_SAR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48657, 5},
+    {I_SAR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43641, 5},
+    {I_SAR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48662, 7},
+    {I_SAR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48667, 7},
+    {I_SAR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43647, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SBB[] = {
+    {I_SBB, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48672, 3},
+    {I_SBB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48673, 0},
+    {I_SBB, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43653, 3},
+    {I_SBB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43654, 0},
+    {I_SBB, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43659, 4},
+    {I_SBB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43660, 5},
+    {I_SBB, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43665, 6},
+    {I_SBB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43666, 7},
+    {I_SBB, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+35268, 8},
+    {I_SBB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+35268, 0},
+    {I_SBB, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48677, 8},
+    {I_SBB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48677, 0},
+    {I_SBB, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48682, 9},
+    {I_SBB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48682, 5},
+    {I_SBB, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48687, 10},
+    {I_SBB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48687, 7},
+    {I_SBB, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33627, 11},
+    {I_SBB, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33634, 12},
+    {I_SBB, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33641, 13},
+    {I_SBB, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50075, 8},
+    {I_SBB, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33628, 8},
+    {I_SBB, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48692, 8},
+    {I_SBB, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33635, 9},
+    {I_SBB, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48697, 9},
+    {I_SBB, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33642, 10},
+    {I_SBB, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48702, 10},
+    {I_SBB, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43671, 3},
+    {I_SBB, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33627, 3},
+    {I_SBB, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33648, 3},
+    {I_SBB, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33634, 4},
+    {I_SBB, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33655, 4},
+    {I_SBB, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33641, 6},
+    {I_SBB, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33662, 6},
+    {I_SBB, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43671, 3},
+    {I_SBB, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33627, 3},
+    {I_SBB, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33648, 3},
+    {I_SBB, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33634, 4},
+    {I_SBB, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33655, 4},
+    {I_SBB, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43677, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SCASB[] = {
+    {I_SCASB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50079, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SCASD[] = {
+    {I_SCASD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48707, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SCASQ[] = {
+    {I_SCASQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48712, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SCASW[] = {
+    {I_SCASW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48717, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SFENCE[] = {
+    {I_SFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43683, 59},
+    {I_SFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43683, 139},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SGDT[] = {
+    {I_SGDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48722, 108},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHL[] = {
+    {I_SHL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50059, 0},
+    {I_SHL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50063, 0},
+    {I_SHL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48602, 35},
+    {I_SHL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48607, 0},
+    {I_SHL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48612, 0},
+    {I_SHL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43617, 35},
+    {I_SHL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48617, 5},
+    {I_SHL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48622, 5},
+    {I_SHL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43623, 5},
+    {I_SHL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48627, 7},
+    {I_SHL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48632, 7},
+    {I_SHL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43629, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHLD[] = {
+    {I_SHLD, 3, {MEMORY,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33669, 109},
+    {I_SHLD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33669, 109},
+    {I_SHLD, 3, {MEMORY,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33676, 109},
+    {I_SHLD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33676, 109},
+    {I_SHLD, 3, {MEMORY,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33683, 110},
+    {I_SHLD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33683, 110},
+    {I_SHLD, 3, {MEMORY,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43689, 9},
+    {I_SHLD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43689, 5},
+    {I_SHLD, 3, {MEMORY,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43695, 9},
+    {I_SHLD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43695, 5},
+    {I_SHLD, 3, {MEMORY,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43701, 10},
+    {I_SHLD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43701, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHR[] = {
+    {I_SHR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50083, 0},
+    {I_SHR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50087, 0},
+    {I_SHR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48727, 35},
+    {I_SHR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48732, 0},
+    {I_SHR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48737, 0},
+    {I_SHR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43707, 35},
+    {I_SHR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48742, 5},
+    {I_SHR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48747, 5},
+    {I_SHR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43713, 5},
+    {I_SHR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48752, 7},
+    {I_SHR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48757, 7},
+    {I_SHR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43719, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHRD[] = {
+    {I_SHRD, 3, {MEMORY,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33690, 109},
+    {I_SHRD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33690, 109},
+    {I_SHRD, 3, {MEMORY,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33697, 109},
+    {I_SHRD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33697, 109},
+    {I_SHRD, 3, {MEMORY,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33704, 110},
+    {I_SHRD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33704, 110},
+    {I_SHRD, 3, {MEMORY,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43725, 9},
+    {I_SHRD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43725, 5},
+    {I_SHRD, 3, {MEMORY,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43731, 9},
+    {I_SHRD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43731, 5},
+    {I_SHRD, 3, {MEMORY,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43737, 10},
+    {I_SHRD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43737, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SIDT[] = {
+    {I_SIDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48762, 108},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SLDT[] = {
+    {I_SLDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43762, 108},
+    {I_SLDT, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43762, 108},
+    {I_SLDT, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43743, 108},
+    {I_SLDT, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43749, 5},
+    {I_SLDT, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43755, 7},
+    {I_SLDT, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43761, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SKINIT[] = {
+    {I_SKINIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48767, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SMI[] = {
+    {I_SMI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50205, 111},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SMINT[] = {
+    {I_SMINT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50091, 33},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SMINTOLD[] = {
+    {I_SMINTOLD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50095, 112},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SMSW[] = {
+    {I_SMSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43780, 108},
+    {I_SMSW, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43780, 108},
+    {I_SMSW, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43767, 108},
+    {I_SMSW, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43773, 5},
+    {I_SMSW, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43779, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STC[] = {
+    {I_STC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48489, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STD[] = {
+    {I_STD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50226, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STI[] = {
+    {I_STI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48284, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STOSB[] = {
+    {I_STOSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12509, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STOSD[] = {
+    {I_STOSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50099, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STOSQ[] = {
+    {I_STOSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50103, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STOSW[] = {
+    {I_STOSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50107, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STR[] = {
+    {I_STR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43798, 62},
+    {I_STR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43798, 62},
+    {I_STR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43785, 62},
+    {I_STR, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43791, 63},
+    {I_STR, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43797, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SUB[] = {
+    {I_SUB, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48772, 3},
+    {I_SUB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48773, 0},
+    {I_SUB, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43803, 3},
+    {I_SUB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43804, 0},
+    {I_SUB, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43809, 4},
+    {I_SUB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43810, 5},
+    {I_SUB, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43815, 6},
+    {I_SUB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43816, 7},
+    {I_SUB, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41036, 8},
+    {I_SUB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+41036, 0},
+    {I_SUB, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48777, 8},
+    {I_SUB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48777, 0},
+    {I_SUB, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48782, 9},
+    {I_SUB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48782, 5},
+    {I_SUB, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48787, 10},
+    {I_SUB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48787, 7},
+    {I_SUB, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33711, 11},
+    {I_SUB, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33718, 12},
+    {I_SUB, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33725, 13},
+    {I_SUB, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50111, 8},
+    {I_SUB, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33712, 8},
+    {I_SUB, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48792, 8},
+    {I_SUB, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33719, 9},
+    {I_SUB, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48797, 9},
+    {I_SUB, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33726, 10},
+    {I_SUB, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48802, 10},
+    {I_SUB, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43821, 3},
+    {I_SUB, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33711, 3},
+    {I_SUB, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33732, 3},
+    {I_SUB, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33718, 4},
+    {I_SUB, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33739, 4},
+    {I_SUB, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33725, 6},
+    {I_SUB, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33746, 6},
+    {I_SUB, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43821, 3},
+    {I_SUB, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33711, 3},
+    {I_SUB, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33732, 3},
+    {I_SUB, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33718, 4},
+    {I_SUB, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33739, 4},
+    {I_SUB, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43827, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SVDC[] = {
+    {I_SVDC, 2, {MEMORY|BITS80,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+34357, 105},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SVLDT[] = {
+    {I_SVLDT, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48807, 105},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SVTS[] = {
+    {I_SVTS, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48812, 105},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SWAPGS[] = {
+    {I_SWAPGS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48817, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SYSCALL[] = {
+    {I_SYSCALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49823, 113},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SYSENTER[] = {
+    {I_SYSENTER, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50115, 89},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SYSEXIT[] = {
+    {I_SYSEXIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50119, 114},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SYSRET[] = {
+    {I_SYSRET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49819, 115},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TEST[] = {
+    {I_TEST, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+50123, 8},
+    {I_TEST, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+50123, 0},
+    {I_TEST, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48822, 8},
+    {I_TEST, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48822, 0},
+    {I_TEST, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48827, 9},
+    {I_TEST, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48827, 5},
+    {I_TEST, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48832, 10},
+    {I_TEST, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48832, 7},
+    {I_TEST, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50127, 8},
+    {I_TEST, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48837, 8},
+    {I_TEST, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48842, 9},
+    {I_TEST, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48847, 10},
+    {I_TEST, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50131, 8},
+    {I_TEST, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48852, 8},
+    {I_TEST, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48857, 9},
+    {I_TEST, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48862, 10},
+    {I_TEST, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48867, 8},
+    {I_TEST, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43833, 8},
+    {I_TEST, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43839, 9},
+    {I_TEST, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43845, 10},
+    {I_TEST, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48867, 8},
+    {I_TEST, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43833, 8},
+    {I_TEST, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43839, 9},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UD0[] = {
+    {I_UD0, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50135, 116},
+    {I_UD0, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43851, 35},
+    {I_UD0, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43857, 35},
+    {I_UD0, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43863, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UD1[] = {
+    {I_UD1, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43869, 35},
+    {I_UD1, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43875, 35},
+    {I_UD1, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43881, 35},
+    {I_UD1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50139, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UD2B[] = {
+    {I_UD2B, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50139, 35},
+    {I_UD2B, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43869, 35},
+    {I_UD2B, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43875, 35},
+    {I_UD2B, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43881, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UD2[] = {
+    {I_UD2, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50143, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UD2A[] = {
+    {I_UD2A, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50143, 35},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UMOV[] = {
+    {I_UMOV, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43887, 117},
+    {I_UMOV, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43887, 111},
+    {I_UMOV, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33753, 117},
+    {I_UMOV, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33753, 111},
+    {I_UMOV, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33760, 117},
+    {I_UMOV, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33760, 111},
+    {I_UMOV, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43893, 117},
+    {I_UMOV, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43893, 111},
+    {I_UMOV, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33767, 117},
+    {I_UMOV, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33767, 111},
+    {I_UMOV, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33774, 117},
+    {I_UMOV, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33774, 111},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VERR[] = {
+    {I_VERR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48872, 62},
+    {I_VERR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48872, 62},
+    {I_VERR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48872, 62},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VERW[] = {
+    {I_VERW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48877, 62},
+    {I_VERW, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48877, 62},
+    {I_VERW, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48877, 62},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FWAIT[] = {
+    {I_FWAIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49721, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WBINVD[] = {
+    {I_WBINVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49183, 54},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRSHR[] = {
+    {I_WRSHR, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43899, 98},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRMSR[] = {
+    {I_WRMSR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50147, 99},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XADD[] = {
+    {I_XADD, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43905, 118},
+    {I_XADD, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43906, 20},
+    {I_XADD, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33781, 118},
+    {I_XADD, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33782, 20},
+    {I_XADD, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33788, 118},
+    {I_XADD, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33789, 20},
+    {I_XADD, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33795, 6},
+    {I_XADD, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33796, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XBTS[] = {
+    {I_XBTS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43911, 119},
+    {I_XBTS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43911, 111},
+    {I_XBTS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43917, 120},
+    {I_XBTS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43917, 111},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XCHG[] = {
+    {I_XCHG, 2, {REG_AX,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+50151, 0},
+    {I_XCHG, 2, {REG_EAX,REG32NA,0,0,0}, NO_DECORATOR, nasm_bytecodes+50155, 5},
+    {I_XCHG, 2, {REG_RAX,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+50159, 7},
+    {I_XCHG, 2, {REG_GPR|BITS16,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50163, 0},
+    {I_XCHG, 2, {REG32NA,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50167, 5},
+    {I_XCHG, 2, {REG_GPR|BITS64,REG_RAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50171, 7},
+    {I_XCHG, 2, {REG_EAX,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50175, 19},
+    {I_XCHG, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48882, 3},
+    {I_XCHG, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48883, 0},
+    {I_XCHG, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43923, 3},
+    {I_XCHG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43924, 0},
+    {I_XCHG, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43929, 4},
+    {I_XCHG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43930, 5},
+    {I_XCHG, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43935, 6},
+    {I_XCHG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43936, 7},
+    {I_XCHG, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48887, 3},
+    {I_XCHG, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48888, 0},
+    {I_XCHG, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43941, 3},
+    {I_XCHG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43942, 0},
+    {I_XCHG, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43947, 4},
+    {I_XCHG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43948, 5},
+    {I_XCHG, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43953, 6},
+    {I_XCHG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43954, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XLATB[] = {
+    {I_XLATB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46014, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XLAT[] = {
+    {I_XLAT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46014, 0},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XOR[] = {
+    {I_XOR, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48892, 3},
+    {I_XOR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48893, 0},
+    {I_XOR, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43959, 3},
+    {I_XOR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43960, 0},
+    {I_XOR, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43965, 4},
+    {I_XOR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43966, 5},
+    {I_XOR, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43971, 6},
+    {I_XOR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43972, 7},
+    {I_XOR, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40476, 8},
+    {I_XOR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40476, 0},
+    {I_XOR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48897, 8},
+    {I_XOR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48897, 0},
+    {I_XOR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48902, 9},
+    {I_XOR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48902, 5},
+    {I_XOR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48907, 10},
+    {I_XOR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48907, 7},
+    {I_XOR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33802, 11},
+    {I_XOR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33809, 12},
+    {I_XOR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33816, 13},
+    {I_XOR, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50179, 8},
+    {I_XOR, 2, {REG_AX,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33803, 8},
+    {I_XOR, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48912, 8},
+    {I_XOR, 2, {REG_EAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33810, 9},
+    {I_XOR, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48917, 9},
+    {I_XOR, 2, {REG_RAX,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33817, 10},
+    {I_XOR, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48922, 10},
+    {I_XOR, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43977, 3},
+    {I_XOR, 2, {RM_GPR|BITS16,SBYTEWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33802, 3},
+    {I_XOR, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33823, 3},
+    {I_XOR, 2, {RM_GPR|BITS32,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33809, 4},
+    {I_XOR, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33830, 4},
+    {I_XOR, 2, {RM_GPR|BITS64,SBYTEDWORD,0,0,0}, NO_DECORATOR, nasm_bytecodes+33816, 6},
+    {I_XOR, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33837, 6},
+    {I_XOR, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43977, 3},
+    {I_XOR, 2, {MEMORY,SBYTEWORD|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33802, 3},
+    {I_XOR, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33823, 3},
+    {I_XOR, 2, {MEMORY,SBYTEDWORD|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33809, 4},
+    {I_XOR, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33830, 4},
+    {I_XOR, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43983, 14},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVA[] = {
+    {I_CMOVA, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43989, 121},
+    {I_CMOVA, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43989, 89},
+    {I_CMOVA, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44085, 121},
+    {I_CMOVA, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44085, 89},
+    {I_CMOVA, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44181, 10},
+    {I_CMOVA, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44181, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVAE[] = {
+    {I_CMOVAE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 121},
+    {I_CMOVAE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 89},
+    {I_CMOVAE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 121},
+    {I_CMOVAE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 89},
+    {I_CMOVAE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 10},
+    {I_CMOVAE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVB[] = {
+    {I_CMOVB, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 121},
+    {I_CMOVB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 89},
+    {I_CMOVB, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 121},
+    {I_CMOVB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 89},
+    {I_CMOVB, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 10},
+    {I_CMOVB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVBE[] = {
+    {I_CMOVBE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44007, 121},
+    {I_CMOVBE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44007, 89},
+    {I_CMOVBE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44103, 121},
+    {I_CMOVBE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44103, 89},
+    {I_CMOVBE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44199, 10},
+    {I_CMOVBE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44199, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVC[] = {
+    {I_CMOVC, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 121},
+    {I_CMOVC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 89},
+    {I_CMOVC, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 121},
+    {I_CMOVC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 89},
+    {I_CMOVC, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 10},
+    {I_CMOVC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVE[] = {
+    {I_CMOVE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44013, 121},
+    {I_CMOVE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44013, 89},
+    {I_CMOVE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44109, 121},
+    {I_CMOVE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44109, 89},
+    {I_CMOVE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44205, 10},
+    {I_CMOVE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44205, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVG[] = {
+    {I_CMOVG, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44019, 121},
+    {I_CMOVG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44019, 89},
+    {I_CMOVG, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44115, 121},
+    {I_CMOVG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44115, 89},
+    {I_CMOVG, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44211, 10},
+    {I_CMOVG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44211, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVGE[] = {
+    {I_CMOVGE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44025, 121},
+    {I_CMOVGE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44025, 89},
+    {I_CMOVGE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44121, 121},
+    {I_CMOVGE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44121, 89},
+    {I_CMOVGE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44217, 10},
+    {I_CMOVGE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44217, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVL[] = {
+    {I_CMOVL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44031, 121},
+    {I_CMOVL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44031, 89},
+    {I_CMOVL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44127, 121},
+    {I_CMOVL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44127, 89},
+    {I_CMOVL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44223, 10},
+    {I_CMOVL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44223, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVLE[] = {
+    {I_CMOVLE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44037, 121},
+    {I_CMOVLE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44037, 89},
+    {I_CMOVLE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44133, 121},
+    {I_CMOVLE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44133, 89},
+    {I_CMOVLE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44229, 10},
+    {I_CMOVLE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44229, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNA[] = {
+    {I_CMOVNA, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44007, 121},
+    {I_CMOVNA, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44007, 89},
+    {I_CMOVNA, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44103, 121},
+    {I_CMOVNA, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44103, 89},
+    {I_CMOVNA, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44199, 10},
+    {I_CMOVNA, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44199, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNAE[] = {
+    {I_CMOVNAE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 121},
+    {I_CMOVNAE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 89},
+    {I_CMOVNAE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 121},
+    {I_CMOVNAE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 89},
+    {I_CMOVNAE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 10},
+    {I_CMOVNAE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNB[] = {
+    {I_CMOVNB, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 121},
+    {I_CMOVNB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 89},
+    {I_CMOVNB, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 121},
+    {I_CMOVNB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 89},
+    {I_CMOVNB, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 10},
+    {I_CMOVNB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNBE[] = {
+    {I_CMOVNBE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43989, 121},
+    {I_CMOVNBE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43989, 89},
+    {I_CMOVNBE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44085, 121},
+    {I_CMOVNBE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44085, 89},
+    {I_CMOVNBE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44181, 10},
+    {I_CMOVNBE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44181, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNC[] = {
+    {I_CMOVNC, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 121},
+    {I_CMOVNC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 89},
+    {I_CMOVNC, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 121},
+    {I_CMOVNC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 89},
+    {I_CMOVNC, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 10},
+    {I_CMOVNC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNE[] = {
+    {I_CMOVNE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44043, 121},
+    {I_CMOVNE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44043, 89},
+    {I_CMOVNE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44139, 121},
+    {I_CMOVNE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44139, 89},
+    {I_CMOVNE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44235, 10},
+    {I_CMOVNE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44235, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNG[] = {
+    {I_CMOVNG, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44037, 121},
+    {I_CMOVNG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44037, 89},
+    {I_CMOVNG, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44133, 121},
+    {I_CMOVNG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44133, 89},
+    {I_CMOVNG, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44229, 10},
+    {I_CMOVNG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44229, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNGE[] = {
+    {I_CMOVNGE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44031, 121},
+    {I_CMOVNGE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44031, 89},
+    {I_CMOVNGE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44127, 121},
+    {I_CMOVNGE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44127, 89},
+    {I_CMOVNGE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44223, 10},
+    {I_CMOVNGE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44223, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNL[] = {
+    {I_CMOVNL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44025, 121},
+    {I_CMOVNL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44025, 89},
+    {I_CMOVNL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44121, 121},
+    {I_CMOVNL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44121, 89},
+    {I_CMOVNL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44217, 10},
+    {I_CMOVNL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44217, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNLE[] = {
+    {I_CMOVNLE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44019, 121},
+    {I_CMOVNLE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44019, 89},
+    {I_CMOVNLE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44115, 121},
+    {I_CMOVNLE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44115, 89},
+    {I_CMOVNLE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44211, 10},
+    {I_CMOVNLE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44211, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNO[] = {
+    {I_CMOVNO, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44049, 121},
+    {I_CMOVNO, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44049, 89},
+    {I_CMOVNO, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44145, 121},
+    {I_CMOVNO, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44145, 89},
+    {I_CMOVNO, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44241, 10},
+    {I_CMOVNO, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44241, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNP[] = {
+    {I_CMOVNP, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44055, 121},
+    {I_CMOVNP, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44055, 89},
+    {I_CMOVNP, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44151, 121},
+    {I_CMOVNP, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44151, 89},
+    {I_CMOVNP, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44247, 10},
+    {I_CMOVNP, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44247, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNS[] = {
+    {I_CMOVNS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44061, 121},
+    {I_CMOVNS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44061, 89},
+    {I_CMOVNS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44157, 121},
+    {I_CMOVNS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44157, 89},
+    {I_CMOVNS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44253, 10},
+    {I_CMOVNS, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44253, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVNZ[] = {
+    {I_CMOVNZ, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44043, 121},
+    {I_CMOVNZ, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44043, 89},
+    {I_CMOVNZ, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44139, 121},
+    {I_CMOVNZ, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44139, 89},
+    {I_CMOVNZ, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44235, 10},
+    {I_CMOVNZ, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44235, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVO[] = {
+    {I_CMOVO, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44067, 121},
+    {I_CMOVO, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44067, 89},
+    {I_CMOVO, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44163, 121},
+    {I_CMOVO, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44163, 89},
+    {I_CMOVO, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44259, 10},
+    {I_CMOVO, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44259, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVP[] = {
+    {I_CMOVP, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44073, 121},
+    {I_CMOVP, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44073, 89},
+    {I_CMOVP, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44169, 121},
+    {I_CMOVP, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44169, 89},
+    {I_CMOVP, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44265, 10},
+    {I_CMOVP, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44265, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVPE[] = {
+    {I_CMOVPE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44073, 121},
+    {I_CMOVPE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44073, 89},
+    {I_CMOVPE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44169, 121},
+    {I_CMOVPE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44169, 89},
+    {I_CMOVPE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44265, 10},
+    {I_CMOVPE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44265, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVPO[] = {
+    {I_CMOVPO, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44055, 121},
+    {I_CMOVPO, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44055, 89},
+    {I_CMOVPO, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44151, 121},
+    {I_CMOVPO, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44151, 89},
+    {I_CMOVPO, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44247, 10},
+    {I_CMOVPO, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44247, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVS[] = {
+    {I_CMOVS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44079, 121},
+    {I_CMOVS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44079, 89},
+    {I_CMOVS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44175, 121},
+    {I_CMOVS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44175, 89},
+    {I_CMOVS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44271, 10},
+    {I_CMOVS, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44271, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMOVZ[] = {
+    {I_CMOVZ, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44013, 121},
+    {I_CMOVZ, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44013, 89},
+    {I_CMOVZ, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44109, 121},
+    {I_CMOVZ, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44109, 89},
+    {I_CMOVZ, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44205, 10},
+    {I_CMOVZ, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44205, 7},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JA[] = {
+    {I_JA, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44277, 122},
+    {I_JA, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44373, 23},
+    {I_JA, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44469, 23},
+    {I_JA, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44565, 24},
+    {I_JA, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48928, 21},
+    {I_JA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48927, 21},
+    {I_JA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44566, 122},
+    {I_JA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33844, 21},
+    {I_JA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48928, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JAE[] = {
+    {I_JAE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44283, 122},
+    {I_JAE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44379, 23},
+    {I_JAE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44475, 23},
+    {I_JAE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44571, 24},
+    {I_JAE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    {I_JAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48932, 21},
+    {I_JAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44572, 122},
+    {I_JAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33851, 21},
+    {I_JAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JB[] = {
+    {I_JB, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44289, 122},
+    {I_JB, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44385, 23},
+    {I_JB, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44481, 23},
+    {I_JB, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44577, 24},
+    {I_JB, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    {I_JB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48937, 21},
+    {I_JB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44578, 122},
+    {I_JB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33858, 21},
+    {I_JB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JBE[] = {
+    {I_JBE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44295, 122},
+    {I_JBE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44391, 23},
+    {I_JBE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44487, 23},
+    {I_JBE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44583, 24},
+    {I_JBE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48943, 21},
+    {I_JBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48942, 21},
+    {I_JBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44584, 122},
+    {I_JBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33865, 21},
+    {I_JBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48943, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JC[] = {
+    {I_JC, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44289, 122},
+    {I_JC, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44385, 23},
+    {I_JC, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44481, 23},
+    {I_JC, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44577, 24},
+    {I_JC, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    {I_JC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48937, 21},
+    {I_JC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44578, 122},
+    {I_JC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33858, 21},
+    {I_JC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JE[] = {
+    {I_JE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44301, 122},
+    {I_JE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44397, 23},
+    {I_JE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44493, 23},
+    {I_JE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44589, 24},
+    {I_JE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48948, 21},
+    {I_JE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48947, 21},
+    {I_JE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44590, 122},
+    {I_JE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33872, 21},
+    {I_JE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48948, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JG[] = {
+    {I_JG, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44307, 122},
+    {I_JG, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44403, 23},
+    {I_JG, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44499, 23},
+    {I_JG, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44595, 24},
+    {I_JG, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48953, 21},
+    {I_JG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48952, 21},
+    {I_JG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44596, 122},
+    {I_JG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33879, 21},
+    {I_JG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48953, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JGE[] = {
+    {I_JGE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44313, 122},
+    {I_JGE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44409, 23},
+    {I_JGE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44505, 23},
+    {I_JGE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44601, 24},
+    {I_JGE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48958, 21},
+    {I_JGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48957, 21},
+    {I_JGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44602, 122},
+    {I_JGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33886, 21},
+    {I_JGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48958, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JL[] = {
+    {I_JL, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44319, 122},
+    {I_JL, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44415, 23},
+    {I_JL, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44511, 23},
+    {I_JL, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44607, 24},
+    {I_JL, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48963, 21},
+    {I_JL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48962, 21},
+    {I_JL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44608, 122},
+    {I_JL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33893, 21},
+    {I_JL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48963, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JLE[] = {
+    {I_JLE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44325, 122},
+    {I_JLE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44421, 23},
+    {I_JLE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44517, 23},
+    {I_JLE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44613, 24},
+    {I_JLE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48968, 21},
+    {I_JLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48967, 21},
+    {I_JLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44614, 122},
+    {I_JLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33900, 21},
+    {I_JLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48968, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNA[] = {
+    {I_JNA, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44295, 122},
+    {I_JNA, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44391, 23},
+    {I_JNA, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44487, 23},
+    {I_JNA, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44583, 24},
+    {I_JNA, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48943, 21},
+    {I_JNA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48942, 21},
+    {I_JNA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44584, 122},
+    {I_JNA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33865, 21},
+    {I_JNA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48943, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNAE[] = {
+    {I_JNAE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44289, 122},
+    {I_JNAE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44385, 23},
+    {I_JNAE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44481, 23},
+    {I_JNAE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44577, 24},
+    {I_JNAE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    {I_JNAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48937, 21},
+    {I_JNAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44578, 122},
+    {I_JNAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33858, 21},
+    {I_JNAE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNB[] = {
+    {I_JNB, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44283, 122},
+    {I_JNB, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44379, 23},
+    {I_JNB, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44475, 23},
+    {I_JNB, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44571, 24},
+    {I_JNB, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    {I_JNB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48932, 21},
+    {I_JNB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44572, 122},
+    {I_JNB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33851, 21},
+    {I_JNB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNBE[] = {
+    {I_JNBE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44277, 122},
+    {I_JNBE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44373, 23},
+    {I_JNBE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44469, 23},
+    {I_JNBE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44565, 24},
+    {I_JNBE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48928, 21},
+    {I_JNBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48927, 21},
+    {I_JNBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44566, 122},
+    {I_JNBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33844, 21},
+    {I_JNBE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48928, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNC[] = {
+    {I_JNC, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44283, 122},
+    {I_JNC, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44379, 23},
+    {I_JNC, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44475, 23},
+    {I_JNC, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44571, 24},
+    {I_JNC, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    {I_JNC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48932, 21},
+    {I_JNC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44572, 122},
+    {I_JNC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33851, 21},
+    {I_JNC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNE[] = {
+    {I_JNE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44331, 122},
+    {I_JNE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44427, 23},
+    {I_JNE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44523, 23},
+    {I_JNE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44619, 24},
+    {I_JNE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48973, 21},
+    {I_JNE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48972, 21},
+    {I_JNE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44620, 122},
+    {I_JNE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33907, 21},
+    {I_JNE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48973, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNG[] = {
+    {I_JNG, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44325, 122},
+    {I_JNG, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44421, 23},
+    {I_JNG, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44517, 23},
+    {I_JNG, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44613, 24},
+    {I_JNG, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48968, 21},
+    {I_JNG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48967, 21},
+    {I_JNG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44614, 122},
+    {I_JNG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33900, 21},
+    {I_JNG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48968, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNGE[] = {
+    {I_JNGE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44319, 122},
+    {I_JNGE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44415, 23},
+    {I_JNGE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44511, 23},
+    {I_JNGE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44607, 24},
+    {I_JNGE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48963, 21},
+    {I_JNGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48962, 21},
+    {I_JNGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44608, 122},
+    {I_JNGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33893, 21},
+    {I_JNGE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48963, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNL[] = {
+    {I_JNL, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44313, 122},
+    {I_JNL, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44409, 23},
+    {I_JNL, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44505, 23},
+    {I_JNL, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44601, 24},
+    {I_JNL, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48958, 21},
+    {I_JNL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48957, 21},
+    {I_JNL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44602, 122},
+    {I_JNL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33886, 21},
+    {I_JNL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48958, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNLE[] = {
+    {I_JNLE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44307, 122},
+    {I_JNLE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44403, 23},
+    {I_JNLE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44499, 23},
+    {I_JNLE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44595, 24},
+    {I_JNLE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48953, 21},
+    {I_JNLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48952, 21},
+    {I_JNLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44596, 122},
+    {I_JNLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33879, 21},
+    {I_JNLE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48953, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNO[] = {
+    {I_JNO, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44337, 122},
+    {I_JNO, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44433, 23},
+    {I_JNO, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44529, 23},
+    {I_JNO, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44625, 24},
+    {I_JNO, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48978, 21},
+    {I_JNO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48977, 21},
+    {I_JNO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44626, 122},
+    {I_JNO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33914, 21},
+    {I_JNO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48978, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNP[] = {
+    {I_JNP, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44343, 122},
+    {I_JNP, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44439, 23},
+    {I_JNP, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44535, 23},
+    {I_JNP, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44631, 24},
+    {I_JNP, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48983, 21},
+    {I_JNP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48982, 21},
+    {I_JNP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44632, 122},
+    {I_JNP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33921, 21},
+    {I_JNP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48983, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNS[] = {
+    {I_JNS, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44349, 122},
+    {I_JNS, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44445, 23},
+    {I_JNS, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44541, 23},
+    {I_JNS, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44637, 24},
+    {I_JNS, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48988, 21},
+    {I_JNS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48987, 21},
+    {I_JNS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44638, 122},
+    {I_JNS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33928, 21},
+    {I_JNS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48988, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JNZ[] = {
+    {I_JNZ, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44331, 122},
+    {I_JNZ, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44427, 23},
+    {I_JNZ, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44523, 23},
+    {I_JNZ, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44619, 24},
+    {I_JNZ, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48973, 21},
+    {I_JNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48972, 21},
+    {I_JNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44620, 122},
+    {I_JNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33907, 21},
+    {I_JNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48973, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JO[] = {
+    {I_JO, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44355, 122},
+    {I_JO, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44451, 23},
+    {I_JO, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44547, 23},
+    {I_JO, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44643, 24},
+    {I_JO, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48993, 21},
+    {I_JO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48992, 21},
+    {I_JO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44644, 122},
+    {I_JO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33935, 21},
+    {I_JO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48993, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JP[] = {
+    {I_JP, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44361, 122},
+    {I_JP, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44457, 23},
+    {I_JP, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44553, 23},
+    {I_JP, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44649, 24},
+    {I_JP, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48998, 21},
+    {I_JP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48997, 21},
+    {I_JP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44650, 122},
+    {I_JP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33942, 21},
+    {I_JP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48998, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JPE[] = {
+    {I_JPE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44361, 122},
+    {I_JPE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44457, 23},
+    {I_JPE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44553, 23},
+    {I_JPE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44649, 24},
+    {I_JPE, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48998, 21},
+    {I_JPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48997, 21},
+    {I_JPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44650, 122},
+    {I_JPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33942, 21},
+    {I_JPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48998, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JPO[] = {
+    {I_JPO, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44343, 122},
+    {I_JPO, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44439, 23},
+    {I_JPO, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44535, 23},
+    {I_JPO, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44631, 24},
+    {I_JPO, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48983, 21},
+    {I_JPO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48982, 21},
+    {I_JPO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44632, 122},
+    {I_JPO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33921, 21},
+    {I_JPO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48983, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JS[] = {
+    {I_JS, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44367, 122},
+    {I_JS, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44463, 23},
+    {I_JS, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44559, 23},
+    {I_JS, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44655, 24},
+    {I_JS, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49003, 21},
+    {I_JS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49002, 21},
+    {I_JS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44656, 122},
+    {I_JS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33949, 21},
+    {I_JS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49003, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_JZ[] = {
+    {I_JZ, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44301, 122},
+    {I_JZ, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44397, 23},
+    {I_JZ, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44493, 23},
+    {I_JZ, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44589, 24},
+    {I_JZ, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48948, 21},
+    {I_JZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48947, 21},
+    {I_JZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44590, 122},
+    {I_JZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33872, 21},
+    {I_JZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48948, 21},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETA[] = {
+    {I_SETA, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49007, 53},
+    {I_SETA, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49007, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETAE[] = {
+    {I_SETAE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 53},
+    {I_SETAE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETB[] = {
+    {I_SETB, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 53},
+    {I_SETB, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETBE[] = {
+    {I_SETBE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49022, 53},
+    {I_SETBE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49022, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETC[] = {
+    {I_SETC, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 53},
+    {I_SETC, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETE[] = {
+    {I_SETE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49027, 53},
+    {I_SETE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49027, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETG[] = {
+    {I_SETG, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49032, 53},
+    {I_SETG, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49032, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETGE[] = {
+    {I_SETGE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49037, 53},
+    {I_SETGE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49037, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETL[] = {
+    {I_SETL, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49042, 53},
+    {I_SETL, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49042, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETLE[] = {
+    {I_SETLE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49047, 53},
+    {I_SETLE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49047, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNA[] = {
+    {I_SETNA, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49022, 53},
+    {I_SETNA, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49022, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNAE[] = {
+    {I_SETNAE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 53},
+    {I_SETNAE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNB[] = {
+    {I_SETNB, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 53},
+    {I_SETNB, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNBE[] = {
+    {I_SETNBE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49007, 53},
+    {I_SETNBE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49007, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNC[] = {
+    {I_SETNC, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 53},
+    {I_SETNC, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNE[] = {
+    {I_SETNE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49052, 53},
+    {I_SETNE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49052, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNG[] = {
+    {I_SETNG, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49047, 53},
+    {I_SETNG, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49047, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNGE[] = {
+    {I_SETNGE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49042, 53},
+    {I_SETNGE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49042, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNL[] = {
+    {I_SETNL, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49037, 53},
+    {I_SETNL, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49037, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNLE[] = {
+    {I_SETNLE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49032, 53},
+    {I_SETNLE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49032, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNO[] = {
+    {I_SETNO, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49057, 53},
+    {I_SETNO, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49057, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNP[] = {
+    {I_SETNP, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49062, 53},
+    {I_SETNP, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49062, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNS[] = {
+    {I_SETNS, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49067, 53},
+    {I_SETNS, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49067, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETNZ[] = {
+    {I_SETNZ, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49052, 53},
+    {I_SETNZ, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49052, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETO[] = {
+    {I_SETO, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49072, 53},
+    {I_SETO, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49072, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETP[] = {
+    {I_SETP, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49077, 53},
+    {I_SETP, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49077, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETPE[] = {
+    {I_SETPE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49077, 53},
+    {I_SETPE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49077, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETPO[] = {
+    {I_SETPO, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49062, 53},
+    {I_SETPO, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49062, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETS[] = {
+    {I_SETS, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49082, 53},
+    {I_SETS, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49082, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETZ[] = {
+    {I_SETZ, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49027, 53},
+    {I_SETZ, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49027, 5},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADDPS[] = {
+    {I_ADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44661, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADDSS[] = {
+    {I_ADDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44667, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ANDNPS[] = {
+    {I_ANDNPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44673, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ANDPS[] = {
+    {I_ANDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44679, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPEQPS[] = {
+    {I_CMPEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12528, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPEQSS[] = {
+    {I_CMPEQSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12536, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLEPS[] = {
+    {I_CMPLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12544, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLESS[] = {
+    {I_CMPLESS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12552, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLTPS[] = {
+    {I_CMPLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12560, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLTSS[] = {
+    {I_CMPLTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12568, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNEQPS[] = {
+    {I_CMPNEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12576, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNEQSS[] = {
+    {I_CMPNEQSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12584, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLEPS[] = {
+    {I_CMPNLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12592, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLESS[] = {
+    {I_CMPNLESS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12600, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLTPS[] = {
+    {I_CMPNLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12608, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLTSS[] = {
+    {I_CMPNLTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12616, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPORDPS[] = {
+    {I_CMPORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12624, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPORDSS[] = {
+    {I_CMPORDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12632, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPUNORDPS[] = {
+    {I_CMPUNORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12640, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPUNORDSS[] = {
+    {I_CMPUNORDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12648, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPPS[] = {
+    {I_CMPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+33956, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPSS[] = {
+    {I_CMPSS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+33963, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_COMISS[] = {
+    {I_COMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44685, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPI2PS[] = {
+    {I_CVTPI2PS, 2, {XMM_L16,RM_MMX|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44691, 124},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPS2PI[] = {
+    {I_CVTPS2PI, 2, {MMXREG,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44697, 124},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTSI2SS[] = {
+    {I_CVTSI2SS, 2, {XMM_L16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33971, 125},
+    {I_CVTSI2SS, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33971, 125},
+    {I_CVTSI2SS, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33970, 126},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTSS2SI[] = {
+    {I_CVTSS2SI, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33978, 125},
+    {I_CVTSS2SI, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33978, 125},
+    {I_CVTSS2SI, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33977, 127},
+    {I_CVTSS2SI, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33977, 127},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTTPS2PI[] = {
+    {I_CVTTPS2PI, 2, {MMXREG,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44703, 128},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTTSS2SI[] = {
+    {I_CVTTSS2SI, 2, {REG_GPR|BITS32,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33985, 125},
+    {I_CVTTSS2SI, 2, {REG_GPR|BITS64,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33984, 127},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DIVPS[] = {
+    {I_DIVPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44709, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DIVSS[] = {
+    {I_DIVSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44715, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LDMXCSR[] = {
+    {I_LDMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44721, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MAXPS[] = {
+    {I_MAXPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44727, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MAXSS[] = {
+    {I_MAXSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44733, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MINPS[] = {
+    {I_MINPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44739, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MINSS[] = {
+    {I_MINSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44745, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVAPS[] = {
+    {I_MOVAPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44751, 123},
+    {I_MOVAPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44757, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVHPS[] = {
+    {I_MOVHPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44763, 123},
+    {I_MOVHPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44769, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVLHPS[] = {
+    {I_MOVLHPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44763, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVLPS[] = {
+    {I_MOVLPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43893, 123},
+    {I_MOVLPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44775, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVHLPS[] = {
+    {I_MOVHLPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43893, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVMSKPS[] = {
+    {I_MOVMSKPS, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44781, 123},
+    {I_MOVMSKPS, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33991, 129},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTPS[] = {
+    {I_MOVNTPS, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44787, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSS[] = {
+    {I_MOVSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44793, 123},
+    {I_MOVSS, 2, {RM_XMM_L16|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44799, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVUPS[] = {
+    {I_MOVUPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44805, 123},
+    {I_MOVUPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44811, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MULPS[] = {
+    {I_MULPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44817, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MULSS[] = {
+    {I_MULSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44823, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ORPS[] = {
+    {I_ORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44829, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RCPPS[] = {
+    {I_RCPPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44835, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RCPSS[] = {
+    {I_RCPSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44841, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSQRTPS[] = {
+    {I_RSQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44847, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSQRTSS[] = {
+    {I_RSQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44853, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHUFPS[] = {
+    {I_SHUFPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+33998, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SQRTPS[] = {
+    {I_SQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44859, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SQRTSS[] = {
+    {I_SQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44865, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STMXCSR[] = {
+    {I_STMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44871, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SUBPS[] = {
+    {I_SUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44877, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SUBSS[] = {
+    {I_SUBSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44883, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UCOMISS[] = {
+    {I_UCOMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44889, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UNPCKHPS[] = {
+    {I_UNPCKHPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44895, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UNPCKLPS[] = {
+    {I_UNPCKLPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44901, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XORPS[] = {
+    {I_XORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44907, 123},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXRSTOR[] = {
+    {I_FXRSTOR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34006, 130},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXRSTOR64[] = {
+    {I_FXRSTOR64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34005, 131},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXSAVE[] = {
+    {I_FXSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34013, 130},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_FXSAVE64[] = {
+    {I_FXSAVE64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34012, 131},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XGETBV[] = {
+    {I_XGETBV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49087, 132},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSETBV[] = {
+    {I_XSETBV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49092, 133},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVE[] = {
+    {I_XSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34020, 132},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVE64[] = {
+    {I_XSAVE64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34019, 134},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVEC[] = {
+    {I_XSAVEC, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34027, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVEC64[] = {
+    {I_XSAVEC64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34026, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVEOPT[] = {
+    {I_XSAVEOPT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34034, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVEOPT64[] = {
+    {I_XSAVEOPT64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34033, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVES[] = {
+    {I_XSAVES, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34041, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSAVES64[] = {
+    {I_XSAVES64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34040, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XRSTOR[] = {
+    {I_XRSTOR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34048, 132},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XRSTOR64[] = {
+    {I_XRSTOR64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34047, 134},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XRSTORS[] = {
+    {I_XRSTORS, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34055, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XRSTORS64[] = {
+    {I_XRSTORS64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34054, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHNTA[] = {
+    {I_PREFETCHNTA, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46126, 137},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHT0[] = {
+    {I_PREFETCHT0, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46144, 137},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHT1[] = {
+    {I_PREFETCHT1, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46162, 137},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHT2[] = {
+    {I_PREFETCHT2, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46180, 137},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHIT0[] = {
+    {I_PREFETCHIT0, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46252, 138},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHIT1[] = {
+    {I_PREFETCHIT1, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46234, 138},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MASKMOVQ[] = {
+    {I_MASKMOVQ, 2, {MMXREG,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44913, 140},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTQ[] = {
+    {I_MOVNTQ, 2, {MEMORY,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44919, 141},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PAVGB[] = {
+    {I_PAVGB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34061, 141},
+    {I_PAVGB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45087, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PAVGW[] = {
+    {I_PAVGW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34068, 141},
+    {I_PAVGW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45093, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PEXTRW[] = {
+    {I_PEXTRW, 3, {REG_GPR|BITS32,MMXREG,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34075, 142},
+    {I_PEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34166, 152},
+    {I_PEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34166, 153},
+    {I_PEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4277, 173},
+    {I_PEXTRW, 3, {MEMORY|BITS16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4277, 173},
+    {I_PEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4276, 174},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PINSRW[] = {
+    {I_PINSRW, 3, {MMXREG,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34082, 142},
+    {I_PINSRW, 3, {MMXREG,RM_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34082, 142},
+    {I_PINSRW, 3, {MMXREG,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34082, 142},
+    {I_PINSRW, 3, {XMM_L16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    {I_PINSRW, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    {I_PINSRW, 3, {XMM_L16,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 153},
+    {I_PINSRW, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    {I_PINSRW, 3, {XMM_L16,MEMORY|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAXSW[] = {
+    {I_PMAXSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34089, 141},
+    {I_PMAXSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45141, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAXUB[] = {
+    {I_PMAXUB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34096, 141},
+    {I_PMAXUB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45147, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMINSW[] = {
+    {I_PMINSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34103, 141},
+    {I_PMINSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45153, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMINUB[] = {
+    {I_PMINUB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34110, 141},
+    {I_PMINUB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45159, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVMSKB[] = {
+    {I_PMOVMSKB, 2, {REG_GPR|BITS32,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44925, 140},
+    {I_PMOVMSKB, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45165, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULHUW[] = {
+    {I_PMULHUW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34117, 141},
+    {I_PMULHUW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45171, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSADBW[] = {
+    {I_PSADBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34124, 141},
+    {I_PSADBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45201, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSHUFW[] = {
+    {I_PSHUFW, 3, {MMXREG,RM_MMX,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12656, 143},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PF2IW[] = {
+    {I_PF2IW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12664, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFNACC[] = {
+    {I_PFNACC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12672, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFPNACC[] = {
+    {I_PFPNACC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12680, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PI2FW[] = {
+    {I_PI2FW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12688, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSWAPD[] = {
+    {I_PSWAPD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12696, 91},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MASKMOVDQU[] = {
+    {I_MASKMOVDQU, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44931, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLFLUSH[] = {
+    {I_CLFLUSH, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44937, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTDQ[] = {
+    {I_MOVNTDQ, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44943, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTI[] = {
+    {I_MOVNTI, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34132, 146},
+    {I_MOVNTI, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34131, 147},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTPD[] = {
+    {I_MOVNTPD, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44949, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVDQA[] = {
+    {I_MOVDQA, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44955, 145},
+    {I_MOVDQA, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44961, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVDQU[] = {
+    {I_MOVDQU, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44967, 145},
+    {I_MOVDQU, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44973, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVDQ2Q[] = {
+    {I_MOVDQ2Q, 2, {MMXREG,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44979, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVQ2DQ[] = {
+    {I_MOVQ2DQ, 2, {XMM_L16,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44997, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PADDQ[] = {
+    {I_PADDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+45039, 151},
+    {I_PADDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45045, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULUDQ[] = {
+    {I_PMULUDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34180, 145},
+    {I_PMULUDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45189, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSHUFD[] = {
+    {I_PSHUFD, 3, {XMM_L16,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34187, 152},
+    {I_PSHUFD, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34187, 154},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSHUFHW[] = {
+    {I_PSHUFHW, 3, {XMM_L16,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34194, 152},
+    {I_PSHUFHW, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34194, 154},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSHUFLW[] = {
+    {I_PSHUFLW, 3, {XMM_L16,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34201, 152},
+    {I_PSHUFLW, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34201, 154},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSLLDQ[] = {
+    {I_PSLLDQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34208, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSRLDQ[] = {
+    {I_PSRLDQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34250, 155},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSUBQ[] = {
+    {I_PSUBQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34278, 145},
+    {I_PSUBQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45273, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKHQDQ[] = {
+    {I_PUNPCKHQDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45321, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PUNPCKLQDQ[] = {
+    {I_PUNPCKLQDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45345, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADDPD[] = {
+    {I_ADDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45357, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADDSD[] = {
+    {I_ADDSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45363, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ANDNPD[] = {
+    {I_ANDNPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45369, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ANDPD[] = {
+    {I_ANDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45375, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPEQPD[] = {
+    {I_CMPEQPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12704, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPEQSD[] = {
+    {I_CMPEQSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12712, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLEPD[] = {
+    {I_CMPLEPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12720, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLESD[] = {
+    {I_CMPLESD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12728, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLTPD[] = {
+    {I_CMPLTPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12736, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLTSD[] = {
+    {I_CMPLTSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12744, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNEQPD[] = {
+    {I_CMPNEQPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12752, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNEQSD[] = {
+    {I_CMPNEQSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12760, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLEPD[] = {
+    {I_CMPNLEPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12768, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLESD[] = {
+    {I_CMPNLESD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12776, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLTPD[] = {
+    {I_CMPNLTPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12784, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLTSD[] = {
+    {I_CMPNLTSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12792, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPORDPD[] = {
+    {I_CMPORDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12800, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPORDSD[] = {
+    {I_CMPORDSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12808, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPUNORDPD[] = {
+    {I_CMPUNORDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12816, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPUNORDSD[] = {
+    {I_CMPUNORDSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12824, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPPD[] = {
+    {I_CMPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+34285, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_COMISD[] = {
+    {I_COMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45381, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTDQ2PD[] = {
+    {I_CVTDQ2PD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45387, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTDQ2PS[] = {
+    {I_CVTDQ2PS, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45393, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPD2DQ[] = {
+    {I_CVTPD2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45399, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPD2PI[] = {
+    {I_CVTPD2PI, 2, {MMXREG,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45405, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPD2PS[] = {
+    {I_CVTPD2PS, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45411, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPI2PD[] = {
+    {I_CVTPI2PD, 2, {XMM_L16,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+45417, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPS2DQ[] = {
+    {I_CVTPS2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45423, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTPS2PD[] = {
+    {I_CVTPS2PD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45429, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTSD2SI[] = {
+    {I_CVTSD2SI, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34299, 156},
+    {I_CVTSD2SI, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34299, 156},
+    {I_CVTSD2SI, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34306, 157},
+    {I_CVTSD2SI, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34306, 157},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTSD2SS[] = {
+    {I_CVTSD2SS, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45435, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTSI2SD[] = {
+    {I_CVTSI2SD, 2, {XMM_L16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34321, 158},
+    {I_CVTSI2SD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34313, 158},
+    {I_CVTSI2SD, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34320, 157},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTSS2SD[] = {
+    {I_CVTSS2SD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45441, 148},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTTPD2PI[] = {
+    {I_CVTTPD2PI, 2, {MMXREG,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45447, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTTPD2DQ[] = {
+    {I_CVTTPD2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45453, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTTPS2DQ[] = {
+    {I_CVTTPS2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45459, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CVTTSD2SI[] = {
+    {I_CVTTSD2SI, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34327, 156},
+    {I_CVTTSD2SI, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34327, 156},
+    {I_CVTTSD2SI, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34334, 157},
+    {I_CVTTSD2SI, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34334, 157},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DIVPD[] = {
+    {I_DIVPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45465, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DIVSD[] = {
+    {I_DIVSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45471, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MAXPD[] = {
+    {I_MAXPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45477, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MAXSD[] = {
+    {I_MAXSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45483, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MINPD[] = {
+    {I_MINPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45489, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MINSD[] = {
+    {I_MINSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45495, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVAPD[] = {
+    {I_MOVAPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45501, 144},
+    {I_MOVAPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45507, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVHPD[] = {
+    {I_MOVHPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45513, 144},
+    {I_MOVHPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45519, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVLPD[] = {
+    {I_MOVLPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45525, 144},
+    {I_MOVLPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45531, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVMSKPD[] = {
+    {I_MOVMSKPD, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45537, 144},
+    {I_MOVMSKPD, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34341, 150},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVUPD[] = {
+    {I_MOVUPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45555, 144},
+    {I_MOVUPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45561, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MULPD[] = {
+    {I_MULPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45567, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MULSD[] = {
+    {I_MULSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45573, 149},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ORPD[] = {
+    {I_ORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45579, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHUFPD[] = {
+    {I_SHUFPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+34348, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SQRTPD[] = {
+    {I_SQRTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45585, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SQRTSD[] = {
+    {I_SQRTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45591, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SUBPD[] = {
+    {I_SUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45597, 145},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SUBSD[] = {
+    {I_SUBSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45603, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UCOMISD[] = {
+    {I_UCOMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45609, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UNPCKHPD[] = {
+    {I_UNPCKHPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45615, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UNPCKLPD[] = {
+    {I_UNPCKLPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45621, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XORPD[] = {
+    {I_XORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45627, 144},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADDSUBPD[] = {
+    {I_ADDSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45633, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADDSUBPS[] = {
+    {I_ADDSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45639, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HADDPD[] = {
+    {I_HADDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45645, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HADDPS[] = {
+    {I_HADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45651, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HSUBPD[] = {
+    {I_HSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45657, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HSUBPS[] = {
+    {I_HSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45663, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LDDQU[] = {
+    {I_LDDQU, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45669, 159},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVDDUP[] = {
+    {I_MOVDDUP, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45675, 160},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSHDUP[] = {
+    {I_MOVSHDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45681, 161},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVSLDUP[] = {
+    {I_MOVSLDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45687, 161},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLGI[] = {
+    {I_CLGI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49097, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STGI[] = {
+    {I_STGI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49102, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMCALL[] = {
+    {I_VMCALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45730, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMCLEAR[] = {
+    {I_VMCLEAR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45693, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMFUNC[] = {
+    {I_VMFUNC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49107, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMLAUNCH[] = {
+    {I_VMLAUNCH, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49112, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMLOAD[] = {
+    {I_VMLOAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49117, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMMCALL[] = {
+    {I_VMMCALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49122, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMPTRLD[] = {
+    {I_VMPTRLD, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45699, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMPTRST[] = {
+    {I_VMPTRST, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45705, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMREAD[] = {
+    {I_VMREAD, 2, {RM_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34356, 164},
+    {I_VMREAD, 2, {RM_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34355, 165},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMRESUME[] = {
+    {I_VMRESUME, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49127, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMRUN[] = {
+    {I_VMRUN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49132, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMSAVE[] = {
+    {I_VMSAVE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49137, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMWRITE[] = {
+    {I_VMWRITE, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34363, 164},
+    {I_VMWRITE, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34362, 165},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMXOFF[] = {
+    {I_VMXOFF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49142, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMXON[] = {
+    {I_VMXON, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42511, 163},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INVEPT[] = {
+    {I_INVEPT, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12833, 166},
+    {I_INVEPT, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12832, 167},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INVVPID[] = {
+    {I_INVVPID, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12841, 166},
+    {I_INVVPID, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12840, 167},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PVALIDATE[] = {
+    {I_PVALIDATE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45711, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RMPADJUST[] = {
+    {I_RMPADJUST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45717, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMGEXIT[] = {
+    {I_VMGEXIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45723, 162},
+    {I_VMGEXIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45729, 162},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PABSB[] = {
+    {I_PABSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34369, 168},
+    {I_PABSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34376, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PABSW[] = {
+    {I_PABSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34383, 168},
+    {I_PABSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34390, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PABSD[] = {
+    {I_PABSD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34397, 168},
+    {I_PABSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34404, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PALIGNR[] = {
+    {I_PALIGNR, 3, {MMXREG,RM_MMX,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12848, 168},
+    {I_PALIGNR, 3, {XMM_L16,RM_XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12856, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHADDW[] = {
+    {I_PHADDW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34411, 168},
+    {I_PHADDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34418, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHADDD[] = {
+    {I_PHADDD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34425, 168},
+    {I_PHADDD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34432, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHADDSW[] = {
+    {I_PHADDSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34439, 168},
+    {I_PHADDSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34446, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHSUBW[] = {
+    {I_PHSUBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34453, 168},
+    {I_PHSUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34460, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHSUBD[] = {
+    {I_PHSUBD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34467, 168},
+    {I_PHSUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34474, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHSUBSW[] = {
+    {I_PHSUBSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34481, 168},
+    {I_PHSUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34488, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMADDUBSW[] = {
+    {I_PMADDUBSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34495, 168},
+    {I_PMADDUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34502, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULHRSW[] = {
+    {I_PMULHRSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34509, 168},
+    {I_PMULHRSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34516, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSHUFB[] = {
+    {I_PSHUFB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34523, 168},
+    {I_PSHUFB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34530, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSIGNB[] = {
+    {I_PSIGNB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34537, 168},
+    {I_PSIGNB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34544, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSIGNW[] = {
+    {I_PSIGNW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34551, 168},
+    {I_PSIGNW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34558, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PSIGND[] = {
+    {I_PSIGND, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34565, 168},
+    {I_PSIGND, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34572, 169},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_EXTRQ[] = {
+    {I_EXTRQ, 3, {XMM_L16,IMMEDIATE,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12864, 170},
+    {I_EXTRQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45735, 170},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INSERTQ[] = {
+    {I_INSERTQ, 4, {XMM_L16,XMM_L16,IMMEDIATE,IMMEDIATE,0}, NO_DECORATOR, nasm_bytecodes+12872, 170},
+    {I_INSERTQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45741, 170},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTSD[] = {
+    {I_MOVNTSD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45747, 171},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTSS[] = {
+    {I_MOVNTSS, 2, {MEMORY|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45753, 172},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LZCNT[] = {
+    {I_LZCNT, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34579, 113},
+    {I_LZCNT, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34586, 113},
+    {I_LZCNT, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34593, 59},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLENDPD[] = {
+    {I_BLENDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12880, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLENDPS[] = {
+    {I_BLENDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12888, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLENDVPD[] = {
+    {I_BLENDVPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+34600, 173},
+    {I_BLENDVPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34600, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLENDVPS[] = {
+    {I_BLENDVPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+34607, 173},
+    {I_BLENDVPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34607, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DPPD[] = {
+    {I_DPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12896, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_DPPS[] = {
+    {I_DPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12904, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_EXTRACTPS[] = {
+    {I_EXTRACTPS, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4241, 173},
+    {I_EXTRACTPS, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4240, 174},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INSERTPS[] = {
+    {I_INSERTPS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12912, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVNTDQA[] = {
+    {I_MOVNTDQA, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34614, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MPSADBW[] = {
+    {I_MPSADBW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12920, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PACKUSDW[] = {
+    {I_PACKUSDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34621, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PBLENDVB[] = {
+    {I_PBLENDVB, 3, {XMM_L16,RM_XMM_L16,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+34628, 173},
+    {I_PBLENDVB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34628, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PBLENDW[] = {
+    {I_PBLENDW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12928, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPEQQ[] = {
+    {I_PCMPEQQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34635, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PEXTRB[] = {
+    {I_PEXTRB, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4250, 173},
+    {I_PEXTRB, 3, {MEMORY|BITS8,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4250, 173},
+    {I_PEXTRB, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4249, 174},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PEXTRD[] = {
+    {I_PEXTRD, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4258, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PEXTRQ[] = {
+    {I_PEXTRQ, 3, {RM_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4267, 174},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PHMINPOSUW[] = {
+    {I_PHMINPOSUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34642, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PINSRB[] = {
+    {I_PINSRB, 3, {XMM_L16,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4286, 175},
+    {I_PINSRB, 3, {XMM_L16,RM_GPR|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4285, 175},
+    {I_PINSRB, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4286, 175},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PINSRD[] = {
+    {I_PINSRD, 3, {XMM_L16,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4294, 175},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PINSRQ[] = {
+    {I_PINSRQ, 3, {XMM_L16,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4303, 176},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAXSB[] = {
+    {I_PMAXSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34649, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAXSD[] = {
+    {I_PMAXSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34656, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAXUD[] = {
+    {I_PMAXUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34663, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMAXUW[] = {
+    {I_PMAXUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34670, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMINSB[] = {
+    {I_PMINSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34677, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMINSD[] = {
+    {I_PMINSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34684, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMINUD[] = {
+    {I_PMINUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34691, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMINUW[] = {
+    {I_PMINUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34698, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVSXBW[] = {
+    {I_PMOVSXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34705, 177},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVSXBD[] = {
+    {I_PMOVSXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34712, 178},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVSXBQ[] = {
+    {I_PMOVSXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34719, 179},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVSXWD[] = {
+    {I_PMOVSXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34726, 177},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVSXWQ[] = {
+    {I_PMOVSXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34733, 178},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVSXDQ[] = {
+    {I_PMOVSXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34740, 177},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVZXBW[] = {
+    {I_PMOVZXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34747, 177},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVZXBD[] = {
+    {I_PMOVZXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34754, 178},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVZXBQ[] = {
+    {I_PMOVZXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34761, 179},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVZXWD[] = {
+    {I_PMOVZXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34768, 177},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVZXWQ[] = {
+    {I_PMOVZXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34775, 178},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMOVZXDQ[] = {
+    {I_PMOVZXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34782, 177},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULDQ[] = {
+    {I_PMULDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34789, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PMULLD[] = {
+    {I_PMULLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34796, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PTEST[] = {
+    {I_PTEST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34803, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ROUNDPD[] = {
+    {I_ROUNDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12936, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ROUNDPS[] = {
+    {I_ROUNDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12944, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ROUNDSD[] = {
+    {I_ROUNDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12952, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ROUNDSS[] = {
+    {I_ROUNDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12960, 173},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CRC32[] = {
+    {I_CRC32, 2, {REG_GPR|BITS32,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12985, 180},
+    {I_CRC32, 2, {REG_GPR|BITS32,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12968, 180},
+    {I_CRC32, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12976, 180},
+    {I_CRC32, 2, {REG_GPR|BITS64,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12984, 181},
+    {I_CRC32, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+12992, 181},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPESTRI[] = {
+    {I_PCMPESTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13000, 180},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPESTRM[] = {
+    {I_PCMPESTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13008, 180},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPISTRI[] = {
+    {I_PCMPISTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13016, 180},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPISTRM[] = {
+    {I_PCMPISTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13024, 180},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCMPGTQ[] = {
+    {I_PCMPGTQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34810, 180},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_POPCNT[] = {
+    {I_POPCNT, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34817, 182},
+    {I_POPCNT, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34824, 183},
+    {I_POPCNT, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34831, 184},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_GETSEC[] = {
+    {I_GETSEC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50183, 139},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRCPV[] = {
+    {I_PFRCPV, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+13032, 185},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PFRSQRTV[] = {
+    {I_PFRSQRTV, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+13040, 185},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVBE[] = {
+    {I_MOVBE, 2, {REG_GPR|BITS16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+13048, 186},
+    {I_MOVBE, 2, {REG_GPR|BITS32,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+13056, 186},
+    {I_MOVBE, 2, {REG_GPR|BITS64,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+13064, 186},
+    {I_MOVBE, 2, {MEMORY|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+13072, 186},
+    {I_MOVBE, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+13080, 186},
+    {I_MOVBE, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+13088, 186},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AESENC[] = {
+    {I_AESENC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34838, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AESENCLAST[] = {
+    {I_AESENCLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34845, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AESDEC[] = {
+    {I_AESDEC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34852, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AESDECLAST[] = {
+    {I_AESDECLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34859, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AESIMC[] = {
+    {I_AESIMC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34866, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AESKEYGENASSIST[] = {
+    {I_AESKEYGENASSIST, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13096, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VAESENC[] = {
+    {I_VAESENC, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34873, 188},
+    {I_VAESENC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34880, 188},
+    {I_VAESENC, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34936, 189},
+    {I_VAESENC, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34943, 189},
+    {I_VAESENC, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13112, 190},
+    {I_VAESENC, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13120, 190},
+    {I_VAESENC, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13128, 190},
+    {I_VAESENC, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13136, 190},
+    {I_VAESENC, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13240, 191},
+    {I_VAESENC, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13248, 191},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VAESENCLAST[] = {
+    {I_VAESENCLAST, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34887, 188},
+    {I_VAESENCLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34894, 188},
+    {I_VAESENCLAST, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34950, 189},
+    {I_VAESENCLAST, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34957, 189},
+    {I_VAESENCLAST, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13144, 190},
+    {I_VAESENCLAST, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13152, 190},
+    {I_VAESENCLAST, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13160, 190},
+    {I_VAESENCLAST, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13168, 190},
+    {I_VAESENCLAST, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13256, 191},
+    {I_VAESENCLAST, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13264, 191},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VAESDEC[] = {
+    {I_VAESDEC, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34901, 188},
+    {I_VAESDEC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34908, 188},
+    {I_VAESDEC, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34964, 189},
+    {I_VAESDEC, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34971, 189},
+    {I_VAESDEC, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13176, 190},
+    {I_VAESDEC, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13184, 190},
+    {I_VAESDEC, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13192, 190},
+    {I_VAESDEC, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13200, 190},
+    {I_VAESDEC, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13272, 191},
+    {I_VAESDEC, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13280, 191},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VAESDECLAST[] = {
+    {I_VAESDECLAST, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34915, 188},
+    {I_VAESDECLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34922, 188},
+    {I_VAESDECLAST, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34978, 189},
+    {I_VAESDECLAST, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34985, 189},
+    {I_VAESDECLAST, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13208, 190},
+    {I_VAESDECLAST, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13216, 190},
+    {I_VAESDECLAST, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13224, 190},
+    {I_VAESDECLAST, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13232, 190},
+    {I_VAESDECLAST, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13288, 191},
+    {I_VAESDECLAST, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13296, 191},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VAESIMC[] = {
+    {I_VAESIMC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34929, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VAESKEYGENASSIST[] = {
+    {I_VAESKEYGENASSIST, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13104, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDPD[] = {
+    {I_VADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34992, 188},
+    {I_VADDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34999, 188},
+    {I_VADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35006, 188},
+    {I_VADDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35013, 188},
+    {I_VADDPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16376, 240},
+    {I_VADDPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16384, 240},
+    {I_VADDPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16392, 240},
+    {I_VADDPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16400, 240},
+    {I_VADDPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+16408, 241},
+    {I_VADDPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+16416, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDPS[] = {
+    {I_VADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35020, 188},
+    {I_VADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35027, 188},
+    {I_VADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35034, 188},
+    {I_VADDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35041, 188},
+    {I_VADDPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16424, 240},
+    {I_VADDPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16432, 240},
+    {I_VADDPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16440, 240},
+    {I_VADDPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16448, 240},
+    {I_VADDPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+16456, 241},
+    {I_VADDPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+16464, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDSD[] = {
+    {I_VADDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35048, 188},
+    {I_VADDSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35055, 188},
+    {I_VADDSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+16472, 241},
+    {I_VADDSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+16480, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDSS[] = {
+    {I_VADDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35062, 188},
+    {I_VADDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35069, 188},
+    {I_VADDSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+16488, 241},
+    {I_VADDSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+16496, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDSUBPD[] = {
+    {I_VADDSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35076, 188},
+    {I_VADDSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35083, 188},
+    {I_VADDSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35090, 188},
+    {I_VADDSUBPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35097, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDSUBPS[] = {
+    {I_VADDSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35104, 188},
+    {I_VADDSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35111, 188},
+    {I_VADDSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35118, 188},
+    {I_VADDSUBPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35125, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VANDPD[] = {
+    {I_VANDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35132, 188},
+    {I_VANDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35139, 188},
+    {I_VANDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35146, 188},
+    {I_VANDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35153, 188},
+    {I_VANDPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16600, 242},
+    {I_VANDPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16608, 242},
+    {I_VANDPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16616, 242},
+    {I_VANDPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16624, 242},
+    {I_VANDPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16632, 243},
+    {I_VANDPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16640, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VANDPS[] = {
+    {I_VANDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35160, 188},
+    {I_VANDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35167, 188},
+    {I_VANDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35174, 188},
+    {I_VANDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35181, 188},
+    {I_VANDPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16648, 242},
+    {I_VANDPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16656, 242},
+    {I_VANDPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16664, 242},
+    {I_VANDPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16672, 242},
+    {I_VANDPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16680, 243},
+    {I_VANDPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16688, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VANDNPD[] = {
+    {I_VANDNPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35188, 188},
+    {I_VANDNPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35195, 188},
+    {I_VANDNPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35202, 188},
+    {I_VANDNPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35209, 188},
+    {I_VANDNPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16504, 242},
+    {I_VANDNPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16512, 242},
+    {I_VANDNPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16520, 242},
+    {I_VANDNPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16528, 242},
+    {I_VANDNPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16536, 243},
+    {I_VANDNPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16544, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VANDNPS[] = {
+    {I_VANDNPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35216, 188},
+    {I_VANDNPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35223, 188},
+    {I_VANDNPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35230, 188},
+    {I_VANDNPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35237, 188},
+    {I_VANDNPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16552, 242},
+    {I_VANDNPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16560, 242},
+    {I_VANDNPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16568, 242},
+    {I_VANDNPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16576, 242},
+    {I_VANDNPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16584, 243},
+    {I_VANDNPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16592, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBLENDPD[] = {
+    {I_VBLENDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13304, 188},
+    {I_VBLENDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13312, 188},
+    {I_VBLENDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13320, 188},
+    {I_VBLENDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13328, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBLENDPS[] = {
+    {I_VBLENDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13336, 188},
+    {I_VBLENDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13344, 188},
+    {I_VBLENDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13352, 188},
+    {I_VBLENDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13360, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBLENDVPD[] = {
+    {I_VBLENDVPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13368, 188},
+    {I_VBLENDVPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13376, 188},
+    {I_VBLENDVPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13384, 188},
+    {I_VBLENDVPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13392, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBLENDVPS[] = {
+    {I_VBLENDVPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13400, 188},
+    {I_VBLENDVPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13408, 188},
+    {I_VBLENDVPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13416, 188},
+    {I_VBLENDVPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13424, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTSS[] = {
+    {I_VBROADCASTSS, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35244, 188},
+    {I_VBROADCASTSS, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35251, 188},
+    {I_VBROADCASTSS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35244, 207},
+    {I_VBROADCASTSS, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35251, 207},
+    {I_VBROADCASTSS, 2, {XMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16912, 240},
+    {I_VBROADCASTSS, 2, {YMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16920, 240},
+    {I_VBROADCASTSS, 2, {ZMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16928, 241},
+    {I_VBROADCASTSS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16936, 240},
+    {I_VBROADCASTSS, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16944, 240},
+    {I_VBROADCASTSS, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16952, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTSD[] = {
+    {I_VBROADCASTSD, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35258, 188},
+    {I_VBROADCASTSD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35258, 207},
+    {I_VBROADCASTSD, 2, {YMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16880, 240},
+    {I_VBROADCASTSD, 2, {ZMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16888, 241},
+    {I_VBROADCASTSD, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16896, 240},
+    {I_VBROADCASTSD, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16904, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTF128[] = {
+    {I_VBROADCASTF128, 2, {YMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35265, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OSPD[] = {
+    {I_VCMPEQ_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4312, 188},
+    {I_VCMPEQ_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4321, 188},
+    {I_VCMPEQ_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4330, 188},
+    {I_VCMPEQ_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4339, 188},
+    {I_VCMPEQ_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4312, 188},
+    {I_VCMPEQ_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4321, 188},
+    {I_VCMPEQ_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4330, 188},
+    {I_VCMPEQ_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4339, 188},
+    {I_VCMPEQ_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1520, 240},
+    {I_VCMPEQ_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1530, 240},
+    {I_VCMPEQ_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1540, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQPD[] = {
+    {I_VCMPEQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4348, 188},
+    {I_VCMPEQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4357, 188},
+    {I_VCMPEQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4366, 188},
+    {I_VCMPEQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4375, 188},
+    {I_VCMPEQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+240, 240},
+    {I_VCMPEQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+250, 240},
+    {I_VCMPEQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+260, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OSPD[] = {
+    {I_VCMPLT_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4384, 188},
+    {I_VCMPLT_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4393, 188},
+    {I_VCMPLT_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4402, 188},
+    {I_VCMPLT_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4411, 188},
+    {I_VCMPLT_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+320, 240},
+    {I_VCMPLT_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+330, 240},
+    {I_VCMPLT_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+340, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLTPD[] = {
+    {I_VCMPLTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4384, 188},
+    {I_VCMPLTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4393, 188},
+    {I_VCMPLTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4402, 188},
+    {I_VCMPLTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4411, 188},
+    {I_VCMPLTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+320, 240},
+    {I_VCMPLTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+330, 240},
+    {I_VCMPLTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+340, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OSPD[] = {
+    {I_VCMPLE_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4420, 188},
+    {I_VCMPLE_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4429, 188},
+    {I_VCMPLE_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4438, 188},
+    {I_VCMPLE_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4447, 188},
+    {I_VCMPLE_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+400, 240},
+    {I_VCMPLE_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+410, 240},
+    {I_VCMPLE_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLEPD[] = {
+    {I_VCMPLEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4420, 188},
+    {I_VCMPLEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4429, 188},
+    {I_VCMPLEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4438, 188},
+    {I_VCMPLEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4447, 188},
+    {I_VCMPLEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+400, 240},
+    {I_VCMPLEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+410, 240},
+    {I_VCMPLEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_QPD[] = {
+    {I_VCMPUNORD_QPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4456, 188},
+    {I_VCMPUNORD_QPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4465, 188},
+    {I_VCMPUNORD_QPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4474, 188},
+    {I_VCMPUNORD_QPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4483, 188},
+    {I_VCMPUNORD_QPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+480, 240},
+    {I_VCMPUNORD_QPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+490, 240},
+    {I_VCMPUNORD_QPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+500, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORDPD[] = {
+    {I_VCMPUNORDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4456, 188},
+    {I_VCMPUNORDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4465, 188},
+    {I_VCMPUNORDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4474, 188},
+    {I_VCMPUNORDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4483, 188},
+    {I_VCMPUNORDPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+480, 240},
+    {I_VCMPUNORDPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+490, 240},
+    {I_VCMPUNORDPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+500, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_UQPD[] = {
+    {I_VCMPNEQ_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4492, 188},
+    {I_VCMPNEQ_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4501, 188},
+    {I_VCMPNEQ_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4510, 188},
+    {I_VCMPNEQ_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4519, 188},
+    {I_VCMPNEQ_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+560, 240},
+    {I_VCMPNEQ_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+570, 240},
+    {I_VCMPNEQ_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+580, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQPD[] = {
+    {I_VCMPNEQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4492, 188},
+    {I_VCMPNEQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4501, 188},
+    {I_VCMPNEQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4510, 188},
+    {I_VCMPNEQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4519, 188},
+    {I_VCMPNEQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+560, 240},
+    {I_VCMPNEQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+570, 240},
+    {I_VCMPNEQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+580, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_USPD[] = {
+    {I_VCMPNLT_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4528, 188},
+    {I_VCMPNLT_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4537, 188},
+    {I_VCMPNLT_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4546, 188},
+    {I_VCMPNLT_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4555, 188},
+    {I_VCMPNLT_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+640, 240},
+    {I_VCMPNLT_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+650, 240},
+    {I_VCMPNLT_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+660, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLTPD[] = {
+    {I_VCMPNLTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4528, 188},
+    {I_VCMPNLTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4537, 188},
+    {I_VCMPNLTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4546, 188},
+    {I_VCMPNLTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4555, 188},
+    {I_VCMPNLTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+640, 240},
+    {I_VCMPNLTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+650, 240},
+    {I_VCMPNLTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+660, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_USPD[] = {
+    {I_VCMPNLE_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4564, 188},
+    {I_VCMPNLE_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4573, 188},
+    {I_VCMPNLE_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4582, 188},
+    {I_VCMPNLE_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4591, 188},
+    {I_VCMPNLE_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+720, 240},
+    {I_VCMPNLE_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+730, 240},
+    {I_VCMPNLE_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+740, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLEPD[] = {
+    {I_VCMPNLEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4564, 188},
+    {I_VCMPNLEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4573, 188},
+    {I_VCMPNLEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4582, 188},
+    {I_VCMPNLEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4591, 188},
+    {I_VCMPNLEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+720, 240},
+    {I_VCMPNLEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+730, 240},
+    {I_VCMPNLEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+740, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_QPD[] = {
+    {I_VCMPORD_QPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4600, 188},
+    {I_VCMPORD_QPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4609, 188},
+    {I_VCMPORD_QPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4618, 188},
+    {I_VCMPORD_QPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4627, 188},
+    {I_VCMPORD_QPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+800, 240},
+    {I_VCMPORD_QPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+810, 240},
+    {I_VCMPORD_QPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+820, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORDPD[] = {
+    {I_VCMPORDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4600, 188},
+    {I_VCMPORDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4609, 188},
+    {I_VCMPORDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4618, 188},
+    {I_VCMPORDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4627, 188},
+    {I_VCMPORDPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+800, 240},
+    {I_VCMPORDPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+810, 240},
+    {I_VCMPORDPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+820, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_UQPD[] = {
+    {I_VCMPEQ_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4636, 188},
+    {I_VCMPEQ_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4645, 188},
+    {I_VCMPEQ_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4654, 188},
+    {I_VCMPEQ_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4663, 188},
+    {I_VCMPEQ_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+880, 240},
+    {I_VCMPEQ_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+890, 240},
+    {I_VCMPEQ_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+900, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_USPD[] = {
+    {I_VCMPNGE_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4672, 188},
+    {I_VCMPNGE_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4681, 188},
+    {I_VCMPNGE_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4690, 188},
+    {I_VCMPNGE_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4699, 188},
+    {I_VCMPNGE_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+960, 240},
+    {I_VCMPNGE_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+970, 240},
+    {I_VCMPNGE_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+980, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGEPD[] = {
+    {I_VCMPNGEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4672, 188},
+    {I_VCMPNGEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4681, 188},
+    {I_VCMPNGEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4690, 188},
+    {I_VCMPNGEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4699, 188},
+    {I_VCMPNGEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+960, 240},
+    {I_VCMPNGEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+970, 240},
+    {I_VCMPNGEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+980, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_USPD[] = {
+    {I_VCMPNGT_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4708, 188},
+    {I_VCMPNGT_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4717, 188},
+    {I_VCMPNGT_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4726, 188},
+    {I_VCMPNGT_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4735, 188},
+    {I_VCMPNGT_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1040, 240},
+    {I_VCMPNGT_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1050, 240},
+    {I_VCMPNGT_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1060, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGTPD[] = {
+    {I_VCMPNGTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4708, 188},
+    {I_VCMPNGTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4717, 188},
+    {I_VCMPNGTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4726, 188},
+    {I_VCMPNGTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4735, 188},
+    {I_VCMPNGTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1040, 240},
+    {I_VCMPNGTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1050, 240},
+    {I_VCMPNGTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1060, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OQPD[] = {
+    {I_VCMPFALSE_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4744, 188},
+    {I_VCMPFALSE_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4753, 188},
+    {I_VCMPFALSE_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4762, 188},
+    {I_VCMPFALSE_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4771, 188},
+    {I_VCMPFALSE_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1120, 240},
+    {I_VCMPFALSE_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1130, 240},
+    {I_VCMPFALSE_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1140, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSEPD[] = {
+    {I_VCMPFALSEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4744, 188},
+    {I_VCMPFALSEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4753, 188},
+    {I_VCMPFALSEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4762, 188},
+    {I_VCMPFALSEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4771, 188},
+    {I_VCMPFALSEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1120, 240},
+    {I_VCMPFALSEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1130, 240},
+    {I_VCMPFALSEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1140, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OQPD[] = {
+    {I_VCMPNEQ_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4780, 188},
+    {I_VCMPNEQ_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4789, 188},
+    {I_VCMPNEQ_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4798, 188},
+    {I_VCMPNEQ_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4807, 188},
+    {I_VCMPNEQ_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1200, 240},
+    {I_VCMPNEQ_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1210, 240},
+    {I_VCMPNEQ_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1220, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OSPD[] = {
+    {I_VCMPGE_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4816, 188},
+    {I_VCMPGE_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4825, 188},
+    {I_VCMPGE_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4834, 188},
+    {I_VCMPGE_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4843, 188},
+    {I_VCMPGE_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1280, 240},
+    {I_VCMPGE_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1290, 240},
+    {I_VCMPGE_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1300, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGEPD[] = {
+    {I_VCMPGEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4816, 188},
+    {I_VCMPGEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4825, 188},
+    {I_VCMPGEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4834, 188},
+    {I_VCMPGEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4843, 188},
+    {I_VCMPGEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1280, 240},
+    {I_VCMPGEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1290, 240},
+    {I_VCMPGEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1300, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OSPD[] = {
+    {I_VCMPGT_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4852, 188},
+    {I_VCMPGT_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4861, 188},
+    {I_VCMPGT_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4870, 188},
+    {I_VCMPGT_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4879, 188},
+    {I_VCMPGT_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1360, 240},
+    {I_VCMPGT_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1370, 240},
+    {I_VCMPGT_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1380, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGTPD[] = {
+    {I_VCMPGTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4852, 188},
+    {I_VCMPGTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4861, 188},
+    {I_VCMPGTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4870, 188},
+    {I_VCMPGTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4879, 188},
+    {I_VCMPGTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1360, 240},
+    {I_VCMPGTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1370, 240},
+    {I_VCMPGTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1380, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_UQPD[] = {
+    {I_VCMPTRUE_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4888, 188},
+    {I_VCMPTRUE_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4897, 188},
+    {I_VCMPTRUE_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4906, 188},
+    {I_VCMPTRUE_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4915, 188},
+    {I_VCMPTRUE_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1440, 240},
+    {I_VCMPTRUE_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1450, 240},
+    {I_VCMPTRUE_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1460, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUEPD[] = {
+    {I_VCMPTRUEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4888, 188},
+    {I_VCMPTRUEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4897, 188},
+    {I_VCMPTRUEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4906, 188},
+    {I_VCMPTRUEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4915, 188},
+    {I_VCMPTRUEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1440, 240},
+    {I_VCMPTRUEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1450, 240},
+    {I_VCMPTRUEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1460, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OQPD[] = {
+    {I_VCMPLT_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4924, 188},
+    {I_VCMPLT_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4933, 188},
+    {I_VCMPLT_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4942, 188},
+    {I_VCMPLT_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4951, 188},
+    {I_VCMPLT_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1600, 240},
+    {I_VCMPLT_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1610, 240},
+    {I_VCMPLT_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1620, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OQPD[] = {
+    {I_VCMPLE_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4960, 188},
+    {I_VCMPLE_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4969, 188},
+    {I_VCMPLE_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4978, 188},
+    {I_VCMPLE_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4987, 188},
+    {I_VCMPLE_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1680, 240},
+    {I_VCMPLE_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1690, 240},
+    {I_VCMPLE_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1700, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_SPD[] = {
+    {I_VCMPUNORD_SPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4996, 188},
+    {I_VCMPUNORD_SPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5005, 188},
+    {I_VCMPUNORD_SPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5014, 188},
+    {I_VCMPUNORD_SPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5023, 188},
+    {I_VCMPUNORD_SPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1760, 240},
+    {I_VCMPUNORD_SPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1770, 240},
+    {I_VCMPUNORD_SPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1780, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_USPD[] = {
+    {I_VCMPNEQ_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5032, 188},
+    {I_VCMPNEQ_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5041, 188},
+    {I_VCMPNEQ_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5050, 188},
+    {I_VCMPNEQ_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5059, 188},
+    {I_VCMPNEQ_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1840, 240},
+    {I_VCMPNEQ_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1850, 240},
+    {I_VCMPNEQ_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1860, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_UQPD[] = {
+    {I_VCMPNLT_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5068, 188},
+    {I_VCMPNLT_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5077, 188},
+    {I_VCMPNLT_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5086, 188},
+    {I_VCMPNLT_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5095, 188},
+    {I_VCMPNLT_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1920, 240},
+    {I_VCMPNLT_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1930, 240},
+    {I_VCMPNLT_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1940, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_UQPD[] = {
+    {I_VCMPNLE_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5104, 188},
+    {I_VCMPNLE_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5113, 188},
+    {I_VCMPNLE_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5122, 188},
+    {I_VCMPNLE_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5131, 188},
+    {I_VCMPNLE_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2000, 240},
+    {I_VCMPNLE_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2010, 240},
+    {I_VCMPNLE_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2020, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_SPD[] = {
+    {I_VCMPORD_SPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5140, 188},
+    {I_VCMPORD_SPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5149, 188},
+    {I_VCMPORD_SPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5158, 188},
+    {I_VCMPORD_SPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5167, 188},
+    {I_VCMPORD_SPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2080, 240},
+    {I_VCMPORD_SPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2090, 240},
+    {I_VCMPORD_SPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2100, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_USPD[] = {
+    {I_VCMPEQ_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5176, 188},
+    {I_VCMPEQ_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5185, 188},
+    {I_VCMPEQ_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5194, 188},
+    {I_VCMPEQ_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5203, 188},
+    {I_VCMPEQ_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2160, 240},
+    {I_VCMPEQ_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2170, 240},
+    {I_VCMPEQ_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2180, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_UQPD[] = {
+    {I_VCMPNGE_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5212, 188},
+    {I_VCMPNGE_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5221, 188},
+    {I_VCMPNGE_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5230, 188},
+    {I_VCMPNGE_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5239, 188},
+    {I_VCMPNGE_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2240, 240},
+    {I_VCMPNGE_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2250, 240},
+    {I_VCMPNGE_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2260, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_UQPD[] = {
+    {I_VCMPNGT_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5248, 188},
+    {I_VCMPNGT_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5257, 188},
+    {I_VCMPNGT_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5266, 188},
+    {I_VCMPNGT_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5275, 188},
+    {I_VCMPNGT_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2320, 240},
+    {I_VCMPNGT_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2330, 240},
+    {I_VCMPNGT_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2340, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OSPD[] = {
+    {I_VCMPFALSE_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5284, 188},
+    {I_VCMPFALSE_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5293, 188},
+    {I_VCMPFALSE_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5302, 188},
+    {I_VCMPFALSE_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5311, 188},
+    {I_VCMPFALSE_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2400, 240},
+    {I_VCMPFALSE_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2410, 240},
+    {I_VCMPFALSE_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OSPD[] = {
+    {I_VCMPNEQ_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5320, 188},
+    {I_VCMPNEQ_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5329, 188},
+    {I_VCMPNEQ_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5338, 188},
+    {I_VCMPNEQ_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5347, 188},
+    {I_VCMPNEQ_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2480, 240},
+    {I_VCMPNEQ_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2490, 240},
+    {I_VCMPNEQ_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2500, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OQPD[] = {
+    {I_VCMPGE_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5356, 188},
+    {I_VCMPGE_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5365, 188},
+    {I_VCMPGE_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5374, 188},
+    {I_VCMPGE_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5383, 188},
+    {I_VCMPGE_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2560, 240},
+    {I_VCMPGE_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2570, 240},
+    {I_VCMPGE_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2580, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OQPD[] = {
+    {I_VCMPGT_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5392, 188},
+    {I_VCMPGT_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5401, 188},
+    {I_VCMPGT_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5410, 188},
+    {I_VCMPGT_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5419, 188},
+    {I_VCMPGT_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2640, 240},
+    {I_VCMPGT_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2650, 240},
+    {I_VCMPGT_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2660, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_USPD[] = {
+    {I_VCMPTRUE_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5428, 188},
+    {I_VCMPTRUE_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5437, 188},
+    {I_VCMPTRUE_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5446, 188},
+    {I_VCMPTRUE_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5455, 188},
+    {I_VCMPTRUE_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2720, 240},
+    {I_VCMPTRUE_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2730, 240},
+    {I_VCMPTRUE_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2740, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPPD[] = {
+    {I_VCMPPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13432, 188},
+    {I_VCMPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13440, 188},
+    {I_VCMPPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13448, 188},
+    {I_VCMPPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13456, 188},
+    {I_VCMPPD, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+8110, 240},
+    {I_VCMPPD, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+8119, 240},
+    {I_VCMPPD, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+8128, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OSPS[] = {
+    {I_VCMPEQ_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5464, 188},
+    {I_VCMPEQ_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5473, 188},
+    {I_VCMPEQ_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5482, 188},
+    {I_VCMPEQ_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5491, 188},
+    {I_VCMPEQ_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5464, 188},
+    {I_VCMPEQ_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5473, 188},
+    {I_VCMPEQ_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5482, 188},
+    {I_VCMPEQ_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5491, 188},
+    {I_VCMPEQ_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1550, 240},
+    {I_VCMPEQ_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1560, 240},
+    {I_VCMPEQ_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1570, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQPS[] = {
+    {I_VCMPEQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5500, 188},
+    {I_VCMPEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5509, 188},
+    {I_VCMPEQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5518, 188},
+    {I_VCMPEQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5527, 188},
+    {I_VCMPEQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+270, 240},
+    {I_VCMPEQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+280, 240},
+    {I_VCMPEQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+290, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OSPS[] = {
+    {I_VCMPLT_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5536, 188},
+    {I_VCMPLT_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5545, 188},
+    {I_VCMPLT_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5554, 188},
+    {I_VCMPLT_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5563, 188},
+    {I_VCMPLT_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+350, 240},
+    {I_VCMPLT_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+360, 240},
+    {I_VCMPLT_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+370, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLTPS[] = {
+    {I_VCMPLTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5536, 188},
+    {I_VCMPLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5545, 188},
+    {I_VCMPLTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5554, 188},
+    {I_VCMPLTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5563, 188},
+    {I_VCMPLTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+350, 240},
+    {I_VCMPLTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+360, 240},
+    {I_VCMPLTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+370, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OSPS[] = {
+    {I_VCMPLE_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5572, 188},
+    {I_VCMPLE_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5581, 188},
+    {I_VCMPLE_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5590, 188},
+    {I_VCMPLE_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5599, 188},
+    {I_VCMPLE_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+430, 240},
+    {I_VCMPLE_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+440, 240},
+    {I_VCMPLE_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+450, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLEPS[] = {
+    {I_VCMPLEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5572, 188},
+    {I_VCMPLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5581, 188},
+    {I_VCMPLEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5590, 188},
+    {I_VCMPLEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5599, 188},
+    {I_VCMPLEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+430, 240},
+    {I_VCMPLEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+440, 240},
+    {I_VCMPLEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+450, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_QPS[] = {
+    {I_VCMPUNORD_QPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5608, 188},
+    {I_VCMPUNORD_QPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5617, 188},
+    {I_VCMPUNORD_QPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5626, 188},
+    {I_VCMPUNORD_QPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5635, 188},
+    {I_VCMPUNORD_QPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+510, 240},
+    {I_VCMPUNORD_QPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+520, 240},
+    {I_VCMPUNORD_QPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+530, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORDPS[] = {
+    {I_VCMPUNORDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5608, 188},
+    {I_VCMPUNORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5617, 188},
+    {I_VCMPUNORDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5626, 188},
+    {I_VCMPUNORDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5635, 188},
+    {I_VCMPUNORDPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+510, 240},
+    {I_VCMPUNORDPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+520, 240},
+    {I_VCMPUNORDPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+530, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_UQPS[] = {
+    {I_VCMPNEQ_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5644, 188},
+    {I_VCMPNEQ_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5653, 188},
+    {I_VCMPNEQ_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5662, 188},
+    {I_VCMPNEQ_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5671, 188},
+    {I_VCMPNEQ_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+590, 240},
+    {I_VCMPNEQ_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+600, 240},
+    {I_VCMPNEQ_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+610, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQPS[] = {
+    {I_VCMPNEQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5644, 188},
+    {I_VCMPNEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5653, 188},
+    {I_VCMPNEQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5662, 188},
+    {I_VCMPNEQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5671, 188},
+    {I_VCMPNEQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+590, 240},
+    {I_VCMPNEQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+600, 240},
+    {I_VCMPNEQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+610, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_USPS[] = {
+    {I_VCMPNLT_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5680, 188},
+    {I_VCMPNLT_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5689, 188},
+    {I_VCMPNLT_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5698, 188},
+    {I_VCMPNLT_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5707, 188},
+    {I_VCMPNLT_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+670, 240},
+    {I_VCMPNLT_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+680, 240},
+    {I_VCMPNLT_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+690, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLTPS[] = {
+    {I_VCMPNLTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5680, 188},
+    {I_VCMPNLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5689, 188},
+    {I_VCMPNLTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5698, 188},
+    {I_VCMPNLTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5707, 188},
+    {I_VCMPNLTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+670, 240},
+    {I_VCMPNLTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+680, 240},
+    {I_VCMPNLTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+690, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_USPS[] = {
+    {I_VCMPNLE_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5716, 188},
+    {I_VCMPNLE_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5725, 188},
+    {I_VCMPNLE_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5734, 188},
+    {I_VCMPNLE_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5743, 188},
+    {I_VCMPNLE_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+750, 240},
+    {I_VCMPNLE_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+760, 240},
+    {I_VCMPNLE_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+770, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLEPS[] = {
+    {I_VCMPNLEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5716, 188},
+    {I_VCMPNLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5725, 188},
+    {I_VCMPNLEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5734, 188},
+    {I_VCMPNLEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5743, 188},
+    {I_VCMPNLEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+750, 240},
+    {I_VCMPNLEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+760, 240},
+    {I_VCMPNLEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+770, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_QPS[] = {
+    {I_VCMPORD_QPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5752, 188},
+    {I_VCMPORD_QPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5761, 188},
+    {I_VCMPORD_QPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5770, 188},
+    {I_VCMPORD_QPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5779, 188},
+    {I_VCMPORD_QPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+830, 240},
+    {I_VCMPORD_QPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+840, 240},
+    {I_VCMPORD_QPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+850, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORDPS[] = {
+    {I_VCMPORDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5752, 188},
+    {I_VCMPORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5761, 188},
+    {I_VCMPORDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5770, 188},
+    {I_VCMPORDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5779, 188},
+    {I_VCMPORDPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+830, 240},
+    {I_VCMPORDPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+840, 240},
+    {I_VCMPORDPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+850, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_UQPS[] = {
+    {I_VCMPEQ_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5788, 188},
+    {I_VCMPEQ_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5797, 188},
+    {I_VCMPEQ_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5806, 188},
+    {I_VCMPEQ_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5815, 188},
+    {I_VCMPEQ_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+910, 240},
+    {I_VCMPEQ_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+920, 240},
+    {I_VCMPEQ_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+930, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_USPS[] = {
+    {I_VCMPNGE_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5824, 188},
+    {I_VCMPNGE_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5833, 188},
+    {I_VCMPNGE_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5842, 188},
+    {I_VCMPNGE_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5851, 188},
+    {I_VCMPNGE_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+990, 240},
+    {I_VCMPNGE_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1000, 240},
+    {I_VCMPNGE_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1010, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGEPS[] = {
+    {I_VCMPNGEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5824, 188},
+    {I_VCMPNGEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5833, 188},
+    {I_VCMPNGEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5842, 188},
+    {I_VCMPNGEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5851, 188},
+    {I_VCMPNGEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+990, 240},
+    {I_VCMPNGEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1000, 240},
+    {I_VCMPNGEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1010, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_USPS[] = {
+    {I_VCMPNGT_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5860, 188},
+    {I_VCMPNGT_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5869, 188},
+    {I_VCMPNGT_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5878, 188},
+    {I_VCMPNGT_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5887, 188},
+    {I_VCMPNGT_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1070, 240},
+    {I_VCMPNGT_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1080, 240},
+    {I_VCMPNGT_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1090, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGTPS[] = {
+    {I_VCMPNGTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5860, 188},
+    {I_VCMPNGTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5869, 188},
+    {I_VCMPNGTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5878, 188},
+    {I_VCMPNGTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5887, 188},
+    {I_VCMPNGTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1070, 240},
+    {I_VCMPNGTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1080, 240},
+    {I_VCMPNGTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1090, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OQPS[] = {
+    {I_VCMPFALSE_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5896, 188},
+    {I_VCMPFALSE_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5905, 188},
+    {I_VCMPFALSE_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5914, 188},
+    {I_VCMPFALSE_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5923, 188},
+    {I_VCMPFALSE_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1150, 240},
+    {I_VCMPFALSE_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1160, 240},
+    {I_VCMPFALSE_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1170, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSEPS[] = {
+    {I_VCMPFALSEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5896, 188},
+    {I_VCMPFALSEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5905, 188},
+    {I_VCMPFALSEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5914, 188},
+    {I_VCMPFALSEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5923, 188},
+    {I_VCMPFALSEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1150, 240},
+    {I_VCMPFALSEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1160, 240},
+    {I_VCMPFALSEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1170, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OQPS[] = {
+    {I_VCMPNEQ_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5932, 188},
+    {I_VCMPNEQ_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5941, 188},
+    {I_VCMPNEQ_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5950, 188},
+    {I_VCMPNEQ_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5959, 188},
+    {I_VCMPNEQ_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1230, 240},
+    {I_VCMPNEQ_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1240, 240},
+    {I_VCMPNEQ_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1250, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OSPS[] = {
+    {I_VCMPGE_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5968, 188},
+    {I_VCMPGE_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5977, 188},
+    {I_VCMPGE_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5986, 188},
+    {I_VCMPGE_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5995, 188},
+    {I_VCMPGE_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1310, 240},
+    {I_VCMPGE_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1320, 240},
+    {I_VCMPGE_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1330, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGEPS[] = {
+    {I_VCMPGEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5968, 188},
+    {I_VCMPGEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5977, 188},
+    {I_VCMPGEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5986, 188},
+    {I_VCMPGEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5995, 188},
+    {I_VCMPGEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1310, 240},
+    {I_VCMPGEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1320, 240},
+    {I_VCMPGEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1330, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OSPS[] = {
+    {I_VCMPGT_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6004, 188},
+    {I_VCMPGT_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6013, 188},
+    {I_VCMPGT_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6022, 188},
+    {I_VCMPGT_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6031, 188},
+    {I_VCMPGT_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1390, 240},
+    {I_VCMPGT_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1400, 240},
+    {I_VCMPGT_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1410, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGTPS[] = {
+    {I_VCMPGTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6004, 188},
+    {I_VCMPGTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6013, 188},
+    {I_VCMPGTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6022, 188},
+    {I_VCMPGTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6031, 188},
+    {I_VCMPGTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1390, 240},
+    {I_VCMPGTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1400, 240},
+    {I_VCMPGTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1410, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_UQPS[] = {
+    {I_VCMPTRUE_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6040, 188},
+    {I_VCMPTRUE_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6049, 188},
+    {I_VCMPTRUE_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6058, 188},
+    {I_VCMPTRUE_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6067, 188},
+    {I_VCMPTRUE_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1470, 240},
+    {I_VCMPTRUE_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1480, 240},
+    {I_VCMPTRUE_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1490, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUEPS[] = {
+    {I_VCMPTRUEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6040, 188},
+    {I_VCMPTRUEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6049, 188},
+    {I_VCMPTRUEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6058, 188},
+    {I_VCMPTRUEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6067, 188},
+    {I_VCMPTRUEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1470, 240},
+    {I_VCMPTRUEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1480, 240},
+    {I_VCMPTRUEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1490, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OQPS[] = {
+    {I_VCMPLT_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6076, 188},
+    {I_VCMPLT_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6085, 188},
+    {I_VCMPLT_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6094, 188},
+    {I_VCMPLT_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6103, 188},
+    {I_VCMPLT_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1630, 240},
+    {I_VCMPLT_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1640, 240},
+    {I_VCMPLT_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1650, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OQPS[] = {
+    {I_VCMPLE_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6112, 188},
+    {I_VCMPLE_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6121, 188},
+    {I_VCMPLE_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6130, 188},
+    {I_VCMPLE_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6139, 188},
+    {I_VCMPLE_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1710, 240},
+    {I_VCMPLE_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1720, 240},
+    {I_VCMPLE_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1730, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_SPS[] = {
+    {I_VCMPUNORD_SPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6148, 188},
+    {I_VCMPUNORD_SPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6157, 188},
+    {I_VCMPUNORD_SPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6166, 188},
+    {I_VCMPUNORD_SPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6175, 188},
+    {I_VCMPUNORD_SPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1790, 240},
+    {I_VCMPUNORD_SPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1800, 240},
+    {I_VCMPUNORD_SPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1810, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_USPS[] = {
+    {I_VCMPNEQ_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6184, 188},
+    {I_VCMPNEQ_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6193, 188},
+    {I_VCMPNEQ_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6202, 188},
+    {I_VCMPNEQ_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6211, 188},
+    {I_VCMPNEQ_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1870, 240},
+    {I_VCMPNEQ_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1880, 240},
+    {I_VCMPNEQ_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1890, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_UQPS[] = {
+    {I_VCMPNLT_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6220, 188},
+    {I_VCMPNLT_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6229, 188},
+    {I_VCMPNLT_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6238, 188},
+    {I_VCMPNLT_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6247, 188},
+    {I_VCMPNLT_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1950, 240},
+    {I_VCMPNLT_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1960, 240},
+    {I_VCMPNLT_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1970, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_UQPS[] = {
+    {I_VCMPNLE_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6256, 188},
+    {I_VCMPNLE_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6265, 188},
+    {I_VCMPNLE_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6274, 188},
+    {I_VCMPNLE_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6283, 188},
+    {I_VCMPNLE_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2030, 240},
+    {I_VCMPNLE_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2040, 240},
+    {I_VCMPNLE_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2050, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_SPS[] = {
+    {I_VCMPORD_SPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6292, 188},
+    {I_VCMPORD_SPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6301, 188},
+    {I_VCMPORD_SPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6310, 188},
+    {I_VCMPORD_SPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6319, 188},
+    {I_VCMPORD_SPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2110, 240},
+    {I_VCMPORD_SPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2120, 240},
+    {I_VCMPORD_SPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2130, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_USPS[] = {
+    {I_VCMPEQ_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6328, 188},
+    {I_VCMPEQ_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6337, 188},
+    {I_VCMPEQ_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6346, 188},
+    {I_VCMPEQ_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6355, 188},
+    {I_VCMPEQ_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2190, 240},
+    {I_VCMPEQ_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2200, 240},
+    {I_VCMPEQ_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2210, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_UQPS[] = {
+    {I_VCMPNGE_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6364, 188},
+    {I_VCMPNGE_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6373, 188},
+    {I_VCMPNGE_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6382, 188},
+    {I_VCMPNGE_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6391, 188},
+    {I_VCMPNGE_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2270, 240},
+    {I_VCMPNGE_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2280, 240},
+    {I_VCMPNGE_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2290, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_UQPS[] = {
+    {I_VCMPNGT_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6400, 188},
+    {I_VCMPNGT_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6409, 188},
+    {I_VCMPNGT_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6418, 188},
+    {I_VCMPNGT_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6427, 188},
+    {I_VCMPNGT_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2350, 240},
+    {I_VCMPNGT_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2360, 240},
+    {I_VCMPNGT_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2370, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OSPS[] = {
+    {I_VCMPFALSE_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6436, 188},
+    {I_VCMPFALSE_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6445, 188},
+    {I_VCMPFALSE_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6454, 188},
+    {I_VCMPFALSE_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6463, 188},
+    {I_VCMPFALSE_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2430, 240},
+    {I_VCMPFALSE_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2440, 240},
+    {I_VCMPFALSE_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2450, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OSPS[] = {
+    {I_VCMPNEQ_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6472, 188},
+    {I_VCMPNEQ_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6481, 188},
+    {I_VCMPNEQ_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6490, 188},
+    {I_VCMPNEQ_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6499, 188},
+    {I_VCMPNEQ_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2510, 240},
+    {I_VCMPNEQ_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2520, 240},
+    {I_VCMPNEQ_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2530, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OQPS[] = {
+    {I_VCMPGE_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6508, 188},
+    {I_VCMPGE_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6517, 188},
+    {I_VCMPGE_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6526, 188},
+    {I_VCMPGE_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6535, 188},
+    {I_VCMPGE_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2590, 240},
+    {I_VCMPGE_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2600, 240},
+    {I_VCMPGE_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2610, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OQPS[] = {
+    {I_VCMPGT_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6544, 188},
+    {I_VCMPGT_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6553, 188},
+    {I_VCMPGT_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6562, 188},
+    {I_VCMPGT_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6571, 188},
+    {I_VCMPGT_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2670, 240},
+    {I_VCMPGT_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2680, 240},
+    {I_VCMPGT_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2690, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_USPS[] = {
+    {I_VCMPTRUE_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6580, 188},
+    {I_VCMPTRUE_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6589, 188},
+    {I_VCMPTRUE_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6598, 188},
+    {I_VCMPTRUE_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6607, 188},
+    {I_VCMPTRUE_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2750, 240},
+    {I_VCMPTRUE_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2760, 240},
+    {I_VCMPTRUE_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2770, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPPS[] = {
+    {I_VCMPPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13464, 188},
+    {I_VCMPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13472, 188},
+    {I_VCMPPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13480, 188},
+    {I_VCMPPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13488, 188},
+    {I_VCMPPS, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+8137, 240},
+    {I_VCMPPS, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+8146, 240},
+    {I_VCMPPS, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+8155, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OSSD[] = {
+    {I_VCMPEQ_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6616, 188},
+    {I_VCMPEQ_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6625, 188},
+    {I_VCMPEQ_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6616, 188},
+    {I_VCMPEQ_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6625, 188},
+    {I_VCMPEQ_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1580, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQSD[] = {
+    {I_VCMPEQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6634, 188},
+    {I_VCMPEQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6643, 188},
+    {I_VCMPEQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+300, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OSSD[] = {
+    {I_VCMPLT_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6652, 188},
+    {I_VCMPLT_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6661, 188},
+    {I_VCMPLT_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+380, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLTSD[] = {
+    {I_VCMPLTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6652, 188},
+    {I_VCMPLTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6661, 188},
+    {I_VCMPLTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+380, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OSSD[] = {
+    {I_VCMPLE_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6670, 188},
+    {I_VCMPLE_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6679, 188},
+    {I_VCMPLE_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+460, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLESD[] = {
+    {I_VCMPLESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6670, 188},
+    {I_VCMPLESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6679, 188},
+    {I_VCMPLESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+460, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_QSD[] = {
+    {I_VCMPUNORD_QSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6688, 188},
+    {I_VCMPUNORD_QSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6697, 188},
+    {I_VCMPUNORD_QSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+540, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORDSD[] = {
+    {I_VCMPUNORDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6688, 188},
+    {I_VCMPUNORDSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6697, 188},
+    {I_VCMPUNORDSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+540, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_UQSD[] = {
+    {I_VCMPNEQ_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6706, 188},
+    {I_VCMPNEQ_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6715, 188},
+    {I_VCMPNEQ_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+620, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQSD[] = {
+    {I_VCMPNEQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6706, 188},
+    {I_VCMPNEQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6715, 188},
+    {I_VCMPNEQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+620, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_USSD[] = {
+    {I_VCMPNLT_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6724, 188},
+    {I_VCMPNLT_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6733, 188},
+    {I_VCMPNLT_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+700, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLTSD[] = {
+    {I_VCMPNLTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6724, 188},
+    {I_VCMPNLTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6733, 188},
+    {I_VCMPNLTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+700, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_USSD[] = {
+    {I_VCMPNLE_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6742, 188},
+    {I_VCMPNLE_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6751, 188},
+    {I_VCMPNLE_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+780, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLESD[] = {
+    {I_VCMPNLESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6742, 188},
+    {I_VCMPNLESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6751, 188},
+    {I_VCMPNLESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+780, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_QSD[] = {
+    {I_VCMPORD_QSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6760, 188},
+    {I_VCMPORD_QSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6769, 188},
+    {I_VCMPORD_QSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+860, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORDSD[] = {
+    {I_VCMPORDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6760, 188},
+    {I_VCMPORDSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6769, 188},
+    {I_VCMPORDSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+860, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_UQSD[] = {
+    {I_VCMPEQ_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6778, 188},
+    {I_VCMPEQ_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6787, 188},
+    {I_VCMPEQ_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+940, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_USSD[] = {
+    {I_VCMPNGE_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6796, 188},
+    {I_VCMPNGE_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6805, 188},
+    {I_VCMPNGE_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1020, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGESD[] = {
+    {I_VCMPNGESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6796, 188},
+    {I_VCMPNGESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6805, 188},
+    {I_VCMPNGESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1020, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_USSD[] = {
+    {I_VCMPNGT_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6814, 188},
+    {I_VCMPNGT_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6823, 188},
+    {I_VCMPNGT_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1100, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGTSD[] = {
+    {I_VCMPNGTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6814, 188},
+    {I_VCMPNGTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6823, 188},
+    {I_VCMPNGTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1100, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OQSD[] = {
+    {I_VCMPFALSE_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6832, 188},
+    {I_VCMPFALSE_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6841, 188},
+    {I_VCMPFALSE_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1180, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSESD[] = {
+    {I_VCMPFALSESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6832, 188},
+    {I_VCMPFALSESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6841, 188},
+    {I_VCMPFALSESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1180, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OQSD[] = {
+    {I_VCMPNEQ_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6850, 188},
+    {I_VCMPNEQ_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6859, 188},
+    {I_VCMPNEQ_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1260, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OSSD[] = {
+    {I_VCMPGE_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6868, 188},
+    {I_VCMPGE_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6877, 188},
+    {I_VCMPGE_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1340, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGESD[] = {
+    {I_VCMPGESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6868, 188},
+    {I_VCMPGESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6877, 188},
+    {I_VCMPGESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1340, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OSSD[] = {
+    {I_VCMPGT_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6886, 188},
+    {I_VCMPGT_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6895, 188},
+    {I_VCMPGT_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGTSD[] = {
+    {I_VCMPGTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6886, 188},
+    {I_VCMPGTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6895, 188},
+    {I_VCMPGTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_UQSD[] = {
+    {I_VCMPTRUE_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6904, 188},
+    {I_VCMPTRUE_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6913, 188},
+    {I_VCMPTRUE_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1500, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUESD[] = {
+    {I_VCMPTRUESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6904, 188},
+    {I_VCMPTRUESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6913, 188},
+    {I_VCMPTRUESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1500, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OQSD[] = {
+    {I_VCMPLT_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6922, 188},
+    {I_VCMPLT_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6931, 188},
+    {I_VCMPLT_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1660, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OQSD[] = {
+    {I_VCMPLE_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6940, 188},
+    {I_VCMPLE_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6949, 188},
+    {I_VCMPLE_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1740, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_SSD[] = {
+    {I_VCMPUNORD_SSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6958, 188},
+    {I_VCMPUNORD_SSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6967, 188},
+    {I_VCMPUNORD_SSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1820, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_USSD[] = {
+    {I_VCMPNEQ_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6976, 188},
+    {I_VCMPNEQ_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6985, 188},
+    {I_VCMPNEQ_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1900, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_UQSD[] = {
+    {I_VCMPNLT_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6994, 188},
+    {I_VCMPNLT_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7003, 188},
+    {I_VCMPNLT_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1980, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_UQSD[] = {
+    {I_VCMPNLE_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7012, 188},
+    {I_VCMPNLE_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7021, 188},
+    {I_VCMPNLE_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2060, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_SSD[] = {
+    {I_VCMPORD_SSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7030, 188},
+    {I_VCMPORD_SSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7039, 188},
+    {I_VCMPORD_SSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2140, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_USSD[] = {
+    {I_VCMPEQ_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7048, 188},
+    {I_VCMPEQ_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7057, 188},
+    {I_VCMPEQ_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2220, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_UQSD[] = {
+    {I_VCMPNGE_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7066, 188},
+    {I_VCMPNGE_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7075, 188},
+    {I_VCMPNGE_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2300, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_UQSD[] = {
+    {I_VCMPNGT_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7084, 188},
+    {I_VCMPNGT_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7093, 188},
+    {I_VCMPNGT_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2380, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OSSD[] = {
+    {I_VCMPFALSE_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7102, 188},
+    {I_VCMPFALSE_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7111, 188},
+    {I_VCMPFALSE_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2460, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OSSD[] = {
+    {I_VCMPNEQ_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7120, 188},
+    {I_VCMPNEQ_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7129, 188},
+    {I_VCMPNEQ_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2540, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OQSD[] = {
+    {I_VCMPGE_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7138, 188},
+    {I_VCMPGE_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7147, 188},
+    {I_VCMPGE_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2620, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OQSD[] = {
+    {I_VCMPGT_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7156, 188},
+    {I_VCMPGT_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7165, 188},
+    {I_VCMPGT_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2700, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_USSD[] = {
+    {I_VCMPTRUE_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7174, 188},
+    {I_VCMPTRUE_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7183, 188},
+    {I_VCMPTRUE_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2780, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPSD[] = {
+    {I_VCMPSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13496, 188},
+    {I_VCMPSD, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13504, 188},
+    {I_VCMPSD, 4, {KREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+8164, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OSSS[] = {
+    {I_VCMPEQ_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7192, 188},
+    {I_VCMPEQ_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7201, 188},
+    {I_VCMPEQ_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7192, 188},
+    {I_VCMPEQ_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7201, 188},
+    {I_VCMPEQ_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1590, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQSS[] = {
+    {I_VCMPEQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7210, 188},
+    {I_VCMPEQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7219, 188},
+    {I_VCMPEQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+310, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OSSS[] = {
+    {I_VCMPLT_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7228, 188},
+    {I_VCMPLT_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7237, 188},
+    {I_VCMPLT_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+390, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLTSS[] = {
+    {I_VCMPLTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7228, 188},
+    {I_VCMPLTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7237, 188},
+    {I_VCMPLTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+390, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OSSS[] = {
+    {I_VCMPLE_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7246, 188},
+    {I_VCMPLE_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7255, 188},
+    {I_VCMPLE_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+470, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLESS[] = {
+    {I_VCMPLESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7246, 188},
+    {I_VCMPLESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7255, 188},
+    {I_VCMPLESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+470, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_QSS[] = {
+    {I_VCMPUNORD_QSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7264, 188},
+    {I_VCMPUNORD_QSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7273, 188},
+    {I_VCMPUNORD_QSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+550, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORDSS[] = {
+    {I_VCMPUNORDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7264, 188},
+    {I_VCMPUNORDSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7273, 188},
+    {I_VCMPUNORDSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+550, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_UQSS[] = {
+    {I_VCMPNEQ_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7282, 188},
+    {I_VCMPNEQ_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7291, 188},
+    {I_VCMPNEQ_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+630, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQSS[] = {
+    {I_VCMPNEQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7282, 188},
+    {I_VCMPNEQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7291, 188},
+    {I_VCMPNEQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+630, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_USSS[] = {
+    {I_VCMPNLT_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7300, 188},
+    {I_VCMPNLT_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7309, 188},
+    {I_VCMPNLT_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+710, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLTSS[] = {
+    {I_VCMPNLTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7300, 188},
+    {I_VCMPNLTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7309, 188},
+    {I_VCMPNLTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+710, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_USSS[] = {
+    {I_VCMPNLE_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7318, 188},
+    {I_VCMPNLE_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7327, 188},
+    {I_VCMPNLE_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+790, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLESS[] = {
+    {I_VCMPNLESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7318, 188},
+    {I_VCMPNLESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7327, 188},
+    {I_VCMPNLESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+790, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_QSS[] = {
+    {I_VCMPORD_QSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7336, 188},
+    {I_VCMPORD_QSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7345, 188},
+    {I_VCMPORD_QSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+870, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORDSS[] = {
+    {I_VCMPORDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7336, 188},
+    {I_VCMPORDSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7345, 188},
+    {I_VCMPORDSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+870, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_UQSS[] = {
+    {I_VCMPEQ_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7354, 188},
+    {I_VCMPEQ_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7363, 188},
+    {I_VCMPEQ_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+950, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_USSS[] = {
+    {I_VCMPNGE_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7372, 188},
+    {I_VCMPNGE_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7381, 188},
+    {I_VCMPNGE_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1030, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGESS[] = {
+    {I_VCMPNGESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7372, 188},
+    {I_VCMPNGESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7381, 188},
+    {I_VCMPNGESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1030, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_USSS[] = {
+    {I_VCMPNGT_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7390, 188},
+    {I_VCMPNGT_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7399, 188},
+    {I_VCMPNGT_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1110, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGTSS[] = {
+    {I_VCMPNGTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7390, 188},
+    {I_VCMPNGTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7399, 188},
+    {I_VCMPNGTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1110, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OQSS[] = {
+    {I_VCMPFALSE_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7408, 188},
+    {I_VCMPFALSE_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7417, 188},
+    {I_VCMPFALSE_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1190, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSESS[] = {
+    {I_VCMPFALSESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7408, 188},
+    {I_VCMPFALSESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7417, 188},
+    {I_VCMPFALSESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1190, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OQSS[] = {
+    {I_VCMPNEQ_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7426, 188},
+    {I_VCMPNEQ_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7435, 188},
+    {I_VCMPNEQ_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1270, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OSSS[] = {
+    {I_VCMPGE_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7444, 188},
+    {I_VCMPGE_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7453, 188},
+    {I_VCMPGE_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1350, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGESS[] = {
+    {I_VCMPGESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7444, 188},
+    {I_VCMPGESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7453, 188},
+    {I_VCMPGESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1350, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OSSS[] = {
+    {I_VCMPGT_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7462, 188},
+    {I_VCMPGT_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7471, 188},
+    {I_VCMPGT_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1430, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGTSS[] = {
+    {I_VCMPGTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7462, 188},
+    {I_VCMPGTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7471, 188},
+    {I_VCMPGTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1430, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_UQSS[] = {
+    {I_VCMPTRUE_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7480, 188},
+    {I_VCMPTRUE_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7489, 188},
+    {I_VCMPTRUE_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1510, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUESS[] = {
+    {I_VCMPTRUESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7480, 188},
+    {I_VCMPTRUESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7489, 188},
+    {I_VCMPTRUESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1510, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLT_OQSS[] = {
+    {I_VCMPLT_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7498, 188},
+    {I_VCMPLT_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7507, 188},
+    {I_VCMPLT_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1670, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPLE_OQSS[] = {
+    {I_VCMPLE_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7516, 188},
+    {I_VCMPLE_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7525, 188},
+    {I_VCMPLE_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1750, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPUNORD_SSS[] = {
+    {I_VCMPUNORD_SSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7534, 188},
+    {I_VCMPUNORD_SSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7543, 188},
+    {I_VCMPUNORD_SSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1830, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_USSS[] = {
+    {I_VCMPNEQ_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7552, 188},
+    {I_VCMPNEQ_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7561, 188},
+    {I_VCMPNEQ_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1910, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLT_UQSS[] = {
+    {I_VCMPNLT_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7570, 188},
+    {I_VCMPNLT_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7579, 188},
+    {I_VCMPNLT_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1990, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNLE_UQSS[] = {
+    {I_VCMPNLE_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7588, 188},
+    {I_VCMPNLE_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7597, 188},
+    {I_VCMPNLE_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2070, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPORD_SSS[] = {
+    {I_VCMPORD_SSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7606, 188},
+    {I_VCMPORD_SSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7615, 188},
+    {I_VCMPORD_SSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2150, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_USSS[] = {
+    {I_VCMPEQ_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7624, 188},
+    {I_VCMPEQ_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7633, 188},
+    {I_VCMPEQ_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2230, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGE_UQSS[] = {
+    {I_VCMPNGE_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7642, 188},
+    {I_VCMPNGE_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7651, 188},
+    {I_VCMPNGE_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2310, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNGT_UQSS[] = {
+    {I_VCMPNGT_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7660, 188},
+    {I_VCMPNGT_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7669, 188},
+    {I_VCMPNGT_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2390, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPFALSE_OSSS[] = {
+    {I_VCMPFALSE_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7678, 188},
+    {I_VCMPFALSE_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7687, 188},
+    {I_VCMPFALSE_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2470, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPNEQ_OSSS[] = {
+    {I_VCMPNEQ_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7696, 188},
+    {I_VCMPNEQ_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7705, 188},
+    {I_VCMPNEQ_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2550, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGE_OQSS[] = {
+    {I_VCMPGE_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7714, 188},
+    {I_VCMPGE_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7723, 188},
+    {I_VCMPGE_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2630, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPGT_OQSS[] = {
+    {I_VCMPGT_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7732, 188},
+    {I_VCMPGT_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7741, 188},
+    {I_VCMPGT_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2710, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPTRUE_USSS[] = {
+    {I_VCMPTRUE_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7750, 188},
+    {I_VCMPTRUE_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7759, 188},
+    {I_VCMPTRUE_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2790, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPSS[] = {
+    {I_VCMPSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13512, 188},
+    {I_VCMPSS, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13520, 188},
+    {I_VCMPSS, 4, {KREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+8173, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCOMISD[] = {
+    {I_VCOMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35272, 188},
+    {I_VCOMISD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+16960, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCOMISS[] = {
+    {I_VCOMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35279, 188},
+    {I_VCOMISS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+16968, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTDQ2PD[] = {
+    {I_VCVTDQ2PD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35286, 188},
+    {I_VCVTDQ2PD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35293, 188},
+    {I_VCVTDQ2PD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17072, 240},
+    {I_VCVTDQ2PD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17080, 240},
+    {I_VCVTDQ2PD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17088, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTDQ2PS[] = {
+    {I_VCVTDQ2PS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35300, 188},
+    {I_VCVTDQ2PS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35307, 188},
+    {I_VCVTDQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17096, 240},
+    {I_VCVTDQ2PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17104, 240},
+    {I_VCVTDQ2PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17112, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPD2DQ[] = {
+    {I_VCVTPD2DQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35314, 188},
+    {I_VCVTPD2DQ, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35314, 192},
+    {I_VCVTPD2DQ, 2, {XMM_L16,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35321, 188},
+    {I_VCVTPD2DQ, 2, {XMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35321, 193},
+    {I_VCVTPD2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17120, 240},
+    {I_VCVTPD2DQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17128, 240},
+    {I_VCVTPD2DQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17136, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPD2PS[] = {
+    {I_VCVTPD2PS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35328, 188},
+    {I_VCVTPD2PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35328, 192},
+    {I_VCVTPD2PS, 2, {XMM_L16,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35335, 188},
+    {I_VCVTPD2PS, 2, {XMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35335, 193},
+    {I_VCVTPD2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17144, 240},
+    {I_VCVTPD2PS, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17152, 240},
+    {I_VCVTPD2PS, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17160, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPS2DQ[] = {
+    {I_VCVTPS2DQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35342, 188},
+    {I_VCVTPS2DQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35349, 188},
+    {I_VCVTPS2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17264, 240},
+    {I_VCVTPS2DQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17272, 240},
+    {I_VCVTPS2DQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17280, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPS2PD[] = {
+    {I_VCVTPS2PD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35356, 188},
+    {I_VCVTPS2PD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35363, 188},
+    {I_VCVTPS2PD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17288, 240},
+    {I_VCVTPS2PD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17296, 240},
+    {I_VCVTPS2PD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17304, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSD2SI[] = {
+    {I_VCVTSD2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35370, 188},
+    {I_VCVTSD2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35377, 194},
+    {I_VCVTSD2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17432, 241},
+    {I_VCVTSD2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17440, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSD2SS[] = {
+    {I_VCVTSD2SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35384, 188},
+    {I_VCVTSD2SS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35391, 188},
+    {I_VCVTSD2SS, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+17448, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSI2SD[] = {
+    {I_VCVTSI2SD, 3, {XMM_L16,XMM_L16,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35398, 195},
+    {I_VCVTSI2SD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35405, 195},
+    {I_VCVTSI2SD, 3, {XMM_L16,XMM_L16,MEMORY|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35398, 195},
+    {I_VCVTSI2SD, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35405, 195},
+    {I_VCVTSI2SD, 3, {XMM_L16,XMM_L16,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35412, 196},
+    {I_VCVTSI2SD, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35419, 196},
+    {I_VCVTSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17472, 241},
+    {I_VCVTSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17480, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSI2SS[] = {
+    {I_VCVTSI2SS, 3, {XMM_L16,XMM_L16,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35426, 195},
+    {I_VCVTSI2SS, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35433, 195},
+    {I_VCVTSI2SS, 3, {XMM_L16,XMM_L16,MEMORY|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35426, 195},
+    {I_VCVTSI2SS, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35433, 195},
+    {I_VCVTSI2SS, 3, {XMM_L16,XMM_L16,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35440, 196},
+    {I_VCVTSI2SS, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35447, 196},
+    {I_VCVTSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17488, 241},
+    {I_VCVTSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17496, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSS2SD[] = {
+    {I_VCVTSS2SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35454, 188},
+    {I_VCVTSS2SD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35461, 188},
+    {I_VCVTSS2SD, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+17504, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSS2SI[] = {
+    {I_VCVTSS2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35468, 188},
+    {I_VCVTSS2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35475, 194},
+    {I_VCVTSS2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17512, 241},
+    {I_VCVTSS2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17520, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPD2DQ[] = {
+    {I_VCVTTPD2DQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35482, 188},
+    {I_VCVTTPD2DQ, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35482, 192},
+    {I_VCVTTPD2DQ, 2, {XMM_L16,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35489, 188},
+    {I_VCVTTPD2DQ, 2, {XMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35489, 193},
+    {I_VCVTTPD2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17544, 240},
+    {I_VCVTTPD2DQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17552, 240},
+    {I_VCVTTPD2DQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17560, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPS2DQ[] = {
+    {I_VCVTTPS2DQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35496, 188},
+    {I_VCVTTPS2DQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35503, 188},
+    {I_VCVTTPS2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17640, 240},
+    {I_VCVTTPS2DQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17648, 240},
+    {I_VCVTTPS2DQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17656, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTSD2SI[] = {
+    {I_VCVTTSD2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35510, 188},
+    {I_VCVTTSD2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35517, 194},
+    {I_VCVTTSD2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17736, 241},
+    {I_VCVTTSD2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17744, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTSS2SI[] = {
+    {I_VCVTTSS2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35524, 188},
+    {I_VCVTTSS2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35531, 194},
+    {I_VCVTTSS2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17768, 241},
+    {I_VCVTTSS2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17776, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDIVPD[] = {
+    {I_VDIVPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35538, 188},
+    {I_VDIVPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35545, 188},
+    {I_VDIVPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35552, 188},
+    {I_VDIVPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35559, 188},
+    {I_VDIVPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+17928, 240},
+    {I_VDIVPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17936, 240},
+    {I_VDIVPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+17944, 240},
+    {I_VDIVPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17952, 240},
+    {I_VDIVPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+17960, 241},
+    {I_VDIVPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17968, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDIVPS[] = {
+    {I_VDIVPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35566, 188},
+    {I_VDIVPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35573, 188},
+    {I_VDIVPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35580, 188},
+    {I_VDIVPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35587, 188},
+    {I_VDIVPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+17976, 240},
+    {I_VDIVPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17984, 240},
+    {I_VDIVPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+17992, 240},
+    {I_VDIVPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+18000, 240},
+    {I_VDIVPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18008, 241},
+    {I_VDIVPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+18016, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDIVSD[] = {
+    {I_VDIVSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35594, 188},
+    {I_VDIVSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35601, 188},
+    {I_VDIVSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18024, 241},
+    {I_VDIVSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+18032, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDIVSS[] = {
+    {I_VDIVSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35608, 188},
+    {I_VDIVSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35615, 188},
+    {I_VDIVSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18040, 241},
+    {I_VDIVSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+18048, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDPPD[] = {
+    {I_VDPPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13528, 188},
+    {I_VDPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13536, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDPPS[] = {
+    {I_VDPPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13544, 188},
+    {I_VDPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13552, 188},
+    {I_VDPPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13560, 188},
+    {I_VDPPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13568, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTF128[] = {
+    {I_VEXTRACTF128, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13576, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTPS[] = {
+    {I_VEXTRACTPS, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13584, 188},
+    {I_VEXTRACTPS, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+8479, 241},
+    {I_VEXTRACTPS, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+8479, 241},
+    {I_VEXTRACTPS, 3, {MEMORY|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+8479, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VHADDPD[] = {
+    {I_VHADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35622, 188},
+    {I_VHADDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35629, 188},
+    {I_VHADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35636, 188},
+    {I_VHADDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35643, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VHADDPS[] = {
+    {I_VHADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35650, 188},
+    {I_VHADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35657, 188},
+    {I_VHADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35664, 188},
+    {I_VHADDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35671, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VHSUBPD[] = {
+    {I_VHSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35678, 188},
+    {I_VHSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35685, 188},
+    {I_VHSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35692, 188},
+    {I_VHSUBPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35699, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VHSUBPS[] = {
+    {I_VHSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35706, 188},
+    {I_VHSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35713, 188},
+    {I_VHSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35720, 188},
+    {I_VHSUBPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35727, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTF128[] = {
+    {I_VINSERTF128, 4, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13592, 188},
+    {I_VINSERTF128, 3, {YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13600, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTPS[] = {
+    {I_VINSERTPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13608, 188},
+    {I_VINSERTPS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13616, 188},
+    {I_VINSERTPS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9172, 241},
+    {I_VINSERTPS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9181, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VLDDQU[] = {
+    {I_VLDDQU, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35734, 188},
+    {I_VLDDQU, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35741, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VLDQQU[] = {
+    {I_VLDQQU, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35741, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VLDMXCSR[] = {
+    {I_VLDMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+35748, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMASKMOVDQU[] = {
+    {I_VMASKMOVDQU, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35755, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMASKMOVPS[] = {
+    {I_VMASKMOVPS, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35762, 188},
+    {I_VMASKMOVPS, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35769, 188},
+    {I_VMASKMOVPS, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35776, 192},
+    {I_VMASKMOVPS, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35783, 193},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMASKMOVPD[] = {
+    {I_VMASKMOVPD, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35790, 188},
+    {I_VMASKMOVPD, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35797, 188},
+    {I_VMASKMOVPD, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35804, 188},
+    {I_VMASKMOVPD, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35811, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMAXPD[] = {
+    {I_VMAXPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35818, 188},
+    {I_VMAXPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35825, 188},
+    {I_VMAXPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35832, 188},
+    {I_VMAXPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35839, 188},
+    {I_VMAXPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19240, 240},
+    {I_VMAXPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19248, 240},
+    {I_VMAXPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19256, 240},
+    {I_VMAXPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19264, 240},
+    {I_VMAXPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+19272, 241},
+    {I_VMAXPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+19280, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMAXPS[] = {
+    {I_VMAXPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35846, 188},
+    {I_VMAXPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35853, 188},
+    {I_VMAXPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35860, 188},
+    {I_VMAXPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35867, 188},
+    {I_VMAXPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19288, 240},
+    {I_VMAXPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19296, 240},
+    {I_VMAXPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19304, 240},
+    {I_VMAXPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19312, 240},
+    {I_VMAXPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+19320, 241},
+    {I_VMAXPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+19328, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMAXSD[] = {
+    {I_VMAXSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35874, 188},
+    {I_VMAXSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35881, 188},
+    {I_VMAXSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19336, 241},
+    {I_VMAXSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19344, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMAXSS[] = {
+    {I_VMAXSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35888, 188},
+    {I_VMAXSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35895, 188},
+    {I_VMAXSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19352, 241},
+    {I_VMAXSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19360, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMINPD[] = {
+    {I_VMINPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35902, 188},
+    {I_VMINPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35909, 188},
+    {I_VMINPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35916, 188},
+    {I_VMINPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35923, 188},
+    {I_VMINPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19368, 240},
+    {I_VMINPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19376, 240},
+    {I_VMINPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19384, 240},
+    {I_VMINPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19392, 240},
+    {I_VMINPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+19400, 241},
+    {I_VMINPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+19408, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMINPS[] = {
+    {I_VMINPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35930, 188},
+    {I_VMINPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35937, 188},
+    {I_VMINPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35944, 188},
+    {I_VMINPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35951, 188},
+    {I_VMINPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19416, 240},
+    {I_VMINPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19424, 240},
+    {I_VMINPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19432, 240},
+    {I_VMINPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19440, 240},
+    {I_VMINPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+19448, 241},
+    {I_VMINPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+19456, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMINSD[] = {
+    {I_VMINSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35958, 188},
+    {I_VMINSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35965, 188},
+    {I_VMINSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19464, 241},
+    {I_VMINSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19472, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMINSS[] = {
+    {I_VMINSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35972, 188},
+    {I_VMINSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35979, 188},
+    {I_VMINSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19480, 241},
+    {I_VMINSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19488, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVAPD[] = {
+    {I_VMOVAPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35986, 188},
+    {I_VMOVAPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35993, 188},
+    {I_VMOVAPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36000, 188},
+    {I_VMOVAPD, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36007, 188},
+    {I_VMOVAPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19496, 240},
+    {I_VMOVAPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19504, 240},
+    {I_VMOVAPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19512, 241},
+    {I_VMOVAPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19520, 240},
+    {I_VMOVAPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19528, 240},
+    {I_VMOVAPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19536, 241},
+    {I_VMOVAPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19544, 240},
+    {I_VMOVAPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19552, 240},
+    {I_VMOVAPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19560, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVAPS[] = {
+    {I_VMOVAPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36014, 188},
+    {I_VMOVAPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36021, 188},
+    {I_VMOVAPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36028, 188},
+    {I_VMOVAPS, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36035, 188},
+    {I_VMOVAPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19568, 240},
+    {I_VMOVAPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19576, 240},
+    {I_VMOVAPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19584, 241},
+    {I_VMOVAPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19592, 240},
+    {I_VMOVAPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19600, 240},
+    {I_VMOVAPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19608, 241},
+    {I_VMOVAPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19616, 240},
+    {I_VMOVAPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19624, 240},
+    {I_VMOVAPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19632, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVD[] = {
+    {I_VMOVD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+36042, 188},
+    {I_VMOVD, 2, {RM_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36049, 188},
+    {I_VMOVD, 2, {XMMREG,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+19640, 241},
+    {I_VMOVD, 2, {RM_GPR|BITS32,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+19648, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVQ[] = {
+    {I_VMOVQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36056, 197},
+    {I_VMOVQ, 2, {RM_XMM_L16|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36063, 197},
+    {I_VMOVQ, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36070, 196},
+    {I_VMOVQ, 2, {RM_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36077, 196},
+    {I_VMOVQ, 2, {XMMREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20192, 241},
+    {I_VMOVQ, 2, {RM_GPR|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20200, 241},
+    {I_VMOVQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20208, 241},
+    {I_VMOVQ, 2, {RM_XMM|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20216, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDDUP[] = {
+    {I_VMOVDDUP, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36084, 188},
+    {I_VMOVDDUP, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36091, 188},
+    {I_VMOVDDUP, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19656, 240},
+    {I_VMOVDDUP, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19664, 240},
+    {I_VMOVDDUP, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19672, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQA[] = {
+    {I_VMOVDQA, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36098, 188},
+    {I_VMOVDQA, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36105, 188},
+    {I_VMOVDQA, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36112, 188},
+    {I_VMOVDQA, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36119, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVQQA[] = {
+    {I_VMOVQQA, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36112, 188},
+    {I_VMOVQQA, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36119, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQU[] = {
+    {I_VMOVDQU, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36126, 188},
+    {I_VMOVDQU, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36133, 188},
+    {I_VMOVDQU, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36140, 188},
+    {I_VMOVDQU, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36147, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVQQU[] = {
+    {I_VMOVQQU, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36140, 188},
+    {I_VMOVQQU, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36147, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVHLPS[] = {
+    {I_VMOVHLPS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36154, 188},
+    {I_VMOVHLPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36161, 188},
+    {I_VMOVHLPS, 3, {XMMREG,XMMREG,XMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+19968, 241},
+    {I_VMOVHLPS, 2, {XMMREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+19976, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVHPD[] = {
+    {I_VMOVHPD, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36168, 188},
+    {I_VMOVHPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36175, 188},
+    {I_VMOVHPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36182, 188},
+    {I_VMOVHPD, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+19984, 241},
+    {I_VMOVHPD, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+19992, 241},
+    {I_VMOVHPD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20000, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVHPS[] = {
+    {I_VMOVHPS, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36189, 188},
+    {I_VMOVHPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36196, 188},
+    {I_VMOVHPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36203, 188},
+    {I_VMOVHPS, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+20008, 241},
+    {I_VMOVHPS, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20016, 241},
+    {I_VMOVHPS, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20024, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVLHPS[] = {
+    {I_VMOVLHPS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36189, 188},
+    {I_VMOVLHPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36196, 188},
+    {I_VMOVLHPS, 3, {XMMREG,XMMREG,XMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+20032, 241},
+    {I_VMOVLHPS, 2, {XMMREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20040, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVLPD[] = {
+    {I_VMOVLPD, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36210, 188},
+    {I_VMOVLPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36217, 188},
+    {I_VMOVLPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36224, 188},
+    {I_VMOVLPD, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+20048, 241},
+    {I_VMOVLPD, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20056, 241},
+    {I_VMOVLPD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20064, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVLPS[] = {
+    {I_VMOVLPS, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36154, 188},
+    {I_VMOVLPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36161, 188},
+    {I_VMOVLPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36231, 188},
+    {I_VMOVLPS, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+20072, 241},
+    {I_VMOVLPS, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20080, 241},
+    {I_VMOVLPS, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20088, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVMSKPD[] = {
+    {I_VMOVMSKPD, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36238, 194},
+    {I_VMOVMSKPD, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36238, 188},
+    {I_VMOVMSKPD, 2, {REG_GPR|BITS64,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36245, 194},
+    {I_VMOVMSKPD, 2, {REG_GPR|BITS32,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36245, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVMSKPS[] = {
+    {I_VMOVMSKPS, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36252, 194},
+    {I_VMOVMSKPS, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36252, 188},
+    {I_VMOVMSKPS, 2, {REG_GPR|BITS64,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36259, 194},
+    {I_VMOVMSKPS, 2, {REG_GPR|BITS32,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36259, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVNTDQ[] = {
+    {I_VMOVNTDQ, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36266, 188},
+    {I_VMOVNTDQ, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36273, 188},
+    {I_VMOVNTDQ, 2, {MEMORY|BITS128,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20096, 240},
+    {I_VMOVNTDQ, 2, {MEMORY|BITS256,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20104, 240},
+    {I_VMOVNTDQ, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20112, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVNTQQ[] = {
+    {I_VMOVNTQQ, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36273, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVNTDQA[] = {
+    {I_VMOVNTDQA, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36280, 188},
+    {I_VMOVNTDQA, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41033, 207},
+    {I_VMOVNTDQA, 2, {XMMREG,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+20120, 240},
+    {I_VMOVNTDQA, 2, {YMMREG,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+20128, 240},
+    {I_VMOVNTDQA, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+20136, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVNTPD[] = {
+    {I_VMOVNTPD, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36287, 188},
+    {I_VMOVNTPD, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36294, 188},
+    {I_VMOVNTPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20144, 240},
+    {I_VMOVNTPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20152, 240},
+    {I_VMOVNTPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20160, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVNTPS[] = {
+    {I_VMOVNTPS, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36301, 188},
+    {I_VMOVNTPS, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36308, 188},
+    {I_VMOVNTPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20168, 240},
+    {I_VMOVNTPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20176, 240},
+    {I_VMOVNTPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20184, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVSD[] = {
+    {I_VMOVSD, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36315, 188},
+    {I_VMOVSD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36322, 188},
+    {I_VMOVSD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36329, 188},
+    {I_VMOVSD, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36336, 188},
+    {I_VMOVSD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36343, 188},
+    {I_VMOVSD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36350, 188},
+    {I_VMOVSD, 2, {XMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20224, 241},
+    {I_VMOVSD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20232, 241},
+    {I_VMOVSD, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20240, 241},
+    {I_VMOVSD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20248, 241},
+    {I_VMOVSD, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20256, 241},
+    {I_VMOVSD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20264, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVSHDUP[] = {
+    {I_VMOVSHDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36357, 188},
+    {I_VMOVSHDUP, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36364, 188},
+    {I_VMOVSHDUP, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20272, 240},
+    {I_VMOVSHDUP, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20280, 240},
+    {I_VMOVSHDUP, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20288, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVSLDUP[] = {
+    {I_VMOVSLDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36371, 188},
+    {I_VMOVSLDUP, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36378, 188},
+    {I_VMOVSLDUP, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20296, 240},
+    {I_VMOVSLDUP, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20304, 240},
+    {I_VMOVSLDUP, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20312, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVSS[] = {
+    {I_VMOVSS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36385, 188},
+    {I_VMOVSS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36392, 188},
+    {I_VMOVSS, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+36399, 188},
+    {I_VMOVSS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36406, 188},
+    {I_VMOVSS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36413, 188},
+    {I_VMOVSS, 2, {MEMORY|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36420, 188},
+    {I_VMOVSS, 2, {XMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20320, 241},
+    {I_VMOVSS, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20328, 241},
+    {I_VMOVSS, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20336, 241},
+    {I_VMOVSS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20344, 241},
+    {I_VMOVSS, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20352, 241},
+    {I_VMOVSS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20360, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVUPD[] = {
+    {I_VMOVUPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36427, 188},
+    {I_VMOVUPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36434, 188},
+    {I_VMOVUPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36441, 188},
+    {I_VMOVUPD, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36448, 188},
+    {I_VMOVUPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20368, 240},
+    {I_VMOVUPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20376, 240},
+    {I_VMOVUPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20384, 241},
+    {I_VMOVUPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20392, 240},
+    {I_VMOVUPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20400, 240},
+    {I_VMOVUPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20408, 241},
+    {I_VMOVUPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20416, 240},
+    {I_VMOVUPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20424, 240},
+    {I_VMOVUPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20432, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVUPS[] = {
+    {I_VMOVUPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36455, 188},
+    {I_VMOVUPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36462, 188},
+    {I_VMOVUPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36469, 188},
+    {I_VMOVUPS, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36476, 188},
+    {I_VMOVUPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20440, 240},
+    {I_VMOVUPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20448, 240},
+    {I_VMOVUPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20456, 241},
+    {I_VMOVUPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20464, 240},
+    {I_VMOVUPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20472, 240},
+    {I_VMOVUPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20480, 241},
+    {I_VMOVUPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20488, 240},
+    {I_VMOVUPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20496, 240},
+    {I_VMOVUPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20504, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMPSADBW[] = {
+    {I_VMPSADBW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13624, 188},
+    {I_VMPSADBW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13632, 188},
+    {I_VMPSADBW, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15808, 207},
+    {I_VMPSADBW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15816, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMULPD[] = {
+    {I_VMULPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36483, 188},
+    {I_VMULPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36490, 188},
+    {I_VMULPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36497, 188},
+    {I_VMULPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36504, 188},
+    {I_VMULPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20512, 240},
+    {I_VMULPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20520, 240},
+    {I_VMULPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20528, 240},
+    {I_VMULPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20536, 240},
+    {I_VMULPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+20544, 241},
+    {I_VMULPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+20552, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMULPS[] = {
+    {I_VMULPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36511, 188},
+    {I_VMULPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36518, 188},
+    {I_VMULPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36525, 188},
+    {I_VMULPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36532, 188},
+    {I_VMULPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20560, 240},
+    {I_VMULPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20568, 240},
+    {I_VMULPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20576, 240},
+    {I_VMULPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20584, 240},
+    {I_VMULPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+20592, 241},
+    {I_VMULPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+20600, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMULSD[] = {
+    {I_VMULSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36539, 188},
+    {I_VMULSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36546, 188},
+    {I_VMULSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+20608, 241},
+    {I_VMULSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+20616, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMULSS[] = {
+    {I_VMULSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+36553, 188},
+    {I_VMULSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+36560, 188},
+    {I_VMULSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+20624, 241},
+    {I_VMULSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+20632, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VORPD[] = {
+    {I_VORPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36567, 188},
+    {I_VORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36574, 188},
+    {I_VORPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36581, 188},
+    {I_VORPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36588, 188},
+    {I_VORPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20640, 242},
+    {I_VORPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20648, 242},
+    {I_VORPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20656, 242},
+    {I_VORPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20664, 242},
+    {I_VORPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20672, 243},
+    {I_VORPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20680, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VORPS[] = {
+    {I_VORPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36595, 188},
+    {I_VORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36602, 188},
+    {I_VORPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36609, 188},
+    {I_VORPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36616, 188},
+    {I_VORPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20688, 242},
+    {I_VORPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20696, 242},
+    {I_VORPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20704, 242},
+    {I_VORPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20712, 242},
+    {I_VORPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20720, 243},
+    {I_VORPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20728, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPABSB[] = {
+    {I_VPABSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36623, 188},
+    {I_VPABSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39773, 207},
+    {I_VPABSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20736, 244},
+    {I_VPABSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20744, 244},
+    {I_VPABSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20752, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPABSW[] = {
+    {I_VPABSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36630, 188},
+    {I_VPABSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39780, 207},
+    {I_VPABSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20808, 244},
+    {I_VPABSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20816, 244},
+    {I_VPABSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20824, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPABSD[] = {
+    {I_VPABSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36637, 188},
+    {I_VPABSD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39787, 207},
+    {I_VPABSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20760, 240},
+    {I_VPABSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20768, 240},
+    {I_VPABSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20776, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPACKSSWB[] = {
+    {I_VPACKSSWB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36644, 188},
+    {I_VPACKSSWB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36651, 188},
+    {I_VPACKSSWB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39794, 207},
+    {I_VPACKSSWB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39801, 207},
+    {I_VPACKSSWB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20880, 244},
+    {I_VPACKSSWB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20888, 244},
+    {I_VPACKSSWB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20896, 244},
+    {I_VPACKSSWB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20904, 244},
+    {I_VPACKSSWB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20912, 245},
+    {I_VPACKSSWB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20920, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPACKSSDW[] = {
+    {I_VPACKSSDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36658, 188},
+    {I_VPACKSSDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36665, 188},
+    {I_VPACKSSDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39808, 207},
+    {I_VPACKSSDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39815, 207},
+    {I_VPACKSSDW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20832, 244},
+    {I_VPACKSSDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20840, 244},
+    {I_VPACKSSDW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20848, 244},
+    {I_VPACKSSDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20856, 244},
+    {I_VPACKSSDW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20864, 245},
+    {I_VPACKSSDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20872, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPACKUSWB[] = {
+    {I_VPACKUSWB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36672, 188},
+    {I_VPACKUSWB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36679, 188},
+    {I_VPACKUSWB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39836, 207},
+    {I_VPACKUSWB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39843, 207},
+    {I_VPACKUSWB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20976, 244},
+    {I_VPACKUSWB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20984, 244},
+    {I_VPACKUSWB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20992, 244},
+    {I_VPACKUSWB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21000, 244},
+    {I_VPACKUSWB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21008, 245},
+    {I_VPACKUSWB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21016, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPACKUSDW[] = {
+    {I_VPACKUSDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36686, 188},
+    {I_VPACKUSDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36693, 188},
+    {I_VPACKUSDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39822, 207},
+    {I_VPACKUSDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39829, 207},
+    {I_VPACKUSDW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20928, 244},
+    {I_VPACKUSDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20936, 244},
+    {I_VPACKUSDW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20944, 244},
+    {I_VPACKUSDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20952, 244},
+    {I_VPACKUSDW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20960, 245},
+    {I_VPACKUSDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20968, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDB[] = {
+    {I_VPADDB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36700, 188},
+    {I_VPADDB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36707, 188},
+    {I_VPADDB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39850, 207},
+    {I_VPADDB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39857, 207},
+    {I_VPADDB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21024, 244},
+    {I_VPADDB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21032, 244},
+    {I_VPADDB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21040, 244},
+    {I_VPADDB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21048, 244},
+    {I_VPADDB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21056, 245},
+    {I_VPADDB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21064, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDW[] = {
+    {I_VPADDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36714, 188},
+    {I_VPADDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36721, 188},
+    {I_VPADDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39864, 207},
+    {I_VPADDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39871, 207},
+    {I_VPADDW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21360, 244},
+    {I_VPADDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21368, 244},
+    {I_VPADDW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21376, 244},
+    {I_VPADDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21384, 244},
+    {I_VPADDW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21392, 245},
+    {I_VPADDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21400, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDD[] = {
+    {I_VPADDD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36728, 188},
+    {I_VPADDD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36735, 188},
+    {I_VPADDD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39878, 207},
+    {I_VPADDD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39885, 207},
+    {I_VPADDD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21072, 240},
+    {I_VPADDD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21080, 240},
+    {I_VPADDD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21088, 240},
+    {I_VPADDD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21096, 240},
+    {I_VPADDD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21104, 241},
+    {I_VPADDD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21112, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDQ[] = {
+    {I_VPADDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36742, 188},
+    {I_VPADDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36749, 188},
+    {I_VPADDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39892, 207},
+    {I_VPADDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39899, 207},
+    {I_VPADDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21120, 240},
+    {I_VPADDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21128, 240},
+    {I_VPADDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21136, 240},
+    {I_VPADDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21144, 240},
+    {I_VPADDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21152, 241},
+    {I_VPADDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21160, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDSB[] = {
+    {I_VPADDSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36756, 188},
+    {I_VPADDSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36763, 188},
+    {I_VPADDSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39906, 207},
+    {I_VPADDSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39913, 207},
+    {I_VPADDSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21168, 244},
+    {I_VPADDSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21176, 244},
+    {I_VPADDSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21184, 244},
+    {I_VPADDSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21192, 244},
+    {I_VPADDSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21200, 245},
+    {I_VPADDSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21208, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDSW[] = {
+    {I_VPADDSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36770, 188},
+    {I_VPADDSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36777, 188},
+    {I_VPADDSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39920, 207},
+    {I_VPADDSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39927, 207},
+    {I_VPADDSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21216, 244},
+    {I_VPADDSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21224, 244},
+    {I_VPADDSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21232, 244},
+    {I_VPADDSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21240, 244},
+    {I_VPADDSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21248, 245},
+    {I_VPADDSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21256, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDUSB[] = {
+    {I_VPADDUSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36784, 188},
+    {I_VPADDUSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36791, 188},
+    {I_VPADDUSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39934, 207},
+    {I_VPADDUSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39941, 207},
+    {I_VPADDUSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21264, 244},
+    {I_VPADDUSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21272, 244},
+    {I_VPADDUSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21280, 244},
+    {I_VPADDUSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21288, 244},
+    {I_VPADDUSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21296, 245},
+    {I_VPADDUSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21304, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPADDUSW[] = {
+    {I_VPADDUSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36798, 188},
+    {I_VPADDUSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36805, 188},
+    {I_VPADDUSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39948, 207},
+    {I_VPADDUSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39955, 207},
+    {I_VPADDUSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21312, 244},
+    {I_VPADDUSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21320, 244},
+    {I_VPADDUSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21328, 244},
+    {I_VPADDUSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21336, 244},
+    {I_VPADDUSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21344, 245},
+    {I_VPADDUSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21352, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPALIGNR[] = {
+    {I_VPALIGNR, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13640, 188},
+    {I_VPALIGNR, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13648, 188},
+    {I_VPALIGNR, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15824, 207},
+    {I_VPALIGNR, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15832, 207},
+    {I_VPALIGNR, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9190, 244},
+    {I_VPALIGNR, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9199, 244},
+    {I_VPALIGNR, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9208, 244},
+    {I_VPALIGNR, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9217, 244},
+    {I_VPALIGNR, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9226, 245},
+    {I_VPALIGNR, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9235, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPAND[] = {
+    {I_VPAND, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36812, 188},
+    {I_VPAND, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36819, 188},
+    {I_VPAND, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39962, 207},
+    {I_VPAND, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39969, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPANDN[] = {
+    {I_VPANDN, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36826, 188},
+    {I_VPANDN, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36833, 188},
+    {I_VPANDN, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39976, 207},
+    {I_VPANDN, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39983, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPAVGB[] = {
+    {I_VPAVGB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36840, 188},
+    {I_VPAVGB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36847, 188},
+    {I_VPAVGB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39990, 207},
+    {I_VPAVGB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39997, 207},
+    {I_VPAVGB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21600, 244},
+    {I_VPAVGB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21608, 244},
+    {I_VPAVGB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21616, 244},
+    {I_VPAVGB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21624, 244},
+    {I_VPAVGB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21632, 245},
+    {I_VPAVGB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21640, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPAVGW[] = {
+    {I_VPAVGW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36854, 188},
+    {I_VPAVGW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36861, 188},
+    {I_VPAVGW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40004, 207},
+    {I_VPAVGW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40011, 207},
+    {I_VPAVGW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21648, 244},
+    {I_VPAVGW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21656, 244},
+    {I_VPAVGW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21664, 244},
+    {I_VPAVGW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21672, 244},
+    {I_VPAVGW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21680, 245},
+    {I_VPAVGW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21688, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDVB[] = {
+    {I_VPBLENDVB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13656, 188},
+    {I_VPBLENDVB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13664, 188},
+    {I_VPBLENDVB, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15840, 207},
+    {I_VPBLENDVB, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15848, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDW[] = {
+    {I_VPBLENDW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13672, 188},
+    {I_VPBLENDW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13680, 188},
+    {I_VPBLENDW, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15856, 207},
+    {I_VPBLENDW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15864, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPESTRI[] = {
+    {I_VPCMPESTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13688, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPESTRM[] = {
+    {I_VPCMPESTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13696, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPISTRI[] = {
+    {I_VPCMPISTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13704, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPISTRM[] = {
+    {I_VPCMPISTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13712, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQB[] = {
+    {I_VPCMPEQB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36868, 188},
+    {I_VPCMPEQB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36875, 188},
+    {I_VPCMPEQB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40018, 207},
+    {I_VPCMPEQB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40025, 207},
+    {I_VPCMPEQB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22080, 244},
+    {I_VPCMPEQB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22088, 244},
+    {I_VPCMPEQB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22096, 245},
+    {I_VPCMPEQB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2800, 244},
+    {I_VPCMPEQB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2810, 244},
+    {I_VPCMPEQB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2820, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQW[] = {
+    {I_VPCMPEQW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36882, 188},
+    {I_VPCMPEQW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36889, 188},
+    {I_VPCMPEQW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40032, 207},
+    {I_VPCMPEQW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40039, 207},
+    {I_VPCMPEQW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22152, 244},
+    {I_VPCMPEQW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22160, 244},
+    {I_VPCMPEQW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22168, 245},
+    {I_VPCMPEQW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3010, 244},
+    {I_VPCMPEQW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3020, 244},
+    {I_VPCMPEQW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3030, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQD[] = {
+    {I_VPCMPEQD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36896, 188},
+    {I_VPCMPEQD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36903, 188},
+    {I_VPCMPEQD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40046, 207},
+    {I_VPCMPEQD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40053, 207},
+    {I_VPCMPEQD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22104, 240},
+    {I_VPCMPEQD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22112, 240},
+    {I_VPCMPEQD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22120, 241},
+    {I_VPCMPEQD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2830, 240},
+    {I_VPCMPEQD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2840, 240},
+    {I_VPCMPEQD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2850, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQQ[] = {
+    {I_VPCMPEQQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36910, 188},
+    {I_VPCMPEQQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36917, 188},
+    {I_VPCMPEQQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40060, 207},
+    {I_VPCMPEQQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40067, 207},
+    {I_VPCMPEQQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22128, 240},
+    {I_VPCMPEQQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22136, 240},
+    {I_VPCMPEQQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22144, 241},
+    {I_VPCMPEQQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2860, 240},
+    {I_VPCMPEQQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2870, 240},
+    {I_VPCMPEQQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2880, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTB[] = {
+    {I_VPCMPGTB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36924, 188},
+    {I_VPCMPGTB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36931, 188},
+    {I_VPCMPGTB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40074, 207},
+    {I_VPCMPGTB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40081, 207},
+    {I_VPCMPGTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22176, 244},
+    {I_VPCMPGTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22184, 244},
+    {I_VPCMPGTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22192, 245},
+    {I_VPCMPGTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3280, 244},
+    {I_VPCMPGTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3290, 244},
+    {I_VPCMPGTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3300, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTW[] = {
+    {I_VPCMPGTW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36938, 188},
+    {I_VPCMPGTW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36945, 188},
+    {I_VPCMPGTW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40088, 207},
+    {I_VPCMPGTW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40095, 207},
+    {I_VPCMPGTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22248, 244},
+    {I_VPCMPGTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22256, 244},
+    {I_VPCMPGTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22264, 245},
+    {I_VPCMPGTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3490, 244},
+    {I_VPCMPGTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3500, 244},
+    {I_VPCMPGTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3510, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTD[] = {
+    {I_VPCMPGTD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36952, 188},
+    {I_VPCMPGTD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36959, 188},
+    {I_VPCMPGTD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40102, 207},
+    {I_VPCMPGTD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40109, 207},
+    {I_VPCMPGTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22200, 240},
+    {I_VPCMPGTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22208, 240},
+    {I_VPCMPGTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22216, 241},
+    {I_VPCMPGTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3310, 240},
+    {I_VPCMPGTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3320, 240},
+    {I_VPCMPGTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3330, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTQ[] = {
+    {I_VPCMPGTQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36966, 188},
+    {I_VPCMPGTQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36973, 188},
+    {I_VPCMPGTQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40116, 207},
+    {I_VPCMPGTQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40123, 207},
+    {I_VPCMPGTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22224, 240},
+    {I_VPCMPGTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22232, 240},
+    {I_VPCMPGTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22240, 241},
+    {I_VPCMPGTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3340, 240},
+    {I_VPCMPGTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3350, 240},
+    {I_VPCMPGTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3360, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMILPD[] = {
+    {I_VPERMILPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36980, 188},
+    {I_VPERMILPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36987, 188},
+    {I_VPERMILPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36994, 188},
+    {I_VPERMILPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37001, 188},
+    {I_VPERMILPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13720, 188},
+    {I_VPERMILPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13728, 188},
+    {I_VPERMILPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9460, 240},
+    {I_VPERMILPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9469, 240},
+    {I_VPERMILPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9478, 241},
+    {I_VPERMILPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22640, 240},
+    {I_VPERMILPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22648, 240},
+    {I_VPERMILPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22656, 240},
+    {I_VPERMILPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22664, 240},
+    {I_VPERMILPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22672, 241},
+    {I_VPERMILPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22680, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMILPS[] = {
+    {I_VPERMILPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37008, 188},
+    {I_VPERMILPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37015, 188},
+    {I_VPERMILPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+37022, 188},
+    {I_VPERMILPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37029, 188},
+    {I_VPERMILPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13736, 188},
+    {I_VPERMILPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13744, 188},
+    {I_VPERMILPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9487, 240},
+    {I_VPERMILPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9496, 240},
+    {I_VPERMILPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9505, 241},
+    {I_VPERMILPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22688, 240},
+    {I_VPERMILPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22696, 240},
+    {I_VPERMILPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22704, 240},
+    {I_VPERMILPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22712, 240},
+    {I_VPERMILPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22720, 241},
+    {I_VPERMILPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22728, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERM2F128[] = {
+    {I_VPERM2F128, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13752, 188},
+    {I_VPERM2F128, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13760, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXTRB[] = {
+    {I_VPEXTRB, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13768, 194},
+    {I_VPEXTRB, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13768, 188},
+    {I_VPEXTRB, 3, {MEMORY|BITS8,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13768, 188},
+    {I_VPEXTRB, 3, {REG_GPR|BITS8,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    {I_VPEXTRB, 3, {REG_GPR|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    {I_VPEXTRB, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    {I_VPEXTRB, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    {I_VPEXTRB, 3, {MEMORY|BITS8,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXTRW[] = {
+    {I_VPEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13776, 194},
+    {I_VPEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13776, 188},
+    {I_VPEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13784, 194},
+    {I_VPEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13784, 188},
+    {I_VPEXTRW, 3, {MEMORY|BITS16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13784, 188},
+    {I_VPEXTRW, 3, {REG_GPR|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    {I_VPEXTRW, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    {I_VPEXTRW, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    {I_VPEXTRW, 3, {MEMORY|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    {I_VPEXTRW, 3, {REG_GPR|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9586, 245},
+    {I_VPEXTRW, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9586, 245},
+    {I_VPEXTRW, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9586, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXTRD[] = {
+    {I_VPEXTRD, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13792, 194},
+    {I_VPEXTRD, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13792, 188},
+    {I_VPEXTRD, 3, {RM_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9559, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXTRQ[] = {
+    {I_VPEXTRQ, 3, {RM_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13800, 194},
+    {I_VPEXTRQ, 3, {RM_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9568, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDW[] = {
+    {I_VPHADDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37036, 188},
+    {I_VPHADDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37043, 188},
+    {I_VPHADDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40130, 207},
+    {I_VPHADDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40137, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDD[] = {
+    {I_VPHADDD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37050, 188},
+    {I_VPHADDD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37057, 188},
+    {I_VPHADDD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40144, 207},
+    {I_VPHADDD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40151, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDSW[] = {
+    {I_VPHADDSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37064, 188},
+    {I_VPHADDSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37071, 188},
+    {I_VPHADDSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40158, 207},
+    {I_VPHADDSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40165, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHMINPOSUW[] = {
+    {I_VPHMINPOSUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37078, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHSUBW[] = {
+    {I_VPHSUBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37085, 188},
+    {I_VPHSUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37092, 188},
+    {I_VPHSUBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40172, 207},
+    {I_VPHSUBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40179, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHSUBD[] = {
+    {I_VPHSUBD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37099, 188},
+    {I_VPHSUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37106, 188},
+    {I_VPHSUBD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40186, 207},
+    {I_VPHSUBD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40193, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHSUBSW[] = {
+    {I_VPHSUBSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37113, 188},
+    {I_VPHSUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37120, 188},
+    {I_VPHSUBSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40200, 207},
+    {I_VPHSUBSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40207, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPINSRB[] = {
+    {I_VPINSRB, 4, {XMM_L16,XMM_L16,MEMORY|BITS8,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13808, 188},
+    {I_VPINSRB, 3, {XMM_L16,MEMORY|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13816, 188},
+    {I_VPINSRB, 4, {XMM_L16,XMM_L16,RM_GPR|BITS8,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13808, 188},
+    {I_VPINSRB, 3, {XMM_L16,RM_GPR|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13816, 188},
+    {I_VPINSRB, 4, {XMM_L16,XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13808, 188},
+    {I_VPINSRB, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13816, 188},
+    {I_VPINSRB, 4, {XMMREG,XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9703, 245},
+    {I_VPINSRB, 3, {XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9712, 245},
+    {I_VPINSRB, 4, {XMMREG,XMMREG,MEMORY|BITS8,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9703, 245},
+    {I_VPINSRB, 3, {XMMREG,MEMORY|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9712, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPINSRW[] = {
+    {I_VPINSRW, 4, {XMM_L16,XMM_L16,MEMORY|BITS16,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13824, 188},
+    {I_VPINSRW, 3, {XMM_L16,MEMORY|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13832, 188},
+    {I_VPINSRW, 4, {XMM_L16,XMM_L16,RM_GPR|BITS16,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13824, 188},
+    {I_VPINSRW, 3, {XMM_L16,RM_GPR|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13832, 188},
+    {I_VPINSRW, 4, {XMM_L16,XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13824, 188},
+    {I_VPINSRW, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13832, 188},
+    {I_VPINSRW, 4, {XMMREG,XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9757, 245},
+    {I_VPINSRW, 3, {XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9766, 245},
+    {I_VPINSRW, 4, {XMMREG,XMMREG,MEMORY|BITS16,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9757, 245},
+    {I_VPINSRW, 3, {XMMREG,MEMORY|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9766, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPINSRD[] = {
+    {I_VPINSRD, 4, {XMM_L16,XMM_L16,MEMORY|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13840, 188},
+    {I_VPINSRD, 3, {XMM_L16,MEMORY|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13848, 188},
+    {I_VPINSRD, 4, {XMM_L16,XMM_L16,RM_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13840, 188},
+    {I_VPINSRD, 3, {XMM_L16,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13848, 188},
+    {I_VPINSRD, 4, {XMMREG,XMMREG,RM_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9721, 243},
+    {I_VPINSRD, 3, {XMMREG,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9730, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPINSRQ[] = {
+    {I_VPINSRQ, 4, {XMM_L16,XMM_L16,MEMORY|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13856, 194},
+    {I_VPINSRQ, 3, {XMM_L16,MEMORY|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13864, 194},
+    {I_VPINSRQ, 4, {XMM_L16,XMM_L16,RM_GPR|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13856, 194},
+    {I_VPINSRQ, 3, {XMM_L16,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13864, 194},
+    {I_VPINSRQ, 4, {XMMREG,XMMREG,RM_GPR|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9739, 243},
+    {I_VPINSRQ, 3, {XMMREG,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9748, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADDWD[] = {
+    {I_VPMADDWD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37127, 188},
+    {I_VPMADDWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37134, 188},
+    {I_VPMADDWD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40228, 207},
+    {I_VPMADDWD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40235, 207},
+    {I_VPMADDWD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23216, 244},
+    {I_VPMADDWD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23224, 244},
+    {I_VPMADDWD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23232, 244},
+    {I_VPMADDWD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23240, 244},
+    {I_VPMADDWD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23248, 245},
+    {I_VPMADDWD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23256, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADDUBSW[] = {
+    {I_VPMADDUBSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37141, 188},
+    {I_VPMADDUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37148, 188},
+    {I_VPMADDUBSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40214, 207},
+    {I_VPMADDUBSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40221, 207},
+    {I_VPMADDUBSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23168, 244},
+    {I_VPMADDUBSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23176, 244},
+    {I_VPMADDUBSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23184, 244},
+    {I_VPMADDUBSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23192, 244},
+    {I_VPMADDUBSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23200, 245},
+    {I_VPMADDUBSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23208, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXSB[] = {
+    {I_VPMAXSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37155, 188},
+    {I_VPMAXSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37162, 188},
+    {I_VPMAXSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40242, 207},
+    {I_VPMAXSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40249, 207},
+    {I_VPMAXSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23264, 244},
+    {I_VPMAXSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23272, 244},
+    {I_VPMAXSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23280, 244},
+    {I_VPMAXSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23288, 244},
+    {I_VPMAXSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23296, 245},
+    {I_VPMAXSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23304, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXSW[] = {
+    {I_VPMAXSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37169, 188},
+    {I_VPMAXSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37176, 188},
+    {I_VPMAXSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40256, 207},
+    {I_VPMAXSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40263, 207},
+    {I_VPMAXSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23408, 244},
+    {I_VPMAXSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23416, 244},
+    {I_VPMAXSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23424, 244},
+    {I_VPMAXSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23432, 244},
+    {I_VPMAXSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23440, 245},
+    {I_VPMAXSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23448, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXSD[] = {
+    {I_VPMAXSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37183, 188},
+    {I_VPMAXSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37190, 188},
+    {I_VPMAXSD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40270, 207},
+    {I_VPMAXSD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40277, 207},
+    {I_VPMAXSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23312, 240},
+    {I_VPMAXSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23320, 240},
+    {I_VPMAXSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23328, 240},
+    {I_VPMAXSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23336, 240},
+    {I_VPMAXSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23344, 241},
+    {I_VPMAXSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23352, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXUB[] = {
+    {I_VPMAXUB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37197, 188},
+    {I_VPMAXUB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37204, 188},
+    {I_VPMAXUB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40284, 207},
+    {I_VPMAXUB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40291, 207},
+    {I_VPMAXUB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23456, 244},
+    {I_VPMAXUB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23464, 244},
+    {I_VPMAXUB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23472, 244},
+    {I_VPMAXUB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23480, 244},
+    {I_VPMAXUB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23488, 245},
+    {I_VPMAXUB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23496, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXUW[] = {
+    {I_VPMAXUW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37211, 188},
+    {I_VPMAXUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37218, 188},
+    {I_VPMAXUW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40298, 207},
+    {I_VPMAXUW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40305, 207},
+    {I_VPMAXUW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23600, 244},
+    {I_VPMAXUW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23608, 244},
+    {I_VPMAXUW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23616, 244},
+    {I_VPMAXUW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23624, 244},
+    {I_VPMAXUW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23632, 245},
+    {I_VPMAXUW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23640, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXUD[] = {
+    {I_VPMAXUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37225, 188},
+    {I_VPMAXUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37232, 188},
+    {I_VPMAXUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40312, 207},
+    {I_VPMAXUD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40319, 207},
+    {I_VPMAXUD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23504, 240},
+    {I_VPMAXUD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23512, 240},
+    {I_VPMAXUD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23520, 240},
+    {I_VPMAXUD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23528, 240},
+    {I_VPMAXUD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23536, 241},
+    {I_VPMAXUD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23544, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINSB[] = {
+    {I_VPMINSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37239, 188},
+    {I_VPMINSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37246, 188},
+    {I_VPMINSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40326, 207},
+    {I_VPMINSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40333, 207},
+    {I_VPMINSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23648, 244},
+    {I_VPMINSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23656, 244},
+    {I_VPMINSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23664, 244},
+    {I_VPMINSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23672, 244},
+    {I_VPMINSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23680, 245},
+    {I_VPMINSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23688, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINSW[] = {
+    {I_VPMINSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37253, 188},
+    {I_VPMINSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37260, 188},
+    {I_VPMINSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40340, 207},
+    {I_VPMINSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40347, 207},
+    {I_VPMINSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23792, 244},
+    {I_VPMINSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23800, 244},
+    {I_VPMINSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23808, 244},
+    {I_VPMINSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23816, 244},
+    {I_VPMINSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23824, 245},
+    {I_VPMINSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23832, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINSD[] = {
+    {I_VPMINSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37267, 188},
+    {I_VPMINSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37274, 188},
+    {I_VPMINSD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40354, 207},
+    {I_VPMINSD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40361, 207},
+    {I_VPMINSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23696, 240},
+    {I_VPMINSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23704, 240},
+    {I_VPMINSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23712, 240},
+    {I_VPMINSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23720, 240},
+    {I_VPMINSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23728, 241},
+    {I_VPMINSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23736, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINUB[] = {
+    {I_VPMINUB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37281, 188},
+    {I_VPMINUB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37288, 188},
+    {I_VPMINUB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40368, 207},
+    {I_VPMINUB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40375, 207},
+    {I_VPMINUB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23840, 244},
+    {I_VPMINUB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23848, 244},
+    {I_VPMINUB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23856, 244},
+    {I_VPMINUB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23864, 244},
+    {I_VPMINUB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23872, 245},
+    {I_VPMINUB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23880, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINUW[] = {
+    {I_VPMINUW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37295, 188},
+    {I_VPMINUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37302, 188},
+    {I_VPMINUW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40382, 207},
+    {I_VPMINUW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40389, 207},
+    {I_VPMINUW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23984, 244},
+    {I_VPMINUW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23992, 244},
+    {I_VPMINUW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24000, 244},
+    {I_VPMINUW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24008, 244},
+    {I_VPMINUW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24016, 245},
+    {I_VPMINUW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24024, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINUD[] = {
+    {I_VPMINUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37309, 188},
+    {I_VPMINUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37316, 188},
+    {I_VPMINUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40396, 207},
+    {I_VPMINUD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40403, 207},
+    {I_VPMINUD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23888, 240},
+    {I_VPMINUD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23896, 240},
+    {I_VPMINUD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23904, 240},
+    {I_VPMINUD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23912, 240},
+    {I_VPMINUD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23920, 241},
+    {I_VPMINUD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23928, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVMSKB[] = {
+    {I_VPMOVMSKB, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37323, 194},
+    {I_VPMOVMSKB, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37323, 188},
+    {I_VPMOVMSKB, 2, {REG_GPR|BITS32,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40410, 207},
+    {I_VPMOVMSKB, 2, {REG_GPR|BITS64,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40410, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSXBW[] = {
+    {I_VPMOVSXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37330, 188},
+    {I_VPMOVSXBW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40417, 207},
+    {I_VPMOVSXBW, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24776, 244},
+    {I_VPMOVSXBW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24784, 244},
+    {I_VPMOVSXBW, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24792, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSXBD[] = {
+    {I_VPMOVSXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37337, 188},
+    {I_VPMOVSXBD, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40424, 207},
+    {I_VPMOVSXBD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40424, 207},
+    {I_VPMOVSXBD, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24728, 240},
+    {I_VPMOVSXBD, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24736, 240},
+    {I_VPMOVSXBD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24744, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSXBQ[] = {
+    {I_VPMOVSXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37344, 188},
+    {I_VPMOVSXBQ, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+40431, 207},
+    {I_VPMOVSXBQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40431, 207},
+    {I_VPMOVSXBQ, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24752, 240},
+    {I_VPMOVSXBQ, 2, {YMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24760, 240},
+    {I_VPMOVSXBQ, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24768, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSXWD[] = {
+    {I_VPMOVSXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37351, 188},
+    {I_VPMOVSXWD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40438, 207},
+    {I_VPMOVSXWD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24824, 240},
+    {I_VPMOVSXWD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24832, 240},
+    {I_VPMOVSXWD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24840, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSXWQ[] = {
+    {I_VPMOVSXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37358, 188},
+    {I_VPMOVSXWQ, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40445, 207},
+    {I_VPMOVSXWQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40445, 207},
+    {I_VPMOVSXWQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24848, 240},
+    {I_VPMOVSXWQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24856, 240},
+    {I_VPMOVSXWQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24864, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSXDQ[] = {
+    {I_VPMOVSXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37365, 188},
+    {I_VPMOVSXDQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40452, 207},
+    {I_VPMOVSXDQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24800, 240},
+    {I_VPMOVSXDQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24808, 240},
+    {I_VPMOVSXDQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24816, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVZXBW[] = {
+    {I_VPMOVZXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37372, 188},
+    {I_VPMOVZXBW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40459, 207},
+    {I_VPMOVZXBW, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25280, 244},
+    {I_VPMOVZXBW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25288, 244},
+    {I_VPMOVZXBW, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25296, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVZXBD[] = {
+    {I_VPMOVZXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37379, 188},
+    {I_VPMOVZXBD, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40466, 207},
+    {I_VPMOVZXBD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40466, 207},
+    {I_VPMOVZXBD, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25232, 240},
+    {I_VPMOVZXBD, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25240, 240},
+    {I_VPMOVZXBD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25248, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVZXBQ[] = {
+    {I_VPMOVZXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37386, 188},
+    {I_VPMOVZXBQ, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+40473, 207},
+    {I_VPMOVZXBQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40473, 207},
+    {I_VPMOVZXBQ, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25256, 240},
+    {I_VPMOVZXBQ, 2, {YMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25264, 240},
+    {I_VPMOVZXBQ, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25272, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVZXWD[] = {
+    {I_VPMOVZXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37393, 188},
+    {I_VPMOVZXWD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40480, 207},
+    {I_VPMOVZXWD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25328, 240},
+    {I_VPMOVZXWD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25336, 240},
+    {I_VPMOVZXWD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25344, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVZXWQ[] = {
+    {I_VPMOVZXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37400, 188},
+    {I_VPMOVZXWQ, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40487, 207},
+    {I_VPMOVZXWQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40487, 207},
+    {I_VPMOVZXWQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25352, 240},
+    {I_VPMOVZXWQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25360, 240},
+    {I_VPMOVZXWQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25368, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVZXDQ[] = {
+    {I_VPMOVZXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37407, 188},
+    {I_VPMOVZXDQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40494, 207},
+    {I_VPMOVZXDQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25304, 240},
+    {I_VPMOVZXDQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25312, 240},
+    {I_VPMOVZXDQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25320, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULHUW[] = {
+    {I_VPMULHUW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37414, 188},
+    {I_VPMULHUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37421, 188},
+    {I_VPMULHUW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40529, 207},
+    {I_VPMULHUW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40536, 207},
+    {I_VPMULHUW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25472, 244},
+    {I_VPMULHUW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25480, 244},
+    {I_VPMULHUW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25488, 244},
+    {I_VPMULHUW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25496, 244},
+    {I_VPMULHUW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25504, 245},
+    {I_VPMULHUW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25512, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULHRSW[] = {
+    {I_VPMULHRSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37428, 188},
+    {I_VPMULHRSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37435, 188},
+    {I_VPMULHRSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40515, 207},
+    {I_VPMULHRSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40522, 207},
+    {I_VPMULHRSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25424, 244},
+    {I_VPMULHRSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25432, 244},
+    {I_VPMULHRSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25440, 244},
+    {I_VPMULHRSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25448, 244},
+    {I_VPMULHRSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25456, 245},
+    {I_VPMULHRSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25464, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULHW[] = {
+    {I_VPMULHW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37442, 188},
+    {I_VPMULHW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37449, 188},
+    {I_VPMULHW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40543, 207},
+    {I_VPMULHW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40550, 207},
+    {I_VPMULHW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25520, 244},
+    {I_VPMULHW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25528, 244},
+    {I_VPMULHW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25536, 244},
+    {I_VPMULHW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25544, 244},
+    {I_VPMULHW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25552, 245},
+    {I_VPMULHW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25560, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULLW[] = {
+    {I_VPMULLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37456, 188},
+    {I_VPMULLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37463, 188},
+    {I_VPMULLW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40557, 207},
+    {I_VPMULLW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40564, 207},
+    {I_VPMULLW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25664, 244},
+    {I_VPMULLW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25672, 244},
+    {I_VPMULLW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25680, 244},
+    {I_VPMULLW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25688, 244},
+    {I_VPMULLW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25696, 245},
+    {I_VPMULLW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25704, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULLD[] = {
+    {I_VPMULLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37470, 188},
+    {I_VPMULLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37477, 188},
+    {I_VPMULLD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40571, 207},
+    {I_VPMULLD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40578, 207},
+    {I_VPMULLD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25568, 240},
+    {I_VPMULLD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25576, 240},
+    {I_VPMULLD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25584, 240},
+    {I_VPMULLD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25592, 240},
+    {I_VPMULLD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25600, 241},
+    {I_VPMULLD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25608, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULUDQ[] = {
+    {I_VPMULUDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37484, 188},
+    {I_VPMULUDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37491, 188},
+    {I_VPMULUDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40585, 207},
+    {I_VPMULUDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40592, 207},
+    {I_VPMULUDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25760, 240},
+    {I_VPMULUDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25768, 240},
+    {I_VPMULUDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25776, 240},
+    {I_VPMULUDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25784, 240},
+    {I_VPMULUDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25792, 241},
+    {I_VPMULUDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25800, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULDQ[] = {
+    {I_VPMULDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37498, 188},
+    {I_VPMULDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37505, 188},
+    {I_VPMULDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40501, 207},
+    {I_VPMULDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40508, 207},
+    {I_VPMULDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25376, 240},
+    {I_VPMULDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25384, 240},
+    {I_VPMULDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25392, 240},
+    {I_VPMULDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25400, 240},
+    {I_VPMULDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25408, 241},
+    {I_VPMULDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25416, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPOR[] = {
+    {I_VPOR, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37512, 188},
+    {I_VPOR, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37519, 188},
+    {I_VPOR, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40599, 207},
+    {I_VPOR, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40606, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSADBW[] = {
+    {I_VPSADBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37526, 188},
+    {I_VPSADBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37533, 188},
+    {I_VPSADBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40613, 207},
+    {I_VPSADBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40620, 207},
+    {I_VPSADBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+26096, 244},
+    {I_VPSADBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+26104, 244},
+    {I_VPSADBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+26112, 244},
+    {I_VPSADBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+26120, 244},
+    {I_VPSADBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+26128, 245},
+    {I_VPSADBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+26136, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHUFB[] = {
+    {I_VPSHUFB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37540, 188},
+    {I_VPSHUFB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37547, 188},
+    {I_VPSHUFB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40627, 207},
+    {I_VPSHUFB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40634, 207},
+    {I_VPSHUFB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26144, 244},
+    {I_VPSHUFB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26152, 244},
+    {I_VPSHUFB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26160, 244},
+    {I_VPSHUFB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26168, 244},
+    {I_VPSHUFB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26176, 245},
+    {I_VPSHUFB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26184, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHUFD[] = {
+    {I_VPSHUFD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13872, 188},
+    {I_VPSHUFD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15872, 207},
+    {I_VPSHUFD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10099, 240},
+    {I_VPSHUFD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10108, 240},
+    {I_VPSHUFD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10117, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHUFHW[] = {
+    {I_VPSHUFHW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13880, 188},
+    {I_VPSHUFHW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15880, 207},
+    {I_VPSHUFHW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10126, 244},
+    {I_VPSHUFHW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10135, 244},
+    {I_VPSHUFHW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10144, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHUFLW[] = {
+    {I_VPSHUFLW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13888, 188},
+    {I_VPSHUFLW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15888, 207},
+    {I_VPSHUFLW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10153, 244},
+    {I_VPSHUFLW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10162, 244},
+    {I_VPSHUFLW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10171, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSIGNB[] = {
+    {I_VPSIGNB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37554, 188},
+    {I_VPSIGNB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37561, 188},
+    {I_VPSIGNB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40641, 207},
+    {I_VPSIGNB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40648, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSIGNW[] = {
+    {I_VPSIGNW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37568, 188},
+    {I_VPSIGNW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37575, 188},
+    {I_VPSIGNW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40655, 207},
+    {I_VPSIGNW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40662, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSIGND[] = {
+    {I_VPSIGND, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37582, 188},
+    {I_VPSIGND, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37589, 188},
+    {I_VPSIGND, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40669, 207},
+    {I_VPSIGND, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40676, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLDQ[] = {
+    {I_VPSLLDQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13896, 188},
+    {I_VPSLLDQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13904, 188},
+    {I_VPSLLDQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15896, 207},
+    {I_VPSLLDQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15904, 207},
+    {I_VPSLLDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10234, 244},
+    {I_VPSLLDQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10243, 244},
+    {I_VPSLLDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10252, 244},
+    {I_VPSLLDQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10261, 244},
+    {I_VPSLLDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10270, 245},
+    {I_VPSLLDQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10279, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLDQ[] = {
+    {I_VPSRLDQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13912, 188},
+    {I_VPSRLDQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13920, 188},
+    {I_VPSRLDQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15992, 207},
+    {I_VPSRLDQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16000, 207},
+    {I_VPSRLDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10612, 244},
+    {I_VPSRLDQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10621, 244},
+    {I_VPSRLDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10630, 244},
+    {I_VPSRLDQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10639, 244},
+    {I_VPSRLDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10648, 245},
+    {I_VPSRLDQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10657, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLW[] = {
+    {I_VPSLLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37596, 188},
+    {I_VPSLLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37603, 188},
+    {I_VPSLLW, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13928, 188},
+    {I_VPSLLW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13936, 188},
+    {I_VPSLLW, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40683, 207},
+    {I_VPSLLW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40690, 207},
+    {I_VPSLLW, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15912, 207},
+    {I_VPSLLW, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15920, 207},
+    {I_VPSLLW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26432, 244},
+    {I_VPSLLW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26440, 244},
+    {I_VPSLLW, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26448, 244},
+    {I_VPSLLW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26456, 244},
+    {I_VPSLLW, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26464, 245},
+    {I_VPSLLW, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26472, 245},
+    {I_VPSLLW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10342, 244},
+    {I_VPSLLW, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10351, 244},
+    {I_VPSLLW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10360, 244},
+    {I_VPSLLW, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10369, 244},
+    {I_VPSLLW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10378, 245},
+    {I_VPSLLW, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10387, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLD[] = {
+    {I_VPSLLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37610, 188},
+    {I_VPSLLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37617, 188},
+    {I_VPSLLD, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13944, 188},
+    {I_VPSLLD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13952, 188},
+    {I_VPSLLD, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40697, 207},
+    {I_VPSLLD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40704, 207},
+    {I_VPSLLD, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15928, 207},
+    {I_VPSLLD, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15936, 207},
+    {I_VPSLLD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26192, 240},
+    {I_VPSLLD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26200, 240},
+    {I_VPSLLD, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26208, 240},
+    {I_VPSLLD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26216, 240},
+    {I_VPSLLD, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26224, 241},
+    {I_VPSLLD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26232, 241},
+    {I_VPSLLD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10180, 240},
+    {I_VPSLLD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10189, 240},
+    {I_VPSLLD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10198, 240},
+    {I_VPSLLD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10207, 240},
+    {I_VPSLLD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10216, 241},
+    {I_VPSLLD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10225, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLQ[] = {
+    {I_VPSLLQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37624, 188},
+    {I_VPSLLQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37631, 188},
+    {I_VPSLLQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13960, 188},
+    {I_VPSLLQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13968, 188},
+    {I_VPSLLQ, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40711, 207},
+    {I_VPSLLQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40718, 207},
+    {I_VPSLLQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15944, 207},
+    {I_VPSLLQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15952, 207},
+    {I_VPSLLQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26240, 240},
+    {I_VPSLLQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26248, 240},
+    {I_VPSLLQ, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26256, 240},
+    {I_VPSLLQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26264, 240},
+    {I_VPSLLQ, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26272, 241},
+    {I_VPSLLQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26280, 241},
+    {I_VPSLLQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10288, 240},
+    {I_VPSLLQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10297, 240},
+    {I_VPSLLQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10306, 240},
+    {I_VPSLLQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10315, 240},
+    {I_VPSLLQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10324, 241},
+    {I_VPSLLQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10333, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRAW[] = {
+    {I_VPSRAW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37638, 188},
+    {I_VPSRAW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37645, 188},
+    {I_VPSRAW, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13976, 188},
+    {I_VPSRAW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13984, 188},
+    {I_VPSRAW, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40725, 207},
+    {I_VPSRAW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40732, 207},
+    {I_VPSRAW, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15960, 207},
+    {I_VPSRAW, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15968, 207},
+    {I_VPSRAW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26720, 244},
+    {I_VPSRAW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26728, 244},
+    {I_VPSRAW, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26736, 244},
+    {I_VPSRAW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26744, 244},
+    {I_VPSRAW, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26752, 245},
+    {I_VPSRAW, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26760, 245},
+    {I_VPSRAW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10504, 244},
+    {I_VPSRAW, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10513, 244},
+    {I_VPSRAW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10522, 244},
+    {I_VPSRAW, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10531, 244},
+    {I_VPSRAW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10540, 245},
+    {I_VPSRAW, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10549, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRAD[] = {
+    {I_VPSRAD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37652, 188},
+    {I_VPSRAD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37659, 188},
+    {I_VPSRAD, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13992, 188},
+    {I_VPSRAD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14000, 188},
+    {I_VPSRAD, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40739, 207},
+    {I_VPSRAD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40746, 207},
+    {I_VPSRAD, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15976, 207},
+    {I_VPSRAD, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15984, 207},
+    {I_VPSRAD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26480, 240},
+    {I_VPSRAD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26488, 240},
+    {I_VPSRAD, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26496, 240},
+    {I_VPSRAD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26504, 240},
+    {I_VPSRAD, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26512, 241},
+    {I_VPSRAD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26520, 241},
+    {I_VPSRAD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10396, 240},
+    {I_VPSRAD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10405, 240},
+    {I_VPSRAD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10414, 240},
+    {I_VPSRAD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10423, 240},
+    {I_VPSRAD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10432, 241},
+    {I_VPSRAD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10441, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLW[] = {
+    {I_VPSRLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37666, 188},
+    {I_VPSRLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37673, 188},
+    {I_VPSRLW, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14008, 188},
+    {I_VPSRLW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14016, 188},
+    {I_VPSRLW, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40753, 207},
+    {I_VPSRLW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40760, 207},
+    {I_VPSRLW, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16008, 207},
+    {I_VPSRLW, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16016, 207},
+    {I_VPSRLW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27008, 244},
+    {I_VPSRLW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27016, 244},
+    {I_VPSRLW, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27024, 244},
+    {I_VPSRLW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27032, 244},
+    {I_VPSRLW, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27040, 245},
+    {I_VPSRLW, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27048, 245},
+    {I_VPSRLW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10720, 244},
+    {I_VPSRLW, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10729, 244},
+    {I_VPSRLW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10738, 244},
+    {I_VPSRLW, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10747, 244},
+    {I_VPSRLW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10756, 245},
+    {I_VPSRLW, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10765, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLD[] = {
+    {I_VPSRLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37680, 188},
+    {I_VPSRLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37687, 188},
+    {I_VPSRLD, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14024, 188},
+    {I_VPSRLD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14032, 188},
+    {I_VPSRLD, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40767, 207},
+    {I_VPSRLD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40774, 207},
+    {I_VPSRLD, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16024, 207},
+    {I_VPSRLD, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16032, 207},
+    {I_VPSRLD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26768, 240},
+    {I_VPSRLD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26776, 240},
+    {I_VPSRLD, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26784, 240},
+    {I_VPSRLD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26792, 240},
+    {I_VPSRLD, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26800, 241},
+    {I_VPSRLD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26808, 241},
+    {I_VPSRLD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10558, 240},
+    {I_VPSRLD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10567, 240},
+    {I_VPSRLD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10576, 240},
+    {I_VPSRLD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10585, 240},
+    {I_VPSRLD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10594, 241},
+    {I_VPSRLD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10603, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLQ[] = {
+    {I_VPSRLQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37694, 188},
+    {I_VPSRLQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37701, 188},
+    {I_VPSRLQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14040, 188},
+    {I_VPSRLQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14048, 188},
+    {I_VPSRLQ, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40781, 207},
+    {I_VPSRLQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40788, 207},
+    {I_VPSRLQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16040, 207},
+    {I_VPSRLQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16048, 207},
+    {I_VPSRLQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26816, 240},
+    {I_VPSRLQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26824, 240},
+    {I_VPSRLQ, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26832, 240},
+    {I_VPSRLQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26840, 240},
+    {I_VPSRLQ, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26848, 241},
+    {I_VPSRLQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26856, 241},
+    {I_VPSRLQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10666, 240},
+    {I_VPSRLQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10675, 240},
+    {I_VPSRLQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10684, 240},
+    {I_VPSRLQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10693, 240},
+    {I_VPSRLQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10702, 241},
+    {I_VPSRLQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10711, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTEST[] = {
+    {I_VPTEST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37708, 188},
+    {I_VPTEST, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37715, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBB[] = {
+    {I_VPSUBB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37722, 188},
+    {I_VPSUBB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37729, 188},
+    {I_VPSUBB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40795, 207},
+    {I_VPSUBB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40802, 207},
+    {I_VPSUBB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27056, 244},
+    {I_VPSUBB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27064, 244},
+    {I_VPSUBB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27072, 244},
+    {I_VPSUBB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27080, 244},
+    {I_VPSUBB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27088, 245},
+    {I_VPSUBB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27096, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBW[] = {
+    {I_VPSUBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37736, 188},
+    {I_VPSUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37743, 188},
+    {I_VPSUBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40809, 207},
+    {I_VPSUBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40816, 207},
+    {I_VPSUBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27392, 244},
+    {I_VPSUBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27400, 244},
+    {I_VPSUBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27408, 244},
+    {I_VPSUBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27416, 244},
+    {I_VPSUBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27424, 245},
+    {I_VPSUBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27432, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBD[] = {
+    {I_VPSUBD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37750, 188},
+    {I_VPSUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37757, 188},
+    {I_VPSUBD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40823, 207},
+    {I_VPSUBD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40830, 207},
+    {I_VPSUBD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27104, 240},
+    {I_VPSUBD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27112, 240},
+    {I_VPSUBD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27120, 240},
+    {I_VPSUBD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27128, 240},
+    {I_VPSUBD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27136, 241},
+    {I_VPSUBD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27144, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBQ[] = {
+    {I_VPSUBQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37764, 188},
+    {I_VPSUBQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37771, 188},
+    {I_VPSUBQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40837, 207},
+    {I_VPSUBQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40844, 207},
+    {I_VPSUBQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27152, 240},
+    {I_VPSUBQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27160, 240},
+    {I_VPSUBQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27168, 240},
+    {I_VPSUBQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27176, 240},
+    {I_VPSUBQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27184, 241},
+    {I_VPSUBQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27192, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBSB[] = {
+    {I_VPSUBSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37778, 188},
+    {I_VPSUBSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37785, 188},
+    {I_VPSUBSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40851, 207},
+    {I_VPSUBSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40858, 207},
+    {I_VPSUBSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27200, 244},
+    {I_VPSUBSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27208, 244},
+    {I_VPSUBSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27216, 244},
+    {I_VPSUBSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27224, 244},
+    {I_VPSUBSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27232, 245},
+    {I_VPSUBSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27240, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBSW[] = {
+    {I_VPSUBSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37792, 188},
+    {I_VPSUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37799, 188},
+    {I_VPSUBSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40865, 207},
+    {I_VPSUBSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40872, 207},
+    {I_VPSUBSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27248, 244},
+    {I_VPSUBSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27256, 244},
+    {I_VPSUBSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27264, 244},
+    {I_VPSUBSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27272, 244},
+    {I_VPSUBSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27280, 245},
+    {I_VPSUBSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27288, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBUSB[] = {
+    {I_VPSUBUSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37806, 188},
+    {I_VPSUBUSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37813, 188},
+    {I_VPSUBUSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40879, 207},
+    {I_VPSUBUSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40886, 207},
+    {I_VPSUBUSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27296, 244},
+    {I_VPSUBUSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27304, 244},
+    {I_VPSUBUSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27312, 244},
+    {I_VPSUBUSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27320, 244},
+    {I_VPSUBUSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27328, 245},
+    {I_VPSUBUSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27336, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSUBUSW[] = {
+    {I_VPSUBUSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37820, 188},
+    {I_VPSUBUSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37827, 188},
+    {I_VPSUBUSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40893, 207},
+    {I_VPSUBUSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40900, 207},
+    {I_VPSUBUSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27344, 244},
+    {I_VPSUBUSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27352, 244},
+    {I_VPSUBUSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27360, 244},
+    {I_VPSUBUSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27368, 244},
+    {I_VPSUBUSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27376, 245},
+    {I_VPSUBUSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27384, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKHBW[] = {
+    {I_VPUNPCKHBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37834, 188},
+    {I_VPUNPCKHBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37841, 188},
+    {I_VPUNPCKHBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40907, 207},
+    {I_VPUNPCKHBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40914, 207},
+    {I_VPUNPCKHBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27632, 244},
+    {I_VPUNPCKHBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27640, 244},
+    {I_VPUNPCKHBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27648, 244},
+    {I_VPUNPCKHBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27656, 244},
+    {I_VPUNPCKHBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27664, 245},
+    {I_VPUNPCKHBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27672, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKHWD[] = {
+    {I_VPUNPCKHWD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37848, 188},
+    {I_VPUNPCKHWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37855, 188},
+    {I_VPUNPCKHWD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40921, 207},
+    {I_VPUNPCKHWD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40928, 207},
+    {I_VPUNPCKHWD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27776, 244},
+    {I_VPUNPCKHWD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27784, 244},
+    {I_VPUNPCKHWD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27792, 244},
+    {I_VPUNPCKHWD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27800, 244},
+    {I_VPUNPCKHWD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27808, 245},
+    {I_VPUNPCKHWD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27816, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKHDQ[] = {
+    {I_VPUNPCKHDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37862, 188},
+    {I_VPUNPCKHDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37869, 188},
+    {I_VPUNPCKHDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40935, 207},
+    {I_VPUNPCKHDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40942, 207},
+    {I_VPUNPCKHDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27680, 240},
+    {I_VPUNPCKHDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27688, 240},
+    {I_VPUNPCKHDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27696, 240},
+    {I_VPUNPCKHDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27704, 240},
+    {I_VPUNPCKHDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27712, 241},
+    {I_VPUNPCKHDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27720, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKHQDQ[] = {
+    {I_VPUNPCKHQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37876, 188},
+    {I_VPUNPCKHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37883, 188},
+    {I_VPUNPCKHQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40949, 207},
+    {I_VPUNPCKHQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40956, 207},
+    {I_VPUNPCKHQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27728, 240},
+    {I_VPUNPCKHQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27736, 240},
+    {I_VPUNPCKHQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27744, 240},
+    {I_VPUNPCKHQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27752, 240},
+    {I_VPUNPCKHQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27760, 241},
+    {I_VPUNPCKHQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27768, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKLBW[] = {
+    {I_VPUNPCKLBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37890, 188},
+    {I_VPUNPCKLBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37897, 188},
+    {I_VPUNPCKLBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40963, 207},
+    {I_VPUNPCKLBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40970, 207},
+    {I_VPUNPCKLBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27824, 244},
+    {I_VPUNPCKLBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27832, 244},
+    {I_VPUNPCKLBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27840, 244},
+    {I_VPUNPCKLBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27848, 244},
+    {I_VPUNPCKLBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27856, 245},
+    {I_VPUNPCKLBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27864, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKLWD[] = {
+    {I_VPUNPCKLWD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37904, 188},
+    {I_VPUNPCKLWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37911, 188},
+    {I_VPUNPCKLWD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40977, 207},
+    {I_VPUNPCKLWD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40984, 207},
+    {I_VPUNPCKLWD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27968, 244},
+    {I_VPUNPCKLWD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27976, 244},
+    {I_VPUNPCKLWD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27984, 244},
+    {I_VPUNPCKLWD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27992, 244},
+    {I_VPUNPCKLWD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28000, 245},
+    {I_VPUNPCKLWD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28008, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKLDQ[] = {
+    {I_VPUNPCKLDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37918, 188},
+    {I_VPUNPCKLDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37925, 188},
+    {I_VPUNPCKLDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40991, 207},
+    {I_VPUNPCKLDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40998, 207},
+    {I_VPUNPCKLDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27872, 240},
+    {I_VPUNPCKLDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27880, 240},
+    {I_VPUNPCKLDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27888, 240},
+    {I_VPUNPCKLDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27896, 240},
+    {I_VPUNPCKLDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27904, 241},
+    {I_VPUNPCKLDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27912, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPUNPCKLQDQ[] = {
+    {I_VPUNPCKLQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37932, 188},
+    {I_VPUNPCKLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37939, 188},
+    {I_VPUNPCKLQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41005, 207},
+    {I_VPUNPCKLQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41012, 207},
+    {I_VPUNPCKLQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27920, 240},
+    {I_VPUNPCKLQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27928, 240},
+    {I_VPUNPCKLQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27936, 240},
+    {I_VPUNPCKLQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27944, 240},
+    {I_VPUNPCKLQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27952, 241},
+    {I_VPUNPCKLQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27960, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPXOR[] = {
+    {I_VPXOR, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37946, 188},
+    {I_VPXOR, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37953, 188},
+    {I_VPXOR, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41019, 207},
+    {I_VPXOR, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41026, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCPPS[] = {
+    {I_VRCPPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37960, 188},
+    {I_VRCPPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37967, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCPSS[] = {
+    {I_VRCPSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+37974, 188},
+    {I_VRCPSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37981, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRTPS[] = {
+    {I_VRSQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37988, 188},
+    {I_VRSQRTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37995, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRTSS[] = {
+    {I_VRSQRTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38002, 188},
+    {I_VRSQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38009, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VROUNDPD[] = {
+    {I_VROUNDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14056, 188},
+    {I_VROUNDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14064, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VROUNDPS[] = {
+    {I_VROUNDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14072, 188},
+    {I_VROUNDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14080, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VROUNDSD[] = {
+    {I_VROUNDSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14088, 188},
+    {I_VROUNDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14096, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VROUNDSS[] = {
+    {I_VROUNDSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14104, 188},
+    {I_VROUNDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14112, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSHUFPD[] = {
+    {I_VSHUFPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14120, 188},
+    {I_VSHUFPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14128, 188},
+    {I_VSHUFPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14136, 188},
+    {I_VSHUFPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14144, 188},
+    {I_VSHUFPD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11476, 240},
+    {I_VSHUFPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11485, 240},
+    {I_VSHUFPD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11494, 240},
+    {I_VSHUFPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11503, 240},
+    {I_VSHUFPD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11512, 241},
+    {I_VSHUFPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11521, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSHUFPS[] = {
+    {I_VSHUFPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14152, 188},
+    {I_VSHUFPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14160, 188},
+    {I_VSHUFPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14168, 188},
+    {I_VSHUFPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14176, 188},
+    {I_VSHUFPS, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11530, 240},
+    {I_VSHUFPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11539, 240},
+    {I_VSHUFPS, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11548, 240},
+    {I_VSHUFPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11557, 240},
+    {I_VSHUFPS, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11566, 241},
+    {I_VSHUFPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11575, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSQRTPD[] = {
+    {I_VSQRTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38016, 188},
+    {I_VSQRTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38023, 188},
+    {I_VSQRTPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28496, 240},
+    {I_VSQRTPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28504, 240},
+    {I_VSQRTPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+28512, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSQRTPS[] = {
+    {I_VSQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38030, 188},
+    {I_VSQRTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38037, 188},
+    {I_VSQRTPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28520, 240},
+    {I_VSQRTPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28528, 240},
+    {I_VSQRTPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+28536, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSQRTSD[] = {
+    {I_VSQRTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38044, 188},
+    {I_VSQRTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+38051, 188},
+    {I_VSQRTSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28544, 241},
+    {I_VSQRTSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28552, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSQRTSS[] = {
+    {I_VSQRTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38058, 188},
+    {I_VSQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38065, 188},
+    {I_VSQRTSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28560, 241},
+    {I_VSQRTSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28568, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSTMXCSR[] = {
+    {I_VSTMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+38072, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSUBPD[] = {
+    {I_VSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38079, 188},
+    {I_VSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38086, 188},
+    {I_VSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38093, 188},
+    {I_VSUBPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38100, 188},
+    {I_VSUBPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28576, 240},
+    {I_VSUBPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28584, 240},
+    {I_VSUBPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28592, 240},
+    {I_VSUBPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28600, 240},
+    {I_VSUBPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+28608, 241},
+    {I_VSUBPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+28616, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSUBPS[] = {
+    {I_VSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38107, 188},
+    {I_VSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38114, 188},
+    {I_VSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38121, 188},
+    {I_VSUBPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38128, 188},
+    {I_VSUBPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28624, 240},
+    {I_VSUBPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28632, 240},
+    {I_VSUBPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28640, 240},
+    {I_VSUBPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28648, 240},
+    {I_VSUBPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+28656, 241},
+    {I_VSUBPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+28664, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSUBSD[] = {
+    {I_VSUBSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38135, 188},
+    {I_VSUBSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+38142, 188},
+    {I_VSUBSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28672, 241},
+    {I_VSUBSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28680, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSUBSS[] = {
+    {I_VSUBSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38149, 188},
+    {I_VSUBSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38156, 188},
+    {I_VSUBSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28688, 241},
+    {I_VSUBSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28696, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VTESTPS[] = {
+    {I_VTESTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38163, 188},
+    {I_VTESTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38170, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VTESTPD[] = {
+    {I_VTESTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38177, 188},
+    {I_VTESTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38184, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUCOMISD[] = {
+    {I_VUCOMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+38191, 188},
+    {I_VUCOMISD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+28704, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUCOMISS[] = {
+    {I_VUCOMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38198, 188},
+    {I_VUCOMISS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+28712, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUNPCKHPD[] = {
+    {I_VUNPCKHPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38205, 188},
+    {I_VUNPCKHPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38212, 188},
+    {I_VUNPCKHPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38219, 188},
+    {I_VUNPCKHPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38226, 188},
+    {I_VUNPCKHPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28720, 240},
+    {I_VUNPCKHPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28728, 240},
+    {I_VUNPCKHPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28736, 240},
+    {I_VUNPCKHPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28744, 240},
+    {I_VUNPCKHPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28752, 241},
+    {I_VUNPCKHPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28760, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUNPCKHPS[] = {
+    {I_VUNPCKHPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38233, 188},
+    {I_VUNPCKHPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38240, 188},
+    {I_VUNPCKHPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38247, 188},
+    {I_VUNPCKHPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38254, 188},
+    {I_VUNPCKHPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28768, 240},
+    {I_VUNPCKHPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28776, 240},
+    {I_VUNPCKHPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28784, 240},
+    {I_VUNPCKHPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28792, 240},
+    {I_VUNPCKHPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28800, 241},
+    {I_VUNPCKHPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28808, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUNPCKLPD[] = {
+    {I_VUNPCKLPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38261, 188},
+    {I_VUNPCKLPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38268, 188},
+    {I_VUNPCKLPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38275, 188},
+    {I_VUNPCKLPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38282, 188},
+    {I_VUNPCKLPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28816, 240},
+    {I_VUNPCKLPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28824, 240},
+    {I_VUNPCKLPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28832, 240},
+    {I_VUNPCKLPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28840, 240},
+    {I_VUNPCKLPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28848, 241},
+    {I_VUNPCKLPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28856, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUNPCKLPS[] = {
+    {I_VUNPCKLPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38289, 188},
+    {I_VUNPCKLPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38296, 188},
+    {I_VUNPCKLPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38303, 188},
+    {I_VUNPCKLPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38310, 188},
+    {I_VUNPCKLPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28864, 240},
+    {I_VUNPCKLPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28872, 240},
+    {I_VUNPCKLPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28880, 240},
+    {I_VUNPCKLPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28888, 240},
+    {I_VUNPCKLPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28896, 241},
+    {I_VUNPCKLPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28904, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VXORPD[] = {
+    {I_VXORPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38317, 188},
+    {I_VXORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38324, 188},
+    {I_VXORPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38331, 188},
+    {I_VXORPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38338, 188},
+    {I_VXORPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28912, 242},
+    {I_VXORPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28920, 242},
+    {I_VXORPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28928, 242},
+    {I_VXORPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28936, 242},
+    {I_VXORPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28944, 243},
+    {I_VXORPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28952, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VXORPS[] = {
+    {I_VXORPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38345, 188},
+    {I_VXORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38352, 188},
+    {I_VXORPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38359, 188},
+    {I_VXORPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38366, 188},
+    {I_VXORPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28960, 242},
+    {I_VXORPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28968, 242},
+    {I_VXORPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28976, 242},
+    {I_VXORPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28984, 242},
+    {I_VXORPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28992, 243},
+    {I_VXORPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29000, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VZEROALL[] = {
+    {I_VZEROALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45759, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VZEROUPPER[] = {
+    {I_VZEROUPPER, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45765, 188},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCLMULLQLQDQ[] = {
+    {I_PCLMULLQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7768, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCLMULHQLQDQ[] = {
+    {I_PCLMULHQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7777, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCLMULLQHQDQ[] = {
+    {I_PCLMULLQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7786, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCLMULHQHQDQ[] = {
+    {I_PCLMULHQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7795, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCLMULQDQ[] = {
+    {I_PCLMULQDQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14184, 187},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCLMULLQLQDQ[] = {
+    {I_VPCLMULLQLQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7804, 188},
+    {I_VPCLMULLQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7813, 188},
+    {I_VPCLMULLQLQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7876, 198},
+    {I_VPCLMULLQLQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7885, 198},
+    {I_VPCLMULLQLQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+0, 199},
+    {I_VPCLMULLQLQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+10, 199},
+    {I_VPCLMULLQLQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+80, 199},
+    {I_VPCLMULLQLQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+90, 199},
+    {I_VPCLMULLQLQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+160, 200},
+    {I_VPCLMULLQLQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+170, 200},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCLMULHQLQDQ[] = {
+    {I_VPCLMULHQLQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7822, 188},
+    {I_VPCLMULHQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7831, 188},
+    {I_VPCLMULHQLQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7894, 198},
+    {I_VPCLMULHQLQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7903, 198},
+    {I_VPCLMULHQLQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+20, 199},
+    {I_VPCLMULHQLQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+30, 199},
+    {I_VPCLMULHQLQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+100, 199},
+    {I_VPCLMULHQLQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+110, 199},
+    {I_VPCLMULHQLQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+180, 200},
+    {I_VPCLMULHQLQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+190, 200},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCLMULLQHQDQ[] = {
+    {I_VPCLMULLQHQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7840, 188},
+    {I_VPCLMULLQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7849, 188},
+    {I_VPCLMULLQHQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7912, 198},
+    {I_VPCLMULLQHQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7921, 198},
+    {I_VPCLMULLQHQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40, 199},
+    {I_VPCLMULLQHQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+50, 199},
+    {I_VPCLMULLQHQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+120, 199},
+    {I_VPCLMULLQHQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+130, 199},
+    {I_VPCLMULLQHQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+200, 200},
+    {I_VPCLMULLQHQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+210, 200},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCLMULHQHQDQ[] = {
+    {I_VPCLMULHQHQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7858, 188},
+    {I_VPCLMULHQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7867, 188},
+    {I_VPCLMULHQHQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7930, 198},
+    {I_VPCLMULHQHQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7939, 198},
+    {I_VPCLMULHQHQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+60, 199},
+    {I_VPCLMULHQHQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+70, 199},
+    {I_VPCLMULHQHQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+140, 199},
+    {I_VPCLMULHQHQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+150, 199},
+    {I_VPCLMULHQHQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+220, 200},
+    {I_VPCLMULHQHQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+230, 200},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCLMULQDQ[] = {
+    {I_VPCLMULQDQ, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14192, 188},
+    {I_VPCLMULQDQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14200, 188},
+    {I_VPCLMULQDQ, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14208, 198},
+    {I_VPCLMULQDQ, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14216, 198},
+    {I_VPCLMULQDQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+7948, 199},
+    {I_VPCLMULQDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+7957, 199},
+    {I_VPCLMULQDQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+7966, 199},
+    {I_VPCLMULQDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+7975, 199},
+    {I_VPCLMULQDQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+7984, 200},
+    {I_VPCLMULQDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+7993, 200},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD132PS[] = {
+    {I_VFMADD132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38373, 201},
+    {I_VFMADD132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38380, 201},
+    {I_VFMADD132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18144, 240},
+    {I_VFMADD132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18152, 240},
+    {I_VFMADD132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18160, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD132PD[] = {
+    {I_VFMADD132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38387, 201},
+    {I_VFMADD132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38394, 201},
+    {I_VFMADD132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18120, 240},
+    {I_VFMADD132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18128, 240},
+    {I_VFMADD132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18136, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD312PS[] = {
+    {I_VFMADD312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38373, 201},
+    {I_VFMADD312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38380, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD312PD[] = {
+    {I_VFMADD312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38387, 201},
+    {I_VFMADD312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38394, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD213PS[] = {
+    {I_VFMADD213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38401, 201},
+    {I_VFMADD213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38408, 201},
+    {I_VFMADD213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18208, 240},
+    {I_VFMADD213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18216, 240},
+    {I_VFMADD213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18224, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD213PD[] = {
+    {I_VFMADD213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38415, 201},
+    {I_VFMADD213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38422, 201},
+    {I_VFMADD213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18184, 240},
+    {I_VFMADD213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18192, 240},
+    {I_VFMADD213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18200, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD123PS[] = {
+    {I_VFMADD123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38401, 201},
+    {I_VFMADD123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38408, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD123PD[] = {
+    {I_VFMADD123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38415, 201},
+    {I_VFMADD123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38422, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD231PS[] = {
+    {I_VFMADD231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38429, 201},
+    {I_VFMADD231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38436, 201},
+    {I_VFMADD231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18272, 240},
+    {I_VFMADD231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18280, 240},
+    {I_VFMADD231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18288, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD231PD[] = {
+    {I_VFMADD231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38443, 201},
+    {I_VFMADD231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38450, 201},
+    {I_VFMADD231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18248, 240},
+    {I_VFMADD231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18256, 240},
+    {I_VFMADD231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18264, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD321PS[] = {
+    {I_VFMADD321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38429, 201},
+    {I_VFMADD321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38436, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD321PD[] = {
+    {I_VFMADD321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38443, 201},
+    {I_VFMADD321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38450, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB132PS[] = {
+    {I_VFMADDSUB132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38457, 201},
+    {I_VFMADDSUB132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38464, 201},
+    {I_VFMADDSUB132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18336, 240},
+    {I_VFMADDSUB132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18344, 240},
+    {I_VFMADDSUB132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18352, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB132PD[] = {
+    {I_VFMADDSUB132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38471, 201},
+    {I_VFMADDSUB132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38478, 201},
+    {I_VFMADDSUB132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18312, 240},
+    {I_VFMADDSUB132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18320, 240},
+    {I_VFMADDSUB132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18328, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB312PS[] = {
+    {I_VFMADDSUB312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38457, 201},
+    {I_VFMADDSUB312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38464, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB312PD[] = {
+    {I_VFMADDSUB312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38471, 201},
+    {I_VFMADDSUB312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38478, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB213PS[] = {
+    {I_VFMADDSUB213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38485, 201},
+    {I_VFMADDSUB213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38492, 201},
+    {I_VFMADDSUB213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18384, 240},
+    {I_VFMADDSUB213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18392, 240},
+    {I_VFMADDSUB213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18400, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB213PD[] = {
+    {I_VFMADDSUB213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38499, 201},
+    {I_VFMADDSUB213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38506, 201},
+    {I_VFMADDSUB213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18360, 240},
+    {I_VFMADDSUB213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18368, 240},
+    {I_VFMADDSUB213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18376, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB123PS[] = {
+    {I_VFMADDSUB123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38485, 201},
+    {I_VFMADDSUB123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38492, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB123PD[] = {
+    {I_VFMADDSUB123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38499, 201},
+    {I_VFMADDSUB123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38506, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB231PS[] = {
+    {I_VFMADDSUB231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38513, 201},
+    {I_VFMADDSUB231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38520, 201},
+    {I_VFMADDSUB231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18432, 240},
+    {I_VFMADDSUB231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18440, 240},
+    {I_VFMADDSUB231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18448, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB231PD[] = {
+    {I_VFMADDSUB231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38527, 201},
+    {I_VFMADDSUB231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38534, 201},
+    {I_VFMADDSUB231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18408, 240},
+    {I_VFMADDSUB231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18416, 240},
+    {I_VFMADDSUB231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18424, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB321PS[] = {
+    {I_VFMADDSUB321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38513, 201},
+    {I_VFMADDSUB321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38520, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB321PD[] = {
+    {I_VFMADDSUB321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38527, 201},
+    {I_VFMADDSUB321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38534, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB132PS[] = {
+    {I_VFMSUB132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38541, 201},
+    {I_VFMSUB132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38548, 201},
+    {I_VFMSUB132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18480, 240},
+    {I_VFMSUB132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18488, 240},
+    {I_VFMSUB132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18496, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB132PD[] = {
+    {I_VFMSUB132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38555, 201},
+    {I_VFMSUB132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38562, 201},
+    {I_VFMSUB132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18456, 240},
+    {I_VFMSUB132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18464, 240},
+    {I_VFMSUB132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18472, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB312PS[] = {
+    {I_VFMSUB312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38541, 201},
+    {I_VFMSUB312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38548, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB312PD[] = {
+    {I_VFMSUB312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38555, 201},
+    {I_VFMSUB312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38562, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB213PS[] = {
+    {I_VFMSUB213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38569, 201},
+    {I_VFMSUB213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38576, 201},
+    {I_VFMSUB213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18544, 240},
+    {I_VFMSUB213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18552, 240},
+    {I_VFMSUB213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18560, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB213PD[] = {
+    {I_VFMSUB213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38583, 201},
+    {I_VFMSUB213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38590, 201},
+    {I_VFMSUB213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18520, 240},
+    {I_VFMSUB213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18528, 240},
+    {I_VFMSUB213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18536, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB123PS[] = {
+    {I_VFMSUB123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38569, 201},
+    {I_VFMSUB123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38576, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB123PD[] = {
+    {I_VFMSUB123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38583, 201},
+    {I_VFMSUB123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38590, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB231PS[] = {
+    {I_VFMSUB231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38597, 201},
+    {I_VFMSUB231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38604, 201},
+    {I_VFMSUB231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18608, 240},
+    {I_VFMSUB231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18616, 240},
+    {I_VFMSUB231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18624, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB231PD[] = {
+    {I_VFMSUB231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38611, 201},
+    {I_VFMSUB231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38618, 201},
+    {I_VFMSUB231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18584, 240},
+    {I_VFMSUB231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18592, 240},
+    {I_VFMSUB231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18600, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB321PS[] = {
+    {I_VFMSUB321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38597, 201},
+    {I_VFMSUB321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38604, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB321PD[] = {
+    {I_VFMSUB321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38611, 201},
+    {I_VFMSUB321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38618, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD132PS[] = {
+    {I_VFMSUBADD132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38625, 201},
+    {I_VFMSUBADD132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38632, 201},
+    {I_VFMSUBADD132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18672, 240},
+    {I_VFMSUBADD132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18680, 240},
+    {I_VFMSUBADD132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18688, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD132PD[] = {
+    {I_VFMSUBADD132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38639, 201},
+    {I_VFMSUBADD132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38646, 201},
+    {I_VFMSUBADD132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18648, 240},
+    {I_VFMSUBADD132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18656, 240},
+    {I_VFMSUBADD132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18664, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD312PS[] = {
+    {I_VFMSUBADD312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38625, 201},
+    {I_VFMSUBADD312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38632, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD312PD[] = {
+    {I_VFMSUBADD312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38639, 201},
+    {I_VFMSUBADD312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38646, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD213PS[] = {
+    {I_VFMSUBADD213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38653, 201},
+    {I_VFMSUBADD213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38660, 201},
+    {I_VFMSUBADD213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18720, 240},
+    {I_VFMSUBADD213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18728, 240},
+    {I_VFMSUBADD213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18736, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD213PD[] = {
+    {I_VFMSUBADD213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38667, 201},
+    {I_VFMSUBADD213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38674, 201},
+    {I_VFMSUBADD213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18696, 240},
+    {I_VFMSUBADD213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18704, 240},
+    {I_VFMSUBADD213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18712, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD123PS[] = {
+    {I_VFMSUBADD123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38653, 201},
+    {I_VFMSUBADD123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38660, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD123PD[] = {
+    {I_VFMSUBADD123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38667, 201},
+    {I_VFMSUBADD123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38674, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD231PS[] = {
+    {I_VFMSUBADD231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38681, 201},
+    {I_VFMSUBADD231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38688, 201},
+    {I_VFMSUBADD231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18768, 240},
+    {I_VFMSUBADD231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18776, 240},
+    {I_VFMSUBADD231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18784, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD231PD[] = {
+    {I_VFMSUBADD231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38695, 201},
+    {I_VFMSUBADD231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38702, 201},
+    {I_VFMSUBADD231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18744, 240},
+    {I_VFMSUBADD231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18752, 240},
+    {I_VFMSUBADD231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18760, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD321PS[] = {
+    {I_VFMSUBADD321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38681, 201},
+    {I_VFMSUBADD321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38688, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD321PD[] = {
+    {I_VFMSUBADD321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38695, 201},
+    {I_VFMSUBADD321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38702, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD132PS[] = {
+    {I_VFNMADD132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38709, 201},
+    {I_VFNMADD132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38716, 201},
+    {I_VFNMADD132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18816, 240},
+    {I_VFNMADD132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18824, 240},
+    {I_VFNMADD132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18832, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD132PD[] = {
+    {I_VFNMADD132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38723, 201},
+    {I_VFNMADD132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38730, 201},
+    {I_VFNMADD132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18792, 240},
+    {I_VFNMADD132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18800, 240},
+    {I_VFNMADD132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18808, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD312PS[] = {
+    {I_VFNMADD312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38709, 201},
+    {I_VFNMADD312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38716, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD312PD[] = {
+    {I_VFNMADD312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38723, 201},
+    {I_VFNMADD312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38730, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD213PS[] = {
+    {I_VFNMADD213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38737, 201},
+    {I_VFNMADD213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38744, 201},
+    {I_VFNMADD213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18880, 240},
+    {I_VFNMADD213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18888, 240},
+    {I_VFNMADD213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18896, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD213PD[] = {
+    {I_VFNMADD213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38751, 201},
+    {I_VFNMADD213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38758, 201},
+    {I_VFNMADD213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18856, 240},
+    {I_VFNMADD213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18864, 240},
+    {I_VFNMADD213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18872, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD123PS[] = {
+    {I_VFNMADD123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38737, 201},
+    {I_VFNMADD123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38744, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD123PD[] = {
+    {I_VFNMADD123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38751, 201},
+    {I_VFNMADD123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38758, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD231PS[] = {
+    {I_VFNMADD231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38765, 201},
+    {I_VFNMADD231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38772, 201},
+    {I_VFNMADD231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18944, 240},
+    {I_VFNMADD231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18952, 240},
+    {I_VFNMADD231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18960, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD231PD[] = {
+    {I_VFNMADD231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38779, 201},
+    {I_VFNMADD231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38786, 201},
+    {I_VFNMADD231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18920, 240},
+    {I_VFNMADD231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18928, 240},
+    {I_VFNMADD231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18936, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD321PS[] = {
+    {I_VFNMADD321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38765, 201},
+    {I_VFNMADD321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38772, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD321PD[] = {
+    {I_VFNMADD321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38779, 201},
+    {I_VFNMADD321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38786, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB132PS[] = {
+    {I_VFNMSUB132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38793, 201},
+    {I_VFNMSUB132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38800, 201},
+    {I_VFNMSUB132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19008, 240},
+    {I_VFNMSUB132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19016, 240},
+    {I_VFNMSUB132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+19024, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB132PD[] = {
+    {I_VFNMSUB132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38807, 201},
+    {I_VFNMSUB132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38814, 201},
+    {I_VFNMSUB132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18984, 240},
+    {I_VFNMSUB132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18992, 240},
+    {I_VFNMSUB132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+19000, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB312PS[] = {
+    {I_VFNMSUB312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38793, 201},
+    {I_VFNMSUB312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38800, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB312PD[] = {
+    {I_VFNMSUB312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38807, 201},
+    {I_VFNMSUB312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38814, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB213PS[] = {
+    {I_VFNMSUB213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38821, 201},
+    {I_VFNMSUB213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38828, 201},
+    {I_VFNMSUB213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19072, 240},
+    {I_VFNMSUB213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19080, 240},
+    {I_VFNMSUB213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+19088, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB213PD[] = {
+    {I_VFNMSUB213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38835, 201},
+    {I_VFNMSUB213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38842, 201},
+    {I_VFNMSUB213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19048, 240},
+    {I_VFNMSUB213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19056, 240},
+    {I_VFNMSUB213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+19064, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB123PS[] = {
+    {I_VFNMSUB123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38821, 201},
+    {I_VFNMSUB123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38828, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB123PD[] = {
+    {I_VFNMSUB123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38835, 201},
+    {I_VFNMSUB123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38842, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB231PS[] = {
+    {I_VFNMSUB231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38849, 201},
+    {I_VFNMSUB231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38856, 201},
+    {I_VFNMSUB231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19136, 240},
+    {I_VFNMSUB231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19144, 240},
+    {I_VFNMSUB231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+19152, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB231PD[] = {
+    {I_VFNMSUB231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38863, 201},
+    {I_VFNMSUB231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38870, 201},
+    {I_VFNMSUB231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19112, 240},
+    {I_VFNMSUB231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19120, 240},
+    {I_VFNMSUB231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+19128, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB321PS[] = {
+    {I_VFNMSUB321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38849, 201},
+    {I_VFNMSUB321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38856, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB321PD[] = {
+    {I_VFNMSUB321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38863, 201},
+    {I_VFNMSUB321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38870, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD132SS[] = {
+    {I_VFMADD132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38877, 201},
+    {I_VFMADD132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18176, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD132SD[] = {
+    {I_VFMADD132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38884, 201},
+    {I_VFMADD132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18168, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD312SS[] = {
+    {I_VFMADD312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38877, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD312SD[] = {
+    {I_VFMADD312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38884, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD213SS[] = {
+    {I_VFMADD213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38891, 201},
+    {I_VFMADD213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18240, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD213SD[] = {
+    {I_VFMADD213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38898, 201},
+    {I_VFMADD213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18232, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD123SS[] = {
+    {I_VFMADD123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38891, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD123SD[] = {
+    {I_VFMADD123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38898, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD231SS[] = {
+    {I_VFMADD231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38905, 201},
+    {I_VFMADD231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18304, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD231SD[] = {
+    {I_VFMADD231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38912, 201},
+    {I_VFMADD231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18296, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD321SS[] = {
+    {I_VFMADD321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38905, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD321SD[] = {
+    {I_VFMADD321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38912, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB132SS[] = {
+    {I_VFMSUB132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38919, 201},
+    {I_VFMSUB132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18512, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB132SD[] = {
+    {I_VFMSUB132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38926, 201},
+    {I_VFMSUB132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18504, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB312SS[] = {
+    {I_VFMSUB312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38919, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB312SD[] = {
+    {I_VFMSUB312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38926, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB213SS[] = {
+    {I_VFMSUB213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38933, 201},
+    {I_VFMSUB213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18576, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB213SD[] = {
+    {I_VFMSUB213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38940, 201},
+    {I_VFMSUB213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18568, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB123SS[] = {
+    {I_VFMSUB123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38933, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB123SD[] = {
+    {I_VFMSUB123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38940, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB231SS[] = {
+    {I_VFMSUB231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38947, 201},
+    {I_VFMSUB231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18640, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB231SD[] = {
+    {I_VFMSUB231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38954, 201},
+    {I_VFMSUB231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18632, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB321SS[] = {
+    {I_VFMSUB321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38947, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB321SD[] = {
+    {I_VFMSUB321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38954, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD132SS[] = {
+    {I_VFNMADD132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38961, 201},
+    {I_VFNMADD132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18848, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD132SD[] = {
+    {I_VFNMADD132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38968, 201},
+    {I_VFNMADD132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18840, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD312SS[] = {
+    {I_VFNMADD312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38961, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD312SD[] = {
+    {I_VFNMADD312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38968, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD213SS[] = {
+    {I_VFNMADD213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38975, 201},
+    {I_VFNMADD213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18912, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD213SD[] = {
+    {I_VFNMADD213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38982, 201},
+    {I_VFNMADD213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18904, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD123SS[] = {
+    {I_VFNMADD123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38975, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD123SD[] = {
+    {I_VFNMADD123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38982, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD231SS[] = {
+    {I_VFNMADD231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38989, 201},
+    {I_VFNMADD231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18976, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD231SD[] = {
+    {I_VFNMADD231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38996, 201},
+    {I_VFNMADD231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18968, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD321SS[] = {
+    {I_VFNMADD321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38989, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADD321SD[] = {
+    {I_VFNMADD321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38996, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB132SS[] = {
+    {I_VFNMSUB132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39003, 201},
+    {I_VFNMSUB132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19040, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB132SD[] = {
+    {I_VFNMSUB132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39010, 201},
+    {I_VFNMSUB132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19032, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB312SS[] = {
+    {I_VFNMSUB312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39003, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB312SD[] = {
+    {I_VFNMSUB312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39010, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB213SS[] = {
+    {I_VFNMSUB213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39017, 201},
+    {I_VFNMSUB213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19104, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB213SD[] = {
+    {I_VFNMSUB213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39024, 201},
+    {I_VFNMSUB213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19096, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB123SS[] = {
+    {I_VFNMSUB123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39017, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB123SD[] = {
+    {I_VFNMSUB123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39024, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB231SS[] = {
+    {I_VFNMSUB231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39031, 201},
+    {I_VFNMSUB231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19168, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB231SD[] = {
+    {I_VFNMSUB231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39038, 201},
+    {I_VFNMSUB231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19160, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB321SS[] = {
+    {I_VFNMSUB321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39031, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUB321SD[] = {
+    {I_VFNMSUB321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39038, 201},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDFSBASE[] = {
+    {I_RDFSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39045, 136},
+    {I_RDFSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39052, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDGSBASE[] = {
+    {I_RDGSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39059, 136},
+    {I_RDGSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39066, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDRAND[] = {
+    {I_RDRAND, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45771, 135},
+    {I_RDRAND, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45777, 135},
+    {I_RDRAND, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45783, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRFSBASE[] = {
+    {I_WRFSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39073, 136},
+    {I_WRFSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39080, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRGSBASE[] = {
+    {I_WRGSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39087, 136},
+    {I_WRGSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39094, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2PS[] = {
+    {I_VCVTPH2PS, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39101, 202},
+    {I_VCVTPH2PS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+39108, 202},
+    {I_VCVTPH2PS, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17240, 240},
+    {I_VCVTPH2PS, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17248, 240},
+    {I_VCVTPH2PS, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+17256, 241},
+    {I_VCVTPH2PS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+39108, 297},
+    {I_VCVTPH2PS, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39101, 297},
+    {I_VCVTPH2PS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17240, 240},
+    {I_VCVTPH2PS, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17248, 240},
+    {I_VCVTPH2PS, 2, {ZMM_L16,RM_YMM_L16|BITS256,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+17256, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPS2PH[] = {
+    {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14224, 202},
+    {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14232, 202},
+    {I_VCVTPS2PH, 3, {XMMREG,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8182, 240},
+    {I_VCVTPS2PH, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8191, 240},
+    {I_VCVTPS2PH, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    {I_VCVTPS2PH, 3, {MEMORY|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8182, 240},
+    {I_VCVTPS2PH, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8191, 240},
+    {I_VCVTPS2PH, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14232, 298},
+    {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14224, 298},
+    {I_VCVTPS2PH, 3, {XMMREG,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8182, 240},
+    {I_VCVTPS2PH, 3, {MEMORY|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8182, 240},
+    {I_VCVTPS2PH, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8191, 240},
+    {I_VCVTPS2PH, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8191, 240},
+    {I_VCVTPS2PH, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    {I_VCVTPS2PH, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    {I_VCVTPS2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30504, 295},
+    {I_VCVTPS2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30512, 295},
+    {I_VCVTPS2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+30520, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADCX[] = {
+    {I_ADCX, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+14240, 135},
+    {I_ADCX, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+14248, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ADOX[] = {
+    {I_ADOX, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+14256, 135},
+    {I_ADOX, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+14264, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDSEED[] = {
+    {I_RDSEED, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45789, 135},
+    {I_RDSEED, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45795, 135},
+    {I_RDSEED, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45801, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLAC[] = {
+    {I_CLAC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49147, 203},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STAC[] = {
+    {I_STAC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49152, 203},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSTORE[] = {
+    {I_XSTORE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49157, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XCRYPTECB[] = {
+    {I_XCRYPTECB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45807, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XCRYPTCBC[] = {
+    {I_XCRYPTCBC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45813, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XCRYPTCTR[] = {
+    {I_XCRYPTCTR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45819, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XCRYPTCFB[] = {
+    {I_XCRYPTCFB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45825, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XCRYPTOFB[] = {
+    {I_XCRYPTOFB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45831, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MONTMUL[] = {
+    {I_MONTMUL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45837, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSHA1[] = {
+    {I_XSHA1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45843, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSHA256[] = {
+    {I_XSHA256, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45849, 32},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LLWPCB[] = {
+    {I_LLWPCB, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39115, 204},
+    {I_LLWPCB, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39122, 205},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SLWPCB[] = {
+    {I_SLWPCB, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39129, 204},
+    {I_SLWPCB, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39136, 205},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LWPVAL[] = {
+    {I_LWPVAL, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14272, 204},
+    {I_LWPVAL, 3, {REG_GPR|BITS64,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14280, 205},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LWPINS[] = {
+    {I_LWPINS, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14288, 204},
+    {I_LWPINS, 3, {REG_GPR|BITS64,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14296, 205},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDPD[] = {
+    {I_VFMADDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14304, 206},
+    {I_VFMADDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14312, 206},
+    {I_VFMADDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14320, 206},
+    {I_VFMADDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14328, 206},
+    {I_VFMADDPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14336, 206},
+    {I_VFMADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14344, 206},
+    {I_VFMADDPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14352, 206},
+    {I_VFMADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14360, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDPS[] = {
+    {I_VFMADDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14368, 206},
+    {I_VFMADDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14376, 206},
+    {I_VFMADDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14384, 206},
+    {I_VFMADDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14392, 206},
+    {I_VFMADDPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14400, 206},
+    {I_VFMADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14408, 206},
+    {I_VFMADDPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14416, 206},
+    {I_VFMADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14424, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSD[] = {
+    {I_VFMADDSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14432, 206},
+    {I_VFMADDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14440, 206},
+    {I_VFMADDSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+14448, 206},
+    {I_VFMADDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+14456, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSS[] = {
+    {I_VFMADDSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14464, 206},
+    {I_VFMADDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14472, 206},
+    {I_VFMADDSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+14480, 206},
+    {I_VFMADDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14488, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUBPD[] = {
+    {I_VFMADDSUBPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14496, 206},
+    {I_VFMADDSUBPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14504, 206},
+    {I_VFMADDSUBPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14512, 206},
+    {I_VFMADDSUBPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14520, 206},
+    {I_VFMADDSUBPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14528, 206},
+    {I_VFMADDSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14536, 206},
+    {I_VFMADDSUBPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14544, 206},
+    {I_VFMADDSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14552, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUBPS[] = {
+    {I_VFMADDSUBPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14560, 206},
+    {I_VFMADDSUBPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14568, 206},
+    {I_VFMADDSUBPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14576, 206},
+    {I_VFMADDSUBPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14584, 206},
+    {I_VFMADDSUBPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14592, 206},
+    {I_VFMADDSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14600, 206},
+    {I_VFMADDSUBPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14608, 206},
+    {I_VFMADDSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14616, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADDPD[] = {
+    {I_VFMSUBADDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14624, 206},
+    {I_VFMSUBADDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14632, 206},
+    {I_VFMSUBADDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14640, 206},
+    {I_VFMSUBADDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14648, 206},
+    {I_VFMSUBADDPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14656, 206},
+    {I_VFMSUBADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14664, 206},
+    {I_VFMSUBADDPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14672, 206},
+    {I_VFMSUBADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14680, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADDPS[] = {
+    {I_VFMSUBADDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14688, 206},
+    {I_VFMSUBADDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14696, 206},
+    {I_VFMSUBADDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14704, 206},
+    {I_VFMSUBADDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14712, 206},
+    {I_VFMSUBADDPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14720, 206},
+    {I_VFMSUBADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14728, 206},
+    {I_VFMSUBADDPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14736, 206},
+    {I_VFMSUBADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14744, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBPD[] = {
+    {I_VFMSUBPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14752, 206},
+    {I_VFMSUBPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14760, 206},
+    {I_VFMSUBPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14768, 206},
+    {I_VFMSUBPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14776, 206},
+    {I_VFMSUBPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14784, 206},
+    {I_VFMSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14792, 206},
+    {I_VFMSUBPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14800, 206},
+    {I_VFMSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14808, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBPS[] = {
+    {I_VFMSUBPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14816, 206},
+    {I_VFMSUBPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14824, 206},
+    {I_VFMSUBPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14832, 206},
+    {I_VFMSUBPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14840, 206},
+    {I_VFMSUBPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14848, 206},
+    {I_VFMSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14856, 206},
+    {I_VFMSUBPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14864, 206},
+    {I_VFMSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14872, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBSD[] = {
+    {I_VFMSUBSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14880, 206},
+    {I_VFMSUBSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14888, 206},
+    {I_VFMSUBSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+14896, 206},
+    {I_VFMSUBSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+14904, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBSS[] = {
+    {I_VFMSUBSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14912, 206},
+    {I_VFMSUBSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14920, 206},
+    {I_VFMSUBSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+14928, 206},
+    {I_VFMSUBSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14936, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADDPD[] = {
+    {I_VFNMADDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14944, 206},
+    {I_VFNMADDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14952, 206},
+    {I_VFNMADDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14960, 206},
+    {I_VFNMADDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14968, 206},
+    {I_VFNMADDPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14976, 206},
+    {I_VFNMADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14984, 206},
+    {I_VFNMADDPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14992, 206},
+    {I_VFNMADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15000, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADDPS[] = {
+    {I_VFNMADDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15008, 206},
+    {I_VFNMADDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15016, 206},
+    {I_VFNMADDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15024, 206},
+    {I_VFNMADDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15032, 206},
+    {I_VFNMADDPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15040, 206},
+    {I_VFNMADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15048, 206},
+    {I_VFNMADDPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15056, 206},
+    {I_VFNMADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15064, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADDSD[] = {
+    {I_VFNMADDSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15072, 206},
+    {I_VFNMADDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15080, 206},
+    {I_VFNMADDSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+15088, 206},
+    {I_VFNMADDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+15096, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMADDSS[] = {
+    {I_VFNMADDSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15104, 206},
+    {I_VFNMADDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15112, 206},
+    {I_VFNMADDSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+15120, 206},
+    {I_VFNMADDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+15128, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUBPD[] = {
+    {I_VFNMSUBPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15136, 206},
+    {I_VFNMSUBPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15144, 206},
+    {I_VFNMSUBPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15152, 206},
+    {I_VFNMSUBPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15160, 206},
+    {I_VFNMSUBPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15168, 206},
+    {I_VFNMSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15176, 206},
+    {I_VFNMSUBPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15184, 206},
+    {I_VFNMSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15192, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUBPS[] = {
+    {I_VFNMSUBPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15200, 206},
+    {I_VFNMSUBPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15208, 206},
+    {I_VFNMSUBPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15216, 206},
+    {I_VFNMSUBPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15224, 206},
+    {I_VFNMSUBPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15232, 206},
+    {I_VFNMSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15240, 206},
+    {I_VFNMSUBPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15248, 206},
+    {I_VFNMSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15256, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUBSD[] = {
+    {I_VFNMSUBSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15264, 206},
+    {I_VFNMSUBSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15272, 206},
+    {I_VFNMSUBSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+15280, 206},
+    {I_VFNMSUBSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+15288, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFNMSUBSS[] = {
+    {I_VFNMSUBSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15296, 206},
+    {I_VFNMSUBSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15304, 206},
+    {I_VFNMSUBSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+15312, 206},
+    {I_VFNMSUBSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+15320, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFRCZPD[] = {
+    {I_VFRCZPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39143, 206},
+    {I_VFRCZPD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39150, 206},
+    {I_VFRCZPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39157, 206},
+    {I_VFRCZPD, 1, {YMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39164, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFRCZPS[] = {
+    {I_VFRCZPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39171, 206},
+    {I_VFRCZPS, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39178, 206},
+    {I_VFRCZPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39185, 206},
+    {I_VFRCZPS, 1, {YMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39192, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFRCZSD[] = {
+    {I_VFRCZSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+39199, 206},
+    {I_VFRCZSD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39206, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFRCZSS[] = {
+    {I_VFRCZSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+39213, 206},
+    {I_VFRCZSS, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39220, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMOV[] = {
+    {I_VPCMOV, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15328, 206},
+    {I_VPCMOV, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15336, 206},
+    {I_VPCMOV, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15344, 206},
+    {I_VPCMOV, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15352, 206},
+    {I_VPCMOV, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15360, 206},
+    {I_VPCMOV, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15368, 206},
+    {I_VPCMOV, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15376, 206},
+    {I_VPCMOV, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15384, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMB[] = {
+    {I_VPCOMB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15392, 206},
+    {I_VPCOMB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15400, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMD[] = {
+    {I_VPCOMD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15408, 206},
+    {I_VPCOMD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15416, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMQ[] = {
+    {I_VPCOMQ, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15424, 206},
+    {I_VPCOMQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15432, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMUB[] = {
+    {I_VPCOMUB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15440, 206},
+    {I_VPCOMUB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15448, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMUD[] = {
+    {I_VPCOMUD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15456, 206},
+    {I_VPCOMUD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15464, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMUQ[] = {
+    {I_VPCOMUQ, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15472, 206},
+    {I_VPCOMUQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15480, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMUW[] = {
+    {I_VPCOMUW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15488, 206},
+    {I_VPCOMUW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15496, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMW[] = {
+    {I_VPCOMW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15504, 206},
+    {I_VPCOMW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15512, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDBD[] = {
+    {I_VPHADDBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39227, 206},
+    {I_VPHADDBD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39234, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDBQ[] = {
+    {I_VPHADDBQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39241, 206},
+    {I_VPHADDBQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39248, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDBW[] = {
+    {I_VPHADDBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39255, 206},
+    {I_VPHADDBW, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39262, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDDQ[] = {
+    {I_VPHADDDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39269, 206},
+    {I_VPHADDDQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39276, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDUBD[] = {
+    {I_VPHADDUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39283, 206},
+    {I_VPHADDUBD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39290, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDUBQ[] = {
+    {I_VPHADDUBQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39297, 206},
+    {I_VPHADDUBQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39304, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDUBW[] = {
+    {I_VPHADDUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39311, 206},
+    {I_VPHADDUBW, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39318, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDUDQ[] = {
+    {I_VPHADDUDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39325, 206},
+    {I_VPHADDUDQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39332, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDUWD[] = {
+    {I_VPHADDUWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39339, 206},
+    {I_VPHADDUWD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39346, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDUWQ[] = {
+    {I_VPHADDUWQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39353, 206},
+    {I_VPHADDUWQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39360, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDWD[] = {
+    {I_VPHADDWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39367, 206},
+    {I_VPHADDWD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39374, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHADDWQ[] = {
+    {I_VPHADDWQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39381, 206},
+    {I_VPHADDWQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39388, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHSUBBW[] = {
+    {I_VPHSUBBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39395, 206},
+    {I_VPHSUBBW, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39402, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHSUBDQ[] = {
+    {I_VPHSUBDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39409, 206},
+    {I_VPHSUBDQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39416, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPHSUBWD[] = {
+    {I_VPHSUBWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39423, 206},
+    {I_VPHSUBWD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39430, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSDD[] = {
+    {I_VPMACSDD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15520, 206},
+    {I_VPMACSDD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15528, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSDQH[] = {
+    {I_VPMACSDQH, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15536, 206},
+    {I_VPMACSDQH, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15544, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSDQL[] = {
+    {I_VPMACSDQL, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15552, 206},
+    {I_VPMACSDQL, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15560, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSSDD[] = {
+    {I_VPMACSSDD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15568, 206},
+    {I_VPMACSSDD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15576, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSSDQH[] = {
+    {I_VPMACSSDQH, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15584, 206},
+    {I_VPMACSSDQH, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15592, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSSDQL[] = {
+    {I_VPMACSSDQL, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15600, 206},
+    {I_VPMACSSDQL, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15608, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSSWD[] = {
+    {I_VPMACSSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15616, 206},
+    {I_VPMACSSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15624, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSSWW[] = {
+    {I_VPMACSSWW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15632, 206},
+    {I_VPMACSSWW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15640, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSWD[] = {
+    {I_VPMACSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15648, 206},
+    {I_VPMACSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15656, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMACSWW[] = {
+    {I_VPMACSWW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15664, 206},
+    {I_VPMACSWW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15672, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADCSSWD[] = {
+    {I_VPMADCSSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15680, 206},
+    {I_VPMADCSSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15688, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADCSWD[] = {
+    {I_VPMADCSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15696, 206},
+    {I_VPMADCSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15704, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPPERM[] = {
+    {I_VPPERM, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15712, 206},
+    {I_VPPERM, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15720, 206},
+    {I_VPPERM, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15728, 206},
+    {I_VPPERM, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15736, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROTB[] = {
+    {I_VPROTB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39437, 206},
+    {I_VPROTB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39444, 206},
+    {I_VPROTB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39451, 206},
+    {I_VPROTB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39458, 206},
+    {I_VPROTB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15744, 206},
+    {I_VPROTB, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15752, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROTD[] = {
+    {I_VPROTD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39465, 206},
+    {I_VPROTD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39472, 206},
+    {I_VPROTD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39479, 206},
+    {I_VPROTD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39486, 206},
+    {I_VPROTD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15760, 206},
+    {I_VPROTD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15768, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROTQ[] = {
+    {I_VPROTQ, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39493, 206},
+    {I_VPROTQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39500, 206},
+    {I_VPROTQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39507, 206},
+    {I_VPROTQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39514, 206},
+    {I_VPROTQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15776, 206},
+    {I_VPROTQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15784, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROTW[] = {
+    {I_VPROTW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39521, 206},
+    {I_VPROTW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39528, 206},
+    {I_VPROTW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39535, 206},
+    {I_VPROTW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39542, 206},
+    {I_VPROTW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15792, 206},
+    {I_VPROTW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15800, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHAB[] = {
+    {I_VPSHAB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39549, 206},
+    {I_VPSHAB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39556, 206},
+    {I_VPSHAB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39563, 206},
+    {I_VPSHAB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39570, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHAD[] = {
+    {I_VPSHAD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39577, 206},
+    {I_VPSHAD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39584, 206},
+    {I_VPSHAD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39591, 206},
+    {I_VPSHAD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39598, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHAQ[] = {
+    {I_VPSHAQ, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39605, 206},
+    {I_VPSHAQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39612, 206},
+    {I_VPSHAQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39619, 206},
+    {I_VPSHAQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39626, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHAW[] = {
+    {I_VPSHAW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39633, 206},
+    {I_VPSHAW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39640, 206},
+    {I_VPSHAW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39647, 206},
+    {I_VPSHAW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39654, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLB[] = {
+    {I_VPSHLB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39661, 206},
+    {I_VPSHLB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39668, 206},
+    {I_VPSHLB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39675, 206},
+    {I_VPSHLB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39682, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLD[] = {
+    {I_VPSHLD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39689, 206},
+    {I_VPSHLD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39696, 206},
+    {I_VPSHLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39703, 206},
+    {I_VPSHLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39710, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLQ[] = {
+    {I_VPSHLQ, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39717, 206},
+    {I_VPSHLQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39724, 206},
+    {I_VPSHLQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39731, 206},
+    {I_VPSHLQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39738, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLW[] = {
+    {I_VPSHLW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39745, 206},
+    {I_VPSHLW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39752, 206},
+    {I_VPSHLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39759, 206},
+    {I_VPSHLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39766, 206},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTI128[] = {
+    {I_VBROADCASTI128, 2, {YMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41040, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDD[] = {
+    {I_VPBLENDD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16056, 207},
+    {I_VPBLENDD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16064, 207},
+    {I_VPBLENDD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16072, 207},
+    {I_VPBLENDD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16080, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBROADCASTB[] = {
+    {I_VPBROADCASTB, 2, {XMM_L16,MEMORY|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+41047, 207},
+    {I_VPBROADCASTB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41047, 207},
+    {I_VPBROADCASTB, 2, {YMM_L16,MEMORY|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+41054, 207},
+    {I_VPBROADCASTB, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41054, 207},
+    {I_VPBROADCASTB, 2, {XMMREG,RM_XMM|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21792, 244},
+    {I_VPBROADCASTB, 2, {YMMREG,RM_XMM|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21800, 244},
+    {I_VPBROADCASTB, 2, {ZMMREG,RM_XMM|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21808, 245},
+    {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBROADCASTW[] = {
+    {I_VPBROADCASTW, 2, {XMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41061, 207},
+    {I_VPBROADCASTW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41061, 207},
+    {I_VPBROADCASTW, 2, {YMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41068, 207},
+    {I_VPBROADCASTW, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41068, 207},
+    {I_VPBROADCASTW, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22032, 244},
+    {I_VPBROADCASTW, 2, {YMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22040, 244},
+    {I_VPBROADCASTW, 2, {ZMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22048, 245},
+    {I_VPBROADCASTW, 2, {XMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22056, 244},
+    {I_VPBROADCASTW, 2, {XMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22056, 244},
+    {I_VPBROADCASTW, 2, {XMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22056, 244},
+    {I_VPBROADCASTW, 2, {YMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22064, 244},
+    {I_VPBROADCASTW, 2, {YMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22064, 244},
+    {I_VPBROADCASTW, 2, {YMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22064, 244},
+    {I_VPBROADCASTW, 2, {ZMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22072, 245},
+    {I_VPBROADCASTW, 2, {ZMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22072, 245},
+    {I_VPBROADCASTW, 2, {ZMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22072, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBROADCASTD[] = {
+    {I_VPBROADCASTD, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41075, 207},
+    {I_VPBROADCASTD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41075, 207},
+    {I_VPBROADCASTD, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41082, 207},
+    {I_VPBROADCASTD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41082, 207},
+    {I_VPBROADCASTD, 2, {XMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21840, 240},
+    {I_VPBROADCASTD, 2, {YMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21848, 240},
+    {I_VPBROADCASTD, 2, {ZMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21856, 241},
+    {I_VPBROADCASTD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21864, 240},
+    {I_VPBROADCASTD, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21872, 240},
+    {I_VPBROADCASTD, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21880, 241},
+    {I_VPBROADCASTD, 2, {XMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21888, 240},
+    {I_VPBROADCASTD, 2, {YMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21896, 240},
+    {I_VPBROADCASTD, 2, {ZMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21904, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBROADCASTQ[] = {
+    {I_VPBROADCASTQ, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41089, 207},
+    {I_VPBROADCASTQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41089, 207},
+    {I_VPBROADCASTQ, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41096, 207},
+    {I_VPBROADCASTQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41096, 207},
+    {I_VPBROADCASTQ, 2, {XMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21960, 240},
+    {I_VPBROADCASTQ, 2, {YMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21968, 240},
+    {I_VPBROADCASTQ, 2, {ZMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21976, 241},
+    {I_VPBROADCASTQ, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21984, 240},
+    {I_VPBROADCASTQ, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21992, 240},
+    {I_VPBROADCASTQ, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22000, 241},
+    {I_VPBROADCASTQ, 2, {XMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22008, 240},
+    {I_VPBROADCASTQ, 2, {YMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22016, 240},
+    {I_VPBROADCASTQ, 2, {ZMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22024, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMD[] = {
+    {I_VPERMD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41103, 207},
+    {I_VPERMD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41110, 207},
+    {I_VPERMD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22464, 240},
+    {I_VPERMD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22472, 240},
+    {I_VPERMD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22480, 241},
+    {I_VPERMD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22488, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMPD[] = {
+    {I_VPERMPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16088, 207},
+    {I_VPERMPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9514, 240},
+    {I_VPERMPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9523, 241},
+    {I_VPERMPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22736, 240},
+    {I_VPERMPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22744, 240},
+    {I_VPERMPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22752, 241},
+    {I_VPERMPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22760, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMPS[] = {
+    {I_VPERMPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41117, 207},
+    {I_VPERMPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41124, 207},
+    {I_VPERMPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22768, 240},
+    {I_VPERMPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22776, 240},
+    {I_VPERMPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22784, 241},
+    {I_VPERMPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22792, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMQ[] = {
+    {I_VPERMQ, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16096, 207},
+    {I_VPERMQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9532, 240},
+    {I_VPERMQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9541, 241},
+    {I_VPERMQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22800, 240},
+    {I_VPERMQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22808, 240},
+    {I_VPERMQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22816, 241},
+    {I_VPERMQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22824, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERM2I128[] = {
+    {I_VPERM2I128, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16104, 207},
+    {I_VPERM2I128, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16112, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTI128[] = {
+    {I_VEXTRACTI128, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16120, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTI128[] = {
+    {I_VINSERTI128, 4, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16128, 207},
+    {I_VINSERTI128, 3, {YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16136, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMASKMOVD[] = {
+    {I_VPMASKMOVD, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41131, 207},
+    {I_VPMASKMOVD, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41138, 207},
+    {I_VPMASKMOVD, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41145, 207},
+    {I_VPMASKMOVD, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41152, 207},
+    {I_VPMASKMOVD, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41187, 207},
+    {I_VPMASKMOVD, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41194, 207},
+    {I_VPMASKMOVD, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41201, 207},
+    {I_VPMASKMOVD, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41208, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMASKMOVQ[] = {
+    {I_VPMASKMOVQ, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41159, 207},
+    {I_VPMASKMOVQ, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41166, 207},
+    {I_VPMASKMOVQ, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41173, 207},
+    {I_VPMASKMOVQ, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41180, 207},
+    {I_VPMASKMOVQ, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41215, 207},
+    {I_VPMASKMOVQ, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41222, 207},
+    {I_VPMASKMOVQ, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41229, 207},
+    {I_VPMASKMOVQ, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41236, 207},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLVD[] = {
+    {I_VPSLLVD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41243, 207},
+    {I_VPSLLVD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41250, 207},
+    {I_VPSLLVD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41271, 207},
+    {I_VPSLLVD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41278, 207},
+    {I_VPSLLVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26288, 240},
+    {I_VPSLLVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26296, 240},
+    {I_VPSLLVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26304, 240},
+    {I_VPSLLVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26312, 240},
+    {I_VPSLLVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26320, 241},
+    {I_VPSLLVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26328, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLVQ[] = {
+    {I_VPSLLVQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41257, 207},
+    {I_VPSLLVQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41264, 207},
+    {I_VPSLLVQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41285, 207},
+    {I_VPSLLVQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41292, 207},
+    {I_VPSLLVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26336, 240},
+    {I_VPSLLVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26344, 240},
+    {I_VPSLLVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26352, 240},
+    {I_VPSLLVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26360, 240},
+    {I_VPSLLVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26368, 241},
+    {I_VPSLLVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26376, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRAVD[] = {
+    {I_VPSRAVD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41299, 207},
+    {I_VPSRAVD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41306, 207},
+    {I_VPSRAVD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41313, 207},
+    {I_VPSRAVD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41320, 207},
+    {I_VPSRAVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26576, 240},
+    {I_VPSRAVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26584, 240},
+    {I_VPSRAVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26592, 240},
+    {I_VPSRAVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26600, 240},
+    {I_VPSRAVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26608, 241},
+    {I_VPSRAVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26616, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLVD[] = {
+    {I_VPSRLVD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41327, 207},
+    {I_VPSRLVD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41334, 207},
+    {I_VPSRLVD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41355, 207},
+    {I_VPSRLVD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41362, 207},
+    {I_VPSRLVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26864, 240},
+    {I_VPSRLVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26872, 240},
+    {I_VPSRLVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26880, 240},
+    {I_VPSRLVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26888, 240},
+    {I_VPSRLVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26896, 241},
+    {I_VPSRLVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26904, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLVQ[] = {
+    {I_VPSRLVQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41341, 207},
+    {I_VPSRLVQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41348, 207},
+    {I_VPSRLVQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41369, 207},
+    {I_VPSRLVQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41376, 207},
+    {I_VPSRLVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26912, 240},
+    {I_VPSRLVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26920, 240},
+    {I_VPSRLVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26928, 240},
+    {I_VPSRLVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26936, 240},
+    {I_VPSRLVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26944, 241},
+    {I_VPSRLVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26952, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERDPD[] = {
+    {I_VGATHERDPD, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16144, 207},
+    {I_VGATHERDPD, 3, {YMM_L16,XMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16160, 207},
+    {I_VGATHERDPD, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8704, 240},
+    {I_VGATHERDPD, 2, {YMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8713, 240},
+    {I_VGATHERDPD, 2, {ZMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8722, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERQPD[] = {
+    {I_VGATHERQPD, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16152, 207},
+    {I_VGATHERQPD, 3, {YMM_L16,YMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16168, 207},
+    {I_VGATHERQPD, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8830, 240},
+    {I_VGATHERQPD, 2, {YMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8839, 240},
+    {I_VGATHERQPD, 2, {ZMMREG,ZMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8848, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERDPS[] = {
+    {I_VGATHERDPS, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16176, 207},
+    {I_VGATHERDPS, 3, {YMM_L16,YMEM|BITS32,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16192, 207},
+    {I_VGATHERDPS, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8731, 240},
+    {I_VGATHERDPS, 2, {YMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8740, 240},
+    {I_VGATHERDPS, 2, {ZMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8749, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERQPS[] = {
+    {I_VGATHERQPS, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16184, 207},
+    {I_VGATHERQPS, 3, {XMM_L16,YMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16200, 207},
+    {I_VGATHERQPS, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8857, 240},
+    {I_VGATHERQPS, 2, {XMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8866, 240},
+    {I_VGATHERQPS, 2, {YMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8875, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPGATHERDD[] = {
+    {I_VPGATHERDD, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16208, 207},
+    {I_VPGATHERDD, 3, {YMM_L16,YMEM|BITS32,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16224, 207},
+    {I_VPGATHERDD, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9595, 240},
+    {I_VPGATHERDD, 2, {YMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9604, 240},
+    {I_VPGATHERDD, 2, {ZMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9613, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPGATHERQD[] = {
+    {I_VPGATHERQD, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16216, 207},
+    {I_VPGATHERQD, 3, {XMM_L16,YMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16232, 207},
+    {I_VPGATHERQD, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9649, 240},
+    {I_VPGATHERQD, 2, {XMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9658, 240},
+    {I_VPGATHERQD, 2, {YMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9667, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPGATHERDQ[] = {
+    {I_VPGATHERDQ, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16240, 207},
+    {I_VPGATHERDQ, 3, {YMM_L16,XMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16256, 207},
+    {I_VPGATHERDQ, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9622, 240},
+    {I_VPGATHERDQ, 2, {YMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9631, 240},
+    {I_VPGATHERDQ, 2, {ZMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9640, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPGATHERQQ[] = {
+    {I_VPGATHERQQ, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16248, 207},
+    {I_VPGATHERQQ, 3, {YMM_L16,YMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16264, 207},
+    {I_VPGATHERQQ, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9676, 240},
+    {I_VPGATHERQQ, 2, {YMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9685, 240},
+    {I_VPGATHERQQ, 2, {ZMMREG,ZMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9694, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XABORT[] = {
+    {I_XABORT, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49162, 208},
+    {I_XABORT, 1, {IMMEDIATE|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49162, 208},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XBEGIN[] = {
+    {I_XBEGIN, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45855, 208},
+    {I_XBEGIN, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45855, 208},
+    {I_XBEGIN, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45861, 209},
+    {I_XBEGIN, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45861, 209},
+    {I_XBEGIN, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45867, 209},
+    {I_XBEGIN, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45867, 209},
+    {I_XBEGIN, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45873, 210},
+    {I_XBEGIN, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45873, 210},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XEND[] = {
+    {I_XEND, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49167, 208},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XTEST[] = {
+    {I_XTEST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49172, 211},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ANDN[] = {
+    {I_ANDN, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41383, 212},
+    {I_ANDN, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41390, 213},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BEXTR[] = {
+    {I_BEXTR, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41397, 212},
+    {I_BEXTR, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41404, 213},
+    {I_BEXTR, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+16272, 214},
+    {I_BEXTR, 3, {REG_GPR|BITS64,RM_GPR|BITS64,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+16280, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLCI[] = {
+    {I_BLCI, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41411, 214},
+    {I_BLCI, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41418, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLCIC[] = {
+    {I_BLCIC, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41425, 214},
+    {I_BLCIC, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41432, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLSI[] = {
+    {I_BLSI, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41439, 212},
+    {I_BLSI, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41446, 213},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLSIC[] = {
+    {I_BLSIC, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41453, 214},
+    {I_BLSIC, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41460, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLCFILL[] = {
+    {I_BLCFILL, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41467, 214},
+    {I_BLCFILL, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41474, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLSFILL[] = {
+    {I_BLSFILL, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41481, 214},
+    {I_BLSFILL, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41488, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLCMSK[] = {
+    {I_BLCMSK, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41495, 214},
+    {I_BLCMSK, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41502, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLSMSK[] = {
+    {I_BLSMSK, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41509, 212},
+    {I_BLSMSK, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41516, 213},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLSR[] = {
+    {I_BLSR, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41523, 212},
+    {I_BLSR, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41530, 213},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BLCS[] = {
+    {I_BLCS, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41537, 214},
+    {I_BLCS, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41544, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BZHI[] = {
+    {I_BZHI, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41551, 216},
+    {I_BZHI, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41558, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MULX[] = {
+    {I_MULX, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41565, 216},
+    {I_MULX, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41572, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PDEP[] = {
+    {I_PDEP, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41579, 216},
+    {I_PDEP, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41586, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PEXT[] = {
+    {I_PEXT, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41593, 216},
+    {I_PEXT, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41600, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RORX[] = {
+    {I_RORX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16288, 216},
+    {I_RORX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16296, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SARX[] = {
+    {I_SARX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41607, 216},
+    {I_SARX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41614, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHLX[] = {
+    {I_SHLX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41621, 216},
+    {I_SHLX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41628, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHRX[] = {
+    {I_SHRX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41635, 216},
+    {I_SHRX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41642, 217},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TZCNT[] = {
+    {I_TZCNT, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41649, 218},
+    {I_TZCNT, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41656, 218},
+    {I_TZCNT, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41663, 219},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TZMSK[] = {
+    {I_TZMSK, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41670, 214},
+    {I_TZMSK, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41677, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_T1MSKC[] = {
+    {I_T1MSKC, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41684, 214},
+    {I_T1MSKC, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41691, 215},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PREFETCHWT1[] = {
+    {I_PREFETCHWT1, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49177, 220},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDMK[] = {
+    {I_BNDMK, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45879, 221},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDCL[] = {
+    {I_BNDCL, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41699, 222},
+    {I_BNDCL, 2, {BNDREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41699, 223},
+    {I_BNDCL, 2, {BNDREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41698, 224},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDCU[] = {
+    {I_BNDCU, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41706, 222},
+    {I_BNDCU, 2, {BNDREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41706, 223},
+    {I_BNDCU, 2, {BNDREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41705, 224},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDCN[] = {
+    {I_BNDCN, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41713, 222},
+    {I_BNDCN, 2, {BNDREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41713, 223},
+    {I_BNDCN, 2, {BNDREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41712, 224},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDMOV[] = {
+    {I_BNDMOV, 2, {BNDREG,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45885, 222},
+    {I_BNDMOV, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45885, 222},
+    {I_BNDMOV, 2, {BNDREG,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45891, 222},
+    {I_BNDMOV, 2, {MEMORY,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45891, 222},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDLDX[] = {
+    {I_BNDLDX, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45886, 221},
+    {I_BNDLDX, 3, {BNDREG,MEMORY,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+45897, 225},
+    {I_BNDLDX, 3, {BNDREG,MEMORY,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+45897, 226},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_BNDSTX[] = {
+    {I_BNDSTX, 2, {MEMORY,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45892, 221},
+    {I_BNDSTX, 3, {MEMORY,REG_GPR|BITS32,BNDREG,0,0}, NO_DECORATOR, nasm_bytecodes+45903, 225},
+    {I_BNDSTX, 3, {MEMORY,REG_GPR|BITS64,BNDREG,0,0}, NO_DECORATOR, nasm_bytecodes+45903, 226},
+    {I_BNDSTX, 3, {MEMORY,BNDREG,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+45909, 225},
+    {I_BNDSTX, 3, {MEMORY,BNDREG,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+45909, 226},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA1MSG1[] = {
+    {I_SHA1MSG1, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45915, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA1MSG2[] = {
+    {I_SHA1MSG2, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45921, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA1NEXTE[] = {
+    {I_SHA1NEXTE, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45927, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA1RNDS4[] = {
+    {I_SHA1RNDS4, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+41719, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA256MSG1[] = {
+    {I_SHA256MSG1, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45933, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA256MSG2[] = {
+    {I_SHA256MSG2, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45939, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SHA256RNDS2[] = {
+    {I_SHA256RNDS2, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+45945, 227},
+    {I_SHA256RNDS2, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45945, 227},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBCSTNEBF16PS[] = {
+    {I_VBCSTNEBF16PS, 2, {XMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41726, 228},
+    {I_VBCSTNEBF16PS, 2, {YMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41733, 228},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBCSTNESH2PS[] = {
+    {I_VBCSTNESH2PS, 2, {XMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41740, 228},
+    {I_VBCSTNESH2PS, 2, {YMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41747, 228},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTNEEBF162PS[] = {
+    {I_VCVTNEEBF162PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41754, 229},
+    {I_VCVTNEEBF162PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41761, 230},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTNEEPH2PS[] = {
+    {I_VCVTNEEPH2PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41768, 229},
+    {I_VCVTNEEPH2PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41775, 230},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTNEOBF162PS[] = {
+    {I_VCVTNEOBF162PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41782, 229},
+    {I_VCVTNEOBF162PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41789, 230},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTNEOPH2PS[] = {
+    {I_VCVTNEOPH2PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41796, 229},
+    {I_VCVTNEOPH2PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41803, 230},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTNEPS2BF16[] = {
+    {I_VCVTNEPS2BF16, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41810, 229},
+    {I_VCVTNEPS2BF16, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41817, 230},
+    {I_VCVTNEPS2BF16, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30064, 289},
+    {I_VCVTNEPS2BF16, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30072, 289},
+    {I_VCVTNEPS2BF16, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30080, 289},
+    {I_VCVTNEPS2BF16, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30088, 289},
+    {I_VCVTNEPS2BF16, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30096, 289},
+    {I_VCVTNEPS2BF16, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30104, 289},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBSSD[] = {
+    {I_VPDPBSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41824, 231},
+    {I_VPDPBSSD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41831, 232},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBSSDS[] = {
+    {I_VPDPBSSDS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41838, 231},
+    {I_VPDPBSSDS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41845, 232},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBSUD[] = {
+    {I_VPDPBSUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41852, 231},
+    {I_VPDPBSUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41859, 232},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBSUDS[] = {
+    {I_VPDPBSUDS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41866, 231},
+    {I_VPDPBSUDS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41873, 232},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBUUD[] = {
+    {I_VPDPBUUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41880, 231},
+    {I_VPDPBUUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41887, 232},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBUUDS[] = {
+    {I_VPDPBUUDS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41894, 231},
+    {I_VPDPBUUDS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41901, 232},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD52HUQ[] = {
+    {I_VPMADD52HUQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41908, 233},
+    {I_VPMADD52HUQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41915, 234},
+    {I_VPMADD52HUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23120, 252},
+    {I_VPMADD52HUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23128, 252},
+    {I_VPMADD52HUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23136, 253},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD52LUQ[] = {
+    {I_VPMADD52LUQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41922, 233},
+    {I_VPMADD52LUQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41929, 234},
+    {I_VPMADD52LUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23144, 252},
+    {I_VPMADD52LUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23152, 252},
+    {I_VPMADD52LUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23160, 253},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KADDB[] = {
+    {I_KADDB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41936, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KADDD[] = {
+    {I_KADDD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41943, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KADDQ[] = {
+    {I_KADDQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41950, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KADDW[] = {
+    {I_KADDW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41957, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDB[] = {
+    {I_KANDB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41964, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDD[] = {
+    {I_KANDD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41971, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDNB[] = {
+    {I_KANDNB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41978, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDND[] = {
+    {I_KANDND, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41985, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDNQ[] = {
+    {I_KANDNQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41992, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDNW[] = {
+    {I_KANDNW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41999, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDQ[] = {
+    {I_KANDQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42006, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDW[] = {
+    {I_KANDW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42013, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KMOVB[] = {
+    {I_KMOVB, 2, {KREG,RM_K|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42020, 235},
+    {I_KMOVB, 2, {MEMORY|BITS8,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42027, 235},
+    {I_KMOVB, 2, {KREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42034, 235},
+    {I_KMOVB, 2, {KREG,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16304, 235},
+    {I_KMOVB, 2, {REG_GPR|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42041, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KMOVD[] = {
+    {I_KMOVD, 2, {KREG,RM_K|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42048, 235},
+    {I_KMOVD, 2, {MEMORY|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42055, 235},
+    {I_KMOVD, 2, {KREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42062, 235},
+    {I_KMOVD, 2, {REG_GPR|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42069, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KMOVQ[] = {
+    {I_KMOVQ, 2, {KREG,RM_K|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42076, 235},
+    {I_KMOVQ, 2, {MEMORY|BITS64,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42083, 235},
+    {I_KMOVQ, 2, {KREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42090, 235},
+    {I_KMOVQ, 2, {REG_GPR|BITS64,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42097, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KMOVW[] = {
+    {I_KMOVW, 2, {KREG,RM_K|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42104, 235},
+    {I_KMOVW, 2, {MEMORY|BITS16,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42111, 235},
+    {I_KMOVW, 2, {KREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42118, 235},
+    {I_KMOVW, 2, {KREG,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42118, 235},
+    {I_KMOVW, 2, {REG_GPR|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42125, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KNOTB[] = {
+    {I_KNOTB, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42132, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KNOTD[] = {
+    {I_KNOTD, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42139, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KNOTQ[] = {
+    {I_KNOTQ, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42146, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KNOTW[] = {
+    {I_KNOTW, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42153, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORB[] = {
+    {I_KORB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42160, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORD[] = {
+    {I_KORD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42167, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORQ[] = {
+    {I_KORQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42174, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORW[] = {
+    {I_KORW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42181, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORTESTB[] = {
+    {I_KORTESTB, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42188, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORTESTD[] = {
+    {I_KORTESTD, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42195, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORTESTQ[] = {
+    {I_KORTESTQ, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42202, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORTESTW[] = {
+    {I_KORTESTW, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42209, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTLB[] = {
+    {I_KSHIFTLB, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16312, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTLD[] = {
+    {I_KSHIFTLD, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16320, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTLQ[] = {
+    {I_KSHIFTLQ, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16328, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTLW[] = {
+    {I_KSHIFTLW, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16336, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTRB[] = {
+    {I_KSHIFTRB, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16344, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTRD[] = {
+    {I_KSHIFTRD, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16352, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTRQ[] = {
+    {I_KSHIFTRQ, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16360, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTRW[] = {
+    {I_KSHIFTRW, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16368, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KTESTB[] = {
+    {I_KTESTB, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42216, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KTESTD[] = {
+    {I_KTESTD, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42223, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KTESTQ[] = {
+    {I_KTESTQ, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42230, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KTESTW[] = {
+    {I_KTESTW, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42237, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KUNPCKBW[] = {
+    {I_KUNPCKBW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42244, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KUNPCKDQ[] = {
+    {I_KUNPCKDQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42251, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KUNPCKWD[] = {
+    {I_KUNPCKWD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42258, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXNORB[] = {
+    {I_KXNORB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42265, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXNORD[] = {
+    {I_KXNORD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42272, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXNORQ[] = {
+    {I_KXNORQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42279, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXNORW[] = {
+    {I_KXNORW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42286, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXORB[] = {
+    {I_KXORB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42293, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXORD[] = {
+    {I_KXORD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42300, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXORQ[] = {
+    {I_KXORQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42307, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXORW[] = {
+    {I_KXORW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42314, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KADD[] = {
+    {I_KADD, 3, {KREG|BITS8,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41936, 236},
+    {I_KADD, 3, {KREG|BITS32,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41943, 236},
+    {I_KADD, 3, {KREG|BITS64,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41950, 236},
+    {I_KADD, 3, {KREG|BITS16,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41957, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KAND[] = {
+    {I_KAND, 3, {KREG|BITS8,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41964, 236},
+    {I_KAND, 3, {KREG|BITS32,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41971, 236},
+    {I_KAND, 3, {KREG|BITS64,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42006, 236},
+    {I_KAND, 3, {KREG|BITS16,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42013, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KANDN[] = {
+    {I_KANDN, 3, {KREG|BITS64,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41978, 236},
+    {I_KANDN, 3, {KREG|BITS16,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41985, 236},
+    {I_KANDN, 3, {KREG|BITS8,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41992, 236},
+    {I_KANDN, 3, {KREG|BITS32,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41999, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KMOV[] = {
+    {I_KMOV, 2, {KREG|BITS8,RM_K|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42020, 236},
+    {I_KMOV, 2, {MEMORY|BITS8,KREG|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42027, 237},
+    {I_KMOV, 2, {KREG|BITS8,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42034, 238},
+    {I_KMOV, 2, {KREG|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42034, 236},
+    {I_KMOV, 2, {REG_GPR|BITS32,KREG|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42041, 238},
+    {I_KMOV, 2, {KREG|BITS32,RM_K|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42048, 236},
+    {I_KMOV, 2, {MEMORY|BITS32,KREG|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42055, 236},
+    {I_KMOV, 2, {KREG|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42062, 236},
+    {I_KMOV, 2, {REG_GPR|BITS32,KREG|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42069, 236},
+    {I_KMOV, 2, {KREG|BITS64,RM_K|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42076, 236},
+    {I_KMOV, 2, {MEMORY|BITS64,KREG|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42083, 236},
+    {I_KMOV, 2, {KREG|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42090, 236},
+    {I_KMOV, 2, {REG_GPR|BITS64,KREG|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42097, 236},
+    {I_KMOV, 2, {KREG|BITS16,RM_K|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42104, 236},
+    {I_KMOV, 2, {MEMORY|BITS16,KREG|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42111, 236},
+    {I_KMOV, 2, {KREG|BITS16,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42118, 238},
+    {I_KMOV, 2, {REG_GPR|BITS32,KREG|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42125, 238},
+    {I_KMOV, 2, {KREG|BITS16,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42118, 238},
+    {I_KMOV, 2, {KREG|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42118, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KNOT[] = {
+    {I_KNOT, 2, {KREG|BITS8,KREG|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42132, 236},
+    {I_KNOT, 2, {KREG|BITS32,KREG|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42139, 236},
+    {I_KNOT, 2, {KREG|BITS64,KREG|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42146, 236},
+    {I_KNOT, 2, {KREG|BITS16,KREG|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42153, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KOR[] = {
+    {I_KOR, 3, {KREG|BITS8,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42160, 236},
+    {I_KOR, 3, {KREG|BITS32,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42167, 236},
+    {I_KOR, 3, {KREG|BITS64,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42174, 236},
+    {I_KOR, 3, {KREG|BITS16,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42181, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KORTEST[] = {
+    {I_KORTEST, 2, {KREG|BITS8,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42188, 236},
+    {I_KORTEST, 2, {KREG|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42195, 236},
+    {I_KORTEST, 2, {KREG|BITS64,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42202, 236},
+    {I_KORTEST, 2, {KREG|BITS16,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42209, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTL[] = {
+    {I_KSHIFTL, 3, {KREG|BITS8,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16312, 239},
+    {I_KSHIFTL, 3, {KREG|BITS32,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16320, 239},
+    {I_KSHIFTL, 3, {KREG|BITS64,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16328, 239},
+    {I_KSHIFTL, 3, {KREG|BITS16,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16336, 239},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KSHIFTR[] = {
+    {I_KSHIFTR, 3, {KREG|BITS8,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16344, 239},
+    {I_KSHIFTR, 3, {KREG|BITS32,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16352, 239},
+    {I_KSHIFTR, 3, {KREG|BITS64,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16360, 239},
+    {I_KSHIFTR, 3, {KREG|BITS16,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16368, 239},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KTEST[] = {
+    {I_KTEST, 2, {KREG|BITS8,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42216, 236},
+    {I_KTEST, 2, {KREG|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42223, 236},
+    {I_KTEST, 2, {KREG|BITS64,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42230, 236},
+    {I_KTEST, 2, {KREG|BITS16,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42237, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KUNPCK[] = {
+    {I_KUNPCK, 3, {KREG|BITS16,KREG|BITS8,KREG|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+42244, 235},
+    {I_KUNPCK, 3, {KREG|BITS64,KREG|BITS32,KREG|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42251, 235},
+    {I_KUNPCK, 3, {KREG|BITS32,KREG|BITS16,KREG|BITS16,0,0}, NO_DECORATOR, nasm_bytecodes+42258, 235},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXNOR[] = {
+    {I_KXNOR, 3, {KREG|BITS8,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42265, 236},
+    {I_KXNOR, 3, {KREG|BITS32,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42272, 236},
+    {I_KXNOR, 3, {KREG|BITS64,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42279, 236},
+    {I_KXNOR, 3, {KREG|BITS16,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42286, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_KXOR[] = {
+    {I_KXOR, 3, {KREG|BITS8,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42293, 236},
+    {I_KXOR, 3, {KREG|BITS32,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42300, 236},
+    {I_KXOR, 3, {KREG|BITS64,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42307, 236},
+    {I_KXOR, 3, {KREG|BITS16,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42314, 236},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VALIGND[] = {
+    {I_VALIGND, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8002, 240},
+    {I_VALIGND, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8011, 240},
+    {I_VALIGND, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8020, 240},
+    {I_VALIGND, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8029, 240},
+    {I_VALIGND, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8038, 241},
+    {I_VALIGND, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8047, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VALIGNQ[] = {
+    {I_VALIGNQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8056, 240},
+    {I_VALIGNQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8065, 240},
+    {I_VALIGNQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8074, 240},
+    {I_VALIGNQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8083, 240},
+    {I_VALIGNQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8092, 241},
+    {I_VALIGNQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8101, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBLENDMPD[] = {
+    {I_VBLENDMPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16696, 240},
+    {I_VBLENDMPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16704, 240},
+    {I_VBLENDMPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16712, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBLENDMPS[] = {
+    {I_VBLENDMPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16720, 240},
+    {I_VBLENDMPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16728, 240},
+    {I_VBLENDMPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16736, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTF32X2[] = {
+    {I_VBROADCASTF32X2, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16744, 242},
+    {I_VBROADCASTF32X2, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16752, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTF32X4[] = {
+    {I_VBROADCASTF32X4, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16760, 240},
+    {I_VBROADCASTF32X4, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16768, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTF32X8[] = {
+    {I_VBROADCASTF32X8, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16776, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTF64X2[] = {
+    {I_VBROADCASTF64X2, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16784, 242},
+    {I_VBROADCASTF64X2, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16792, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTF64X4[] = {
+    {I_VBROADCASTF64X4, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16800, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTI32X2[] = {
+    {I_VBROADCASTI32X2, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16808, 242},
+    {I_VBROADCASTI32X2, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16816, 242},
+    {I_VBROADCASTI32X2, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16824, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTI32X4[] = {
+    {I_VBROADCASTI32X4, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16832, 240},
+    {I_VBROADCASTI32X4, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16840, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTI32X8[] = {
+    {I_VBROADCASTI32X8, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16848, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTI64X2[] = {
+    {I_VBROADCASTI64X2, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16856, 242},
+    {I_VBROADCASTI64X2, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16864, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VBROADCASTI64X4[] = {
+    {I_VBROADCASTI64X4, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16872, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OQPD[] = {
+    {I_VCMPEQ_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+240, 240},
+    {I_VCMPEQ_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+250, 240},
+    {I_VCMPEQ_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+260, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OQPS[] = {
+    {I_VCMPEQ_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+270, 240},
+    {I_VCMPEQ_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+280, 240},
+    {I_VCMPEQ_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+290, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OQSD[] = {
+    {I_VCMPEQ_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+300, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPEQ_OQSS[] = {
+    {I_VCMPEQ_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+310, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCOMPRESSPD[] = {
+    {I_VCOMPRESSPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+16976, 240},
+    {I_VCOMPRESSPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+16984, 240},
+    {I_VCOMPRESSPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+16992, 241},
+    {I_VCOMPRESSPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17000, 240},
+    {I_VCOMPRESSPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17008, 240},
+    {I_VCOMPRESSPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17016, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCOMPRESSPS[] = {
+    {I_VCOMPRESSPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+17024, 240},
+    {I_VCOMPRESSPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+17032, 240},
+    {I_VCOMPRESSPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+17040, 241},
+    {I_VCOMPRESSPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17048, 240},
+    {I_VCOMPRESSPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17056, 240},
+    {I_VCOMPRESSPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17064, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPD2QQ[] = {
+    {I_VCVTPD2QQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17168, 242},
+    {I_VCVTPD2QQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17176, 242},
+    {I_VCVTPD2QQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17184, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPD2UDQ[] = {
+    {I_VCVTPD2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17192, 240},
+    {I_VCVTPD2UDQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17200, 240},
+    {I_VCVTPD2UDQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17208, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPD2UQQ[] = {
+    {I_VCVTPD2UQQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17216, 242},
+    {I_VCVTPD2UQQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17224, 242},
+    {I_VCVTPD2UQQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17232, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPS2QQ[] = {
+    {I_VCVTPS2QQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17312, 242},
+    {I_VCVTPS2QQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17320, 242},
+    {I_VCVTPS2QQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17328, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPS2UDQ[] = {
+    {I_VCVTPS2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17336, 240},
+    {I_VCVTPS2UDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17344, 240},
+    {I_VCVTPS2UDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17352, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPS2UQQ[] = {
+    {I_VCVTPS2UQQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17360, 242},
+    {I_VCVTPS2UQQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17368, 242},
+    {I_VCVTPS2UQQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17376, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTQQ2PD[] = {
+    {I_VCVTQQ2PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17384, 242},
+    {I_VCVTQQ2PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17392, 242},
+    {I_VCVTQQ2PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17400, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTQQ2PS[] = {
+    {I_VCVTQQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17408, 242},
+    {I_VCVTQQ2PS, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17416, 242},
+    {I_VCVTQQ2PS, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17424, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSD2USI[] = {
+    {I_VCVTSD2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17456, 241},
+    {I_VCVTSD2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17464, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSS2USI[] = {
+    {I_VCVTSS2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17528, 241},
+    {I_VCVTSS2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17536, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPD2QQ[] = {
+    {I_VCVTTPD2QQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17568, 242},
+    {I_VCVTTPD2QQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17576, 242},
+    {I_VCVTTPD2QQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17584, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPD2UDQ[] = {
+    {I_VCVTTPD2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17592, 240},
+    {I_VCVTTPD2UDQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17600, 240},
+    {I_VCVTTPD2UDQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17608, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPD2UQQ[] = {
+    {I_VCVTTPD2UQQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17616, 242},
+    {I_VCVTTPD2UQQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17624, 242},
+    {I_VCVTTPD2UQQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17632, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPS2QQ[] = {
+    {I_VCVTTPS2QQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17664, 242},
+    {I_VCVTTPS2QQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17672, 242},
+    {I_VCVTTPS2QQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17680, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPS2UDQ[] = {
+    {I_VCVTTPS2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17688, 240},
+    {I_VCVTTPS2UDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17696, 240},
+    {I_VCVTTPS2UDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17704, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPS2UQQ[] = {
+    {I_VCVTTPS2UQQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17712, 242},
+    {I_VCVTTPS2UQQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17720, 242},
+    {I_VCVTTPS2UQQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17728, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTSD2USI[] = {
+    {I_VCVTTSD2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17752, 241},
+    {I_VCVTTSD2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17760, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTSS2USI[] = {
+    {I_VCVTTSS2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17784, 241},
+    {I_VCVTTSS2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17792, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUDQ2PD[] = {
+    {I_VCVTUDQ2PD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17800, 240},
+    {I_VCVTUDQ2PD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17808, 240},
+    {I_VCVTUDQ2PD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17816, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUDQ2PS[] = {
+    {I_VCVTUDQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17824, 240},
+    {I_VCVTUDQ2PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17832, 240},
+    {I_VCVTUDQ2PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17840, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUQQ2PD[] = {
+    {I_VCVTUQQ2PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17848, 242},
+    {I_VCVTUQQ2PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17856, 242},
+    {I_VCVTUQQ2PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17864, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUQQ2PS[] = {
+    {I_VCVTUQQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17872, 242},
+    {I_VCVTUQQ2PS, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17880, 242},
+    {I_VCVTUQQ2PS, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17888, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUSI2SD[] = {
+    {I_VCVTUSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17896, 241},
+    {I_VCVTUSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17904, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUSI2SS[] = {
+    {I_VCVTUSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17912, 241},
+    {I_VCVTUSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17920, 241},
+    {I_VCVTUSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,ER,0,0}, nasm_bytecodes+30912, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDBPSADBW[] = {
+    {I_VDBPSADBW, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8209, 244},
+    {I_VDBPSADBW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8218, 244},
+    {I_VDBPSADBW, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8227, 244},
+    {I_VDBPSADBW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8236, 244},
+    {I_VDBPSADBW, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8245, 245},
+    {I_VDBPSADBW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8254, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXP2PD[] = {
+    {I_VEXP2PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+18056, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXP2PS[] = {
+    {I_VEXP2PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+18064, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXPANDPD[] = {
+    {I_VEXPANDPD, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18072, 240},
+    {I_VEXPANDPD, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18080, 240},
+    {I_VEXPANDPD, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18088, 241},
+    {I_VEXPANDPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18072, 240},
+    {I_VEXPANDPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18080, 240},
+    {I_VEXPANDPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18088, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXPANDPS[] = {
+    {I_VEXPANDPS, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18096, 240},
+    {I_VEXPANDPS, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18104, 240},
+    {I_VEXPANDPS, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18112, 241},
+    {I_VEXPANDPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18096, 240},
+    {I_VEXPANDPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18104, 240},
+    {I_VEXPANDPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18112, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTF32X4[] = {
+    {I_VEXTRACTF32X4, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8263, 240},
+    {I_VEXTRACTF32X4, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8272, 241},
+    {I_VEXTRACTF32X4, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8281, 240},
+    {I_VEXTRACTF32X4, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8290, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTF32X8[] = {
+    {I_VEXTRACTF32X8, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8299, 243},
+    {I_VEXTRACTF32X8, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8308, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTF64X2[] = {
+    {I_VEXTRACTF64X2, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8317, 242},
+    {I_VEXTRACTF64X2, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8326, 243},
+    {I_VEXTRACTF64X2, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8335, 242},
+    {I_VEXTRACTF64X2, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8344, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTF64X4[] = {
+    {I_VEXTRACTF64X4, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8353, 241},
+    {I_VEXTRACTF64X4, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8362, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTI32X4[] = {
+    {I_VEXTRACTI32X4, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8371, 240},
+    {I_VEXTRACTI32X4, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8380, 241},
+    {I_VEXTRACTI32X4, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8389, 240},
+    {I_VEXTRACTI32X4, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8398, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTI32X8[] = {
+    {I_VEXTRACTI32X8, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8407, 243},
+    {I_VEXTRACTI32X8, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8416, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTI64X2[] = {
+    {I_VEXTRACTI64X2, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8425, 242},
+    {I_VEXTRACTI64X2, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8434, 243},
+    {I_VEXTRACTI64X2, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8443, 242},
+    {I_VEXTRACTI64X2, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8452, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VEXTRACTI64X4[] = {
+    {I_VEXTRACTI64X4, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8461, 241},
+    {I_VEXTRACTI64X4, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8470, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFIXUPIMMPD[] = {
+    {I_VFIXUPIMMPD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8488, 240},
+    {I_VFIXUPIMMPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8497, 240},
+    {I_VFIXUPIMMPD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8506, 240},
+    {I_VFIXUPIMMPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8515, 240},
+    {I_VFIXUPIMMPD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+8524, 241},
+    {I_VFIXUPIMMPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+8533, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFIXUPIMMPS[] = {
+    {I_VFIXUPIMMPS, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8542, 240},
+    {I_VFIXUPIMMPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8551, 240},
+    {I_VFIXUPIMMPS, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8560, 240},
+    {I_VFIXUPIMMPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8569, 240},
+    {I_VFIXUPIMMPS, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+8578, 241},
+    {I_VFIXUPIMMPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+8587, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFIXUPIMMSD[] = {
+    {I_VFIXUPIMMSD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8596, 241},
+    {I_VFIXUPIMMSD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8605, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFIXUPIMMSS[] = {
+    {I_VFIXUPIMMSS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8614, 241},
+    {I_VFIXUPIMMSS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8623, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFPCLASSPD[] = {
+    {I_VFPCLASSPD, 3, {KREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK,B64,0,0,0}, nasm_bytecodes+8632, 242},
+    {I_VFPCLASSPD, 3, {KREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK,B64,0,0,0}, nasm_bytecodes+8641, 242},
+    {I_VFPCLASSPD, 3, {KREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK,B64,0,0,0}, nasm_bytecodes+8650, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFPCLASSPS[] = {
+    {I_VFPCLASSPS, 3, {KREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK,B32,0,0,0}, nasm_bytecodes+8659, 242},
+    {I_VFPCLASSPS, 3, {KREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK,B32,0,0,0}, nasm_bytecodes+8668, 242},
+    {I_VFPCLASSPS, 3, {KREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK,B32,0,0,0}, nasm_bytecodes+8677, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFPCLASSSD[] = {
+    {I_VFPCLASSSD, 3, {KREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8686, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFPCLASSSS[] = {
+    {I_VFPCLASSSS, 3, {KREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8695, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF0DPD[] = {
+    {I_VGATHERPF0DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8758, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF0DPS[] = {
+    {I_VGATHERPF0DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8767, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF0QPD[] = {
+    {I_VGATHERPF0QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8776, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF0QPS[] = {
+    {I_VGATHERPF0QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8785, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF1DPD[] = {
+    {I_VGATHERPF1DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8794, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF1DPS[] = {
+    {I_VGATHERPF1DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8803, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF1QPD[] = {
+    {I_VGATHERPF1QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8812, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGATHERPF1QPS[] = {
+    {I_VGATHERPF1QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8821, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETEXPPD[] = {
+    {I_VGETEXPPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19176, 240},
+    {I_VGETEXPPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19184, 240},
+    {I_VGETEXPPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+19192, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETEXPPS[] = {
+    {I_VGETEXPPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19200, 240},
+    {I_VGETEXPPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19208, 240},
+    {I_VGETEXPPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+19216, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETEXPSD[] = {
+    {I_VGETEXPSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19224, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETEXPSS[] = {
+    {I_VGETEXPSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19232, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMANTPD[] = {
+    {I_VGETMANTPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8884, 240},
+    {I_VGETMANTPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8893, 240},
+    {I_VGETMANTPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+8902, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMANTPS[] = {
+    {I_VGETMANTPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8911, 240},
+    {I_VGETMANTPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8920, 240},
+    {I_VGETMANTPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+8929, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMANTSD[] = {
+    {I_VGETMANTSD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8938, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMANTSS[] = {
+    {I_VGETMANTSS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8947, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTF32X4[] = {
+    {I_VINSERTF32X4, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8956, 240},
+    {I_VINSERTF32X4, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8965, 240},
+    {I_VINSERTF32X4, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8974, 241},
+    {I_VINSERTF32X4, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8983, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTF32X8[] = {
+    {I_VINSERTF32X8, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8992, 243},
+    {I_VINSERTF32X8, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9001, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTF64X2[] = {
+    {I_VINSERTF64X2, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9010, 242},
+    {I_VINSERTF64X2, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9019, 242},
+    {I_VINSERTF64X2, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9028, 243},
+    {I_VINSERTF64X2, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9037, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTF64X4[] = {
+    {I_VINSERTF64X4, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9046, 241},
+    {I_VINSERTF64X4, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9055, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTI32X4[] = {
+    {I_VINSERTI32X4, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9064, 240},
+    {I_VINSERTI32X4, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9073, 240},
+    {I_VINSERTI32X4, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9082, 241},
+    {I_VINSERTI32X4, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9091, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTI32X8[] = {
+    {I_VINSERTI32X8, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9100, 243},
+    {I_VINSERTI32X8, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9109, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTI64X2[] = {
+    {I_VINSERTI64X2, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9118, 242},
+    {I_VINSERTI64X2, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9127, 242},
+    {I_VINSERTI64X2, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9136, 243},
+    {I_VINSERTI64X2, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9145, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VINSERTI64X4[] = {
+    {I_VINSERTI64X4, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9154, 241},
+    {I_VINSERTI64X4, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9163, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQA32[] = {
+    {I_VMOVDQA32, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19680, 240},
+    {I_VMOVDQA32, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19688, 240},
+    {I_VMOVDQA32, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19696, 241},
+    {I_VMOVDQA32, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19704, 240},
+    {I_VMOVDQA32, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19712, 240},
+    {I_VMOVDQA32, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19720, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQA64[] = {
+    {I_VMOVDQA64, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19728, 240},
+    {I_VMOVDQA64, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19736, 240},
+    {I_VMOVDQA64, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19744, 241},
+    {I_VMOVDQA64, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19752, 240},
+    {I_VMOVDQA64, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19760, 240},
+    {I_VMOVDQA64, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19768, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQU16[] = {
+    {I_VMOVDQU16, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19776, 244},
+    {I_VMOVDQU16, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19784, 244},
+    {I_VMOVDQU16, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19792, 245},
+    {I_VMOVDQU16, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19800, 244},
+    {I_VMOVDQU16, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19808, 244},
+    {I_VMOVDQU16, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19816, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQU32[] = {
+    {I_VMOVDQU32, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19824, 240},
+    {I_VMOVDQU32, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19832, 240},
+    {I_VMOVDQU32, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19840, 241},
+    {I_VMOVDQU32, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19848, 240},
+    {I_VMOVDQU32, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19856, 240},
+    {I_VMOVDQU32, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19864, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQU64[] = {
+    {I_VMOVDQU64, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19872, 240},
+    {I_VMOVDQU64, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19880, 240},
+    {I_VMOVDQU64, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19888, 241},
+    {I_VMOVDQU64, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19896, 240},
+    {I_VMOVDQU64, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19904, 240},
+    {I_VMOVDQU64, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19912, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVDQU8[] = {
+    {I_VMOVDQU8, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19920, 244},
+    {I_VMOVDQU8, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19928, 244},
+    {I_VMOVDQU8, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19936, 245},
+    {I_VMOVDQU8, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19944, 244},
+    {I_VMOVDQU8, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19952, 244},
+    {I_VMOVDQU8, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19960, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPABSQ[] = {
+    {I_VPABSQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20784, 240},
+    {I_VPABSQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20792, 240},
+    {I_VPABSQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20800, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPANDD[] = {
+    {I_VPANDD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21408, 240},
+    {I_VPANDD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21416, 240},
+    {I_VPANDD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21424, 240},
+    {I_VPANDD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21432, 240},
+    {I_VPANDD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21440, 241},
+    {I_VPANDD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21448, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPANDND[] = {
+    {I_VPANDND, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21456, 240},
+    {I_VPANDND, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21464, 240},
+    {I_VPANDND, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21472, 240},
+    {I_VPANDND, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21480, 240},
+    {I_VPANDND, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21488, 241},
+    {I_VPANDND, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21496, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPANDNQ[] = {
+    {I_VPANDNQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21504, 240},
+    {I_VPANDNQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21512, 240},
+    {I_VPANDNQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21520, 240},
+    {I_VPANDNQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21528, 240},
+    {I_VPANDNQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21536, 241},
+    {I_VPANDNQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21544, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPANDQ[] = {
+    {I_VPANDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21552, 240},
+    {I_VPANDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21560, 240},
+    {I_VPANDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21568, 240},
+    {I_VPANDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21576, 240},
+    {I_VPANDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21584, 241},
+    {I_VPANDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21592, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDMB[] = {
+    {I_VPBLENDMB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21696, 244},
+    {I_VPBLENDMB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21704, 244},
+    {I_VPBLENDMB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21712, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDMD[] = {
+    {I_VPBLENDMD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21720, 240},
+    {I_VPBLENDMD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21728, 240},
+    {I_VPBLENDMD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21736, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDMQ[] = {
+    {I_VPBLENDMQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21744, 240},
+    {I_VPBLENDMQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21752, 240},
+    {I_VPBLENDMQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21760, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBLENDMW[] = {
+    {I_VPBLENDMW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21768, 244},
+    {I_VPBLENDMW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21776, 244},
+    {I_VPBLENDMW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21784, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBROADCASTMB2Q[] = {
+    {I_VPBROADCASTMB2Q, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21912, 248},
+    {I_VPBROADCASTMB2Q, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21920, 248},
+    {I_VPBROADCASTMB2Q, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21928, 249},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPBROADCASTMW2D[] = {
+    {I_VPBROADCASTMW2D, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21936, 248},
+    {I_VPBROADCASTMW2D, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21944, 248},
+    {I_VPBROADCASTMW2D, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21952, 249},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQUB[] = {
+    {I_VPCMPEQUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2890, 244},
+    {I_VPCMPEQUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2900, 244},
+    {I_VPCMPEQUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2910, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQUD[] = {
+    {I_VPCMPEQUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2920, 240},
+    {I_VPCMPEQUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2930, 240},
+    {I_VPCMPEQUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2940, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQUQ[] = {
+    {I_VPCMPEQUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2950, 240},
+    {I_VPCMPEQUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2960, 240},
+    {I_VPCMPEQUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2970, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPEQUW[] = {
+    {I_VPCMPEQUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2980, 244},
+    {I_VPCMPEQUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2990, 244},
+    {I_VPCMPEQUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3000, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEB[] = {
+    {I_VPCMPGEB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3040, 244},
+    {I_VPCMPGEB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3050, 244},
+    {I_VPCMPGEB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3060, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGED[] = {
+    {I_VPCMPGED, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3070, 240},
+    {I_VPCMPGED, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3080, 240},
+    {I_VPCMPGED, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3090, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEQ[] = {
+    {I_VPCMPGEQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3100, 240},
+    {I_VPCMPGEQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3110, 240},
+    {I_VPCMPGEQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3120, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEUB[] = {
+    {I_VPCMPGEUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3130, 244},
+    {I_VPCMPGEUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3140, 244},
+    {I_VPCMPGEUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3150, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEUD[] = {
+    {I_VPCMPGEUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3160, 240},
+    {I_VPCMPGEUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3170, 240},
+    {I_VPCMPGEUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3180, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEUQ[] = {
+    {I_VPCMPGEUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3190, 240},
+    {I_VPCMPGEUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3200, 240},
+    {I_VPCMPGEUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3210, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEUW[] = {
+    {I_VPCMPGEUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3220, 244},
+    {I_VPCMPGEUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3230, 244},
+    {I_VPCMPGEUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3240, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGEW[] = {
+    {I_VPCMPGEW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3250, 244},
+    {I_VPCMPGEW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3260, 244},
+    {I_VPCMPGEW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3270, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTUB[] = {
+    {I_VPCMPGTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3370, 244},
+    {I_VPCMPGTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3380, 244},
+    {I_VPCMPGTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3390, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTUD[] = {
+    {I_VPCMPGTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3400, 240},
+    {I_VPCMPGTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3410, 240},
+    {I_VPCMPGTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTUQ[] = {
+    {I_VPCMPGTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3430, 240},
+    {I_VPCMPGTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3440, 240},
+    {I_VPCMPGTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3450, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPGTUW[] = {
+    {I_VPCMPGTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3460, 244},
+    {I_VPCMPGTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3470, 244},
+    {I_VPCMPGTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3480, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEB[] = {
+    {I_VPCMPLEB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3520, 244},
+    {I_VPCMPLEB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3530, 244},
+    {I_VPCMPLEB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3540, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLED[] = {
+    {I_VPCMPLED, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3550, 240},
+    {I_VPCMPLED, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3560, 240},
+    {I_VPCMPLED, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3570, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEQ[] = {
+    {I_VPCMPLEQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3580, 240},
+    {I_VPCMPLEQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3590, 240},
+    {I_VPCMPLEQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3600, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEUB[] = {
+    {I_VPCMPLEUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3610, 244},
+    {I_VPCMPLEUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3620, 244},
+    {I_VPCMPLEUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3630, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEUD[] = {
+    {I_VPCMPLEUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3640, 240},
+    {I_VPCMPLEUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3650, 240},
+    {I_VPCMPLEUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3660, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEUQ[] = {
+    {I_VPCMPLEUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3670, 240},
+    {I_VPCMPLEUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3680, 240},
+    {I_VPCMPLEUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3690, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEUW[] = {
+    {I_VPCMPLEUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3700, 244},
+    {I_VPCMPLEUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3710, 244},
+    {I_VPCMPLEUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3720, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLEW[] = {
+    {I_VPCMPLEW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3730, 244},
+    {I_VPCMPLEW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3740, 244},
+    {I_VPCMPLEW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3750, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTB[] = {
+    {I_VPCMPLTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3760, 244},
+    {I_VPCMPLTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3770, 244},
+    {I_VPCMPLTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3780, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTD[] = {
+    {I_VPCMPLTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3790, 240},
+    {I_VPCMPLTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3800, 240},
+    {I_VPCMPLTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3810, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTQ[] = {
+    {I_VPCMPLTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3820, 240},
+    {I_VPCMPLTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3830, 240},
+    {I_VPCMPLTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3840, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTUB[] = {
+    {I_VPCMPLTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3850, 244},
+    {I_VPCMPLTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3860, 244},
+    {I_VPCMPLTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3870, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTUD[] = {
+    {I_VPCMPLTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3880, 240},
+    {I_VPCMPLTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3890, 240},
+    {I_VPCMPLTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3900, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTUQ[] = {
+    {I_VPCMPLTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3910, 240},
+    {I_VPCMPLTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3920, 240},
+    {I_VPCMPLTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3930, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTUW[] = {
+    {I_VPCMPLTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3940, 244},
+    {I_VPCMPLTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3950, 244},
+    {I_VPCMPLTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3960, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPLTW[] = {
+    {I_VPCMPLTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3970, 244},
+    {I_VPCMPLTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3980, 244},
+    {I_VPCMPLTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3990, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQB[] = {
+    {I_VPCMPNEQB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4000, 244},
+    {I_VPCMPNEQB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4010, 244},
+    {I_VPCMPNEQB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4020, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQD[] = {
+    {I_VPCMPNEQD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4030, 240},
+    {I_VPCMPNEQD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4040, 240},
+    {I_VPCMPNEQD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4050, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQQ[] = {
+    {I_VPCMPNEQQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4060, 240},
+    {I_VPCMPNEQQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4070, 240},
+    {I_VPCMPNEQQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4080, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQUB[] = {
+    {I_VPCMPNEQUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4090, 244},
+    {I_VPCMPNEQUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4100, 244},
+    {I_VPCMPNEQUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4110, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQUD[] = {
+    {I_VPCMPNEQUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4120, 240},
+    {I_VPCMPNEQUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4130, 240},
+    {I_VPCMPNEQUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4140, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQUQ[] = {
+    {I_VPCMPNEQUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4150, 240},
+    {I_VPCMPNEQUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4160, 240},
+    {I_VPCMPNEQUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4170, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQUW[] = {
+    {I_VPCMPNEQUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4180, 244},
+    {I_VPCMPNEQUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4190, 244},
+    {I_VPCMPNEQUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4200, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNEQW[] = {
+    {I_VPCMPNEQW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4210, 244},
+    {I_VPCMPNEQW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4220, 244},
+    {I_VPCMPNEQW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4230, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTB[] = {
+    {I_VPCMPNGTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3520, 244},
+    {I_VPCMPNGTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3530, 244},
+    {I_VPCMPNGTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3540, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTD[] = {
+    {I_VPCMPNGTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3550, 240},
+    {I_VPCMPNGTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3560, 240},
+    {I_VPCMPNGTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3570, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTQ[] = {
+    {I_VPCMPNGTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3580, 240},
+    {I_VPCMPNGTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3590, 240},
+    {I_VPCMPNGTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3600, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTUB[] = {
+    {I_VPCMPNGTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3610, 244},
+    {I_VPCMPNGTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3620, 244},
+    {I_VPCMPNGTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3630, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTUD[] = {
+    {I_VPCMPNGTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3640, 240},
+    {I_VPCMPNGTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3650, 240},
+    {I_VPCMPNGTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3660, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTUQ[] = {
+    {I_VPCMPNGTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3670, 240},
+    {I_VPCMPNGTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3680, 240},
+    {I_VPCMPNGTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3690, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTUW[] = {
+    {I_VPCMPNGTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3700, 244},
+    {I_VPCMPNGTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3710, 244},
+    {I_VPCMPNGTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3720, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNGTW[] = {
+    {I_VPCMPNGTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3730, 244},
+    {I_VPCMPNGTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3740, 244},
+    {I_VPCMPNGTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3750, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEB[] = {
+    {I_VPCMPNLEB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3280, 244},
+    {I_VPCMPNLEB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3290, 244},
+    {I_VPCMPNLEB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3300, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLED[] = {
+    {I_VPCMPNLED, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3310, 240},
+    {I_VPCMPNLED, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3320, 240},
+    {I_VPCMPNLED, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3330, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEQ[] = {
+    {I_VPCMPNLEQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3340, 240},
+    {I_VPCMPNLEQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3350, 240},
+    {I_VPCMPNLEQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3360, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEUB[] = {
+    {I_VPCMPNLEUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3370, 244},
+    {I_VPCMPNLEUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3380, 244},
+    {I_VPCMPNLEUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3390, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEUD[] = {
+    {I_VPCMPNLEUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3400, 240},
+    {I_VPCMPNLEUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3410, 240},
+    {I_VPCMPNLEUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3420, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEUQ[] = {
+    {I_VPCMPNLEUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3430, 240},
+    {I_VPCMPNLEUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3440, 240},
+    {I_VPCMPNLEUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3450, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEUW[] = {
+    {I_VPCMPNLEUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3460, 244},
+    {I_VPCMPNLEUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3470, 244},
+    {I_VPCMPNLEUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3480, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLEW[] = {
+    {I_VPCMPNLEW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3490, 244},
+    {I_VPCMPNLEW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3500, 244},
+    {I_VPCMPNLEW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3510, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTB[] = {
+    {I_VPCMPNLTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3040, 244},
+    {I_VPCMPNLTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3050, 244},
+    {I_VPCMPNLTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3060, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTD[] = {
+    {I_VPCMPNLTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3070, 240},
+    {I_VPCMPNLTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3080, 240},
+    {I_VPCMPNLTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3090, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTQ[] = {
+    {I_VPCMPNLTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3100, 240},
+    {I_VPCMPNLTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3110, 240},
+    {I_VPCMPNLTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3120, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTUB[] = {
+    {I_VPCMPNLTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3130, 244},
+    {I_VPCMPNLTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3140, 244},
+    {I_VPCMPNLTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3150, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTUD[] = {
+    {I_VPCMPNLTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3160, 240},
+    {I_VPCMPNLTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3170, 240},
+    {I_VPCMPNLTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3180, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTUQ[] = {
+    {I_VPCMPNLTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3190, 240},
+    {I_VPCMPNLTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3200, 240},
+    {I_VPCMPNLTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3210, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTUW[] = {
+    {I_VPCMPNLTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3220, 244},
+    {I_VPCMPNLTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3230, 244},
+    {I_VPCMPNLTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3240, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPNLTW[] = {
+    {I_VPCMPNLTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3250, 244},
+    {I_VPCMPNLTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3260, 244},
+    {I_VPCMPNLTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3270, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPB[] = {
+    {I_VPCMPB, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9244, 244},
+    {I_VPCMPB, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9253, 244},
+    {I_VPCMPB, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9262, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPD[] = {
+    {I_VPCMPD, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9271, 240},
+    {I_VPCMPD, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9280, 240},
+    {I_VPCMPD, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9289, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPQ[] = {
+    {I_VPCMPQ, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9298, 240},
+    {I_VPCMPQ, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9307, 240},
+    {I_VPCMPQ, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9316, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPUB[] = {
+    {I_VPCMPUB, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9325, 244},
+    {I_VPCMPUB, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9334, 244},
+    {I_VPCMPUB, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9343, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPUD[] = {
+    {I_VPCMPUD, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9352, 240},
+    {I_VPCMPUD, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9361, 240},
+    {I_VPCMPUD, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9370, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPUQ[] = {
+    {I_VPCMPUQ, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9379, 240},
+    {I_VPCMPUQ, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9388, 240},
+    {I_VPCMPUQ, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9397, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPUW[] = {
+    {I_VPCMPUW, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9406, 244},
+    {I_VPCMPUW, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9415, 244},
+    {I_VPCMPUW, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9424, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCMPW[] = {
+    {I_VPCMPW, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9433, 244},
+    {I_VPCMPW, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9442, 244},
+    {I_VPCMPW, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9451, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMPRESSD[] = {
+    {I_VPCOMPRESSD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22272, 240},
+    {I_VPCOMPRESSD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22280, 240},
+    {I_VPCOMPRESSD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22288, 241},
+    {I_VPCOMPRESSD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22296, 240},
+    {I_VPCOMPRESSD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22304, 240},
+    {I_VPCOMPRESSD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22312, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMPRESSQ[] = {
+    {I_VPCOMPRESSQ, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22320, 240},
+    {I_VPCOMPRESSQ, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22328, 240},
+    {I_VPCOMPRESSQ, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22336, 241},
+    {I_VPCOMPRESSQ, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22344, 240},
+    {I_VPCOMPRESSQ, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22352, 240},
+    {I_VPCOMPRESSQ, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22360, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCONFLICTD[] = {
+    {I_VPCONFLICTD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22368, 248},
+    {I_VPCONFLICTD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22376, 248},
+    {I_VPCONFLICTD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22384, 249},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCONFLICTQ[] = {
+    {I_VPCONFLICTQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22392, 248},
+    {I_VPCONFLICTQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22400, 248},
+    {I_VPCONFLICTQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22408, 249},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMB[] = {
+    {I_VPERMB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22416, 250},
+    {I_VPERMB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22424, 250},
+    {I_VPERMB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22432, 250},
+    {I_VPERMB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22440, 250},
+    {I_VPERMB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22448, 251},
+    {I_VPERMB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22456, 251},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMI2B[] = {
+    {I_VPERMI2B, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22496, 250},
+    {I_VPERMI2B, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22504, 250},
+    {I_VPERMI2B, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22512, 251},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMI2D[] = {
+    {I_VPERMI2D, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22520, 240},
+    {I_VPERMI2D, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22528, 240},
+    {I_VPERMI2D, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22536, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMI2PD[] = {
+    {I_VPERMI2PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22544, 240},
+    {I_VPERMI2PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22552, 240},
+    {I_VPERMI2PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22560, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMI2PS[] = {
+    {I_VPERMI2PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22568, 240},
+    {I_VPERMI2PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22576, 240},
+    {I_VPERMI2PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22584, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMI2Q[] = {
+    {I_VPERMI2Q, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22592, 240},
+    {I_VPERMI2Q, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22600, 240},
+    {I_VPERMI2Q, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22608, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMI2W[] = {
+    {I_VPERMI2W, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22616, 244},
+    {I_VPERMI2W, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22624, 244},
+    {I_VPERMI2W, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22632, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMT2B[] = {
+    {I_VPERMT2B, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22832, 250},
+    {I_VPERMT2B, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22840, 250},
+    {I_VPERMT2B, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22848, 251},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMT2D[] = {
+    {I_VPERMT2D, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22856, 240},
+    {I_VPERMT2D, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22864, 240},
+    {I_VPERMT2D, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22872, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMT2PD[] = {
+    {I_VPERMT2PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22880, 240},
+    {I_VPERMT2PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22888, 240},
+    {I_VPERMT2PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22896, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMT2PS[] = {
+    {I_VPERMT2PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22904, 240},
+    {I_VPERMT2PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22912, 240},
+    {I_VPERMT2PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22920, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMT2Q[] = {
+    {I_VPERMT2Q, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22928, 240},
+    {I_VPERMT2Q, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22936, 240},
+    {I_VPERMT2Q, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22944, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMT2W[] = {
+    {I_VPERMT2W, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22952, 244},
+    {I_VPERMT2W, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22960, 244},
+    {I_VPERMT2W, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22968, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPERMW[] = {
+    {I_VPERMW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22976, 244},
+    {I_VPERMW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22984, 244},
+    {I_VPERMW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22992, 244},
+    {I_VPERMW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23000, 244},
+    {I_VPERMW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23008, 245},
+    {I_VPERMW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23016, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXPANDD[] = {
+    {I_VPEXPANDD, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23024, 240},
+    {I_VPEXPANDD, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23032, 240},
+    {I_VPEXPANDD, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23040, 241},
+    {I_VPEXPANDD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23024, 240},
+    {I_VPEXPANDD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23032, 240},
+    {I_VPEXPANDD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23040, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXPANDQ[] = {
+    {I_VPEXPANDQ, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23048, 240},
+    {I_VPEXPANDQ, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23056, 240},
+    {I_VPEXPANDQ, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23064, 241},
+    {I_VPEXPANDQ, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23048, 240},
+    {I_VPEXPANDQ, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23056, 240},
+    {I_VPEXPANDQ, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23064, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPLZCNTD[] = {
+    {I_VPLZCNTD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23072, 248},
+    {I_VPLZCNTD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23080, 248},
+    {I_VPLZCNTD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23088, 249},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPLZCNTQ[] = {
+    {I_VPLZCNTQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23096, 248},
+    {I_VPLZCNTQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23104, 248},
+    {I_VPLZCNTQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23112, 249},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXSQ[] = {
+    {I_VPMAXSQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23360, 240},
+    {I_VPMAXSQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23368, 240},
+    {I_VPMAXSQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23376, 240},
+    {I_VPMAXSQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23384, 240},
+    {I_VPMAXSQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23392, 241},
+    {I_VPMAXSQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23400, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMAXUQ[] = {
+    {I_VPMAXUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23552, 240},
+    {I_VPMAXUQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23560, 240},
+    {I_VPMAXUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23568, 240},
+    {I_VPMAXUQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23576, 240},
+    {I_VPMAXUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23584, 241},
+    {I_VPMAXUQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23592, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINSQ[] = {
+    {I_VPMINSQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23744, 240},
+    {I_VPMINSQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23752, 240},
+    {I_VPMINSQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23760, 240},
+    {I_VPMINSQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23768, 240},
+    {I_VPMINSQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23776, 241},
+    {I_VPMINSQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23784, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMINUQ[] = {
+    {I_VPMINUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23936, 240},
+    {I_VPMINUQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23944, 240},
+    {I_VPMINUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23952, 240},
+    {I_VPMINUQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23960, 240},
+    {I_VPMINUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23968, 241},
+    {I_VPMINUQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23976, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVB2M[] = {
+    {I_VPMOVB2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24032, 244},
+    {I_VPMOVB2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24040, 244},
+    {I_VPMOVB2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24048, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVD2M[] = {
+    {I_VPMOVD2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24056, 242},
+    {I_VPMOVD2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24064, 242},
+    {I_VPMOVD2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24072, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVDB[] = {
+    {I_VPMOVDB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24080, 240},
+    {I_VPMOVDB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24088, 240},
+    {I_VPMOVDB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24096, 241},
+    {I_VPMOVDB, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24104, 240},
+    {I_VPMOVDB, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24112, 240},
+    {I_VPMOVDB, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24120, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVDW[] = {
+    {I_VPMOVDW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24128, 240},
+    {I_VPMOVDW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24136, 240},
+    {I_VPMOVDW, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24144, 241},
+    {I_VPMOVDW, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24152, 240},
+    {I_VPMOVDW, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24160, 240},
+    {I_VPMOVDW, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24168, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVM2B[] = {
+    {I_VPMOVM2B, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24176, 244},
+    {I_VPMOVM2B, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24184, 244},
+    {I_VPMOVM2B, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24192, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVM2D[] = {
+    {I_VPMOVM2D, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24200, 242},
+    {I_VPMOVM2D, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24208, 242},
+    {I_VPMOVM2D, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24216, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVM2Q[] = {
+    {I_VPMOVM2Q, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24224, 242},
+    {I_VPMOVM2Q, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24232, 242},
+    {I_VPMOVM2Q, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24240, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVM2W[] = {
+    {I_VPMOVM2W, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24248, 244},
+    {I_VPMOVM2W, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24256, 244},
+    {I_VPMOVM2W, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24264, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVQ2M[] = {
+    {I_VPMOVQ2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24272, 242},
+    {I_VPMOVQ2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24280, 242},
+    {I_VPMOVQ2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24288, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVQB[] = {
+    {I_VPMOVQB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24296, 240},
+    {I_VPMOVQB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24304, 240},
+    {I_VPMOVQB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24312, 241},
+    {I_VPMOVQB, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24320, 240},
+    {I_VPMOVQB, 2, {MEMORY|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24328, 240},
+    {I_VPMOVQB, 2, {MEMORY|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24336, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVQD[] = {
+    {I_VPMOVQD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24344, 240},
+    {I_VPMOVQD, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24352, 240},
+    {I_VPMOVQD, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24360, 241},
+    {I_VPMOVQD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24368, 240},
+    {I_VPMOVQD, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24376, 240},
+    {I_VPMOVQD, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24384, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVQW[] = {
+    {I_VPMOVQW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24392, 240},
+    {I_VPMOVQW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24400, 240},
+    {I_VPMOVQW, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24408, 241},
+    {I_VPMOVQW, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24416, 240},
+    {I_VPMOVQW, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24424, 240},
+    {I_VPMOVQW, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24432, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSDB[] = {
+    {I_VPMOVSDB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24440, 240},
+    {I_VPMOVSDB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24448, 240},
+    {I_VPMOVSDB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24456, 241},
+    {I_VPMOVSDB, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24464, 240},
+    {I_VPMOVSDB, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24472, 240},
+    {I_VPMOVSDB, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24480, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSDW[] = {
+    {I_VPMOVSDW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24488, 240},
+    {I_VPMOVSDW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24496, 240},
+    {I_VPMOVSDW, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24504, 241},
+    {I_VPMOVSDW, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24512, 240},
+    {I_VPMOVSDW, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24520, 240},
+    {I_VPMOVSDW, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24528, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSQB[] = {
+    {I_VPMOVSQB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24536, 240},
+    {I_VPMOVSQB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24544, 240},
+    {I_VPMOVSQB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24552, 241},
+    {I_VPMOVSQB, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24560, 240},
+    {I_VPMOVSQB, 2, {MEMORY|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24568, 240},
+    {I_VPMOVSQB, 2, {MEMORY|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24576, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSQD[] = {
+    {I_VPMOVSQD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24584, 240},
+    {I_VPMOVSQD, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24592, 240},
+    {I_VPMOVSQD, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24600, 241},
+    {I_VPMOVSQD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24608, 240},
+    {I_VPMOVSQD, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24616, 240},
+    {I_VPMOVSQD, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24624, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSQW[] = {
+    {I_VPMOVSQW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24632, 240},
+    {I_VPMOVSQW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24640, 240},
+    {I_VPMOVSQW, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24648, 241},
+    {I_VPMOVSQW, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24656, 240},
+    {I_VPMOVSQW, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24664, 240},
+    {I_VPMOVSQW, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24672, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVSWB[] = {
+    {I_VPMOVSWB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24680, 244},
+    {I_VPMOVSWB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24688, 244},
+    {I_VPMOVSWB, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24696, 245},
+    {I_VPMOVSWB, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24704, 244},
+    {I_VPMOVSWB, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24712, 244},
+    {I_VPMOVSWB, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24720, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVUSDB[] = {
+    {I_VPMOVUSDB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24872, 240},
+    {I_VPMOVUSDB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24880, 240},
+    {I_VPMOVUSDB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24888, 241},
+    {I_VPMOVUSDB, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24896, 240},
+    {I_VPMOVUSDB, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24904, 240},
+    {I_VPMOVUSDB, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24912, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVUSDW[] = {
+    {I_VPMOVUSDW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24920, 240},
+    {I_VPMOVUSDW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24928, 240},
+    {I_VPMOVUSDW, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24936, 241},
+    {I_VPMOVUSDW, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24944, 240},
+    {I_VPMOVUSDW, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24952, 240},
+    {I_VPMOVUSDW, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24960, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVUSQB[] = {
+    {I_VPMOVUSQB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24968, 240},
+    {I_VPMOVUSQB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24976, 240},
+    {I_VPMOVUSQB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24984, 241},
+    {I_VPMOVUSQB, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24992, 240},
+    {I_VPMOVUSQB, 2, {MEMORY|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25000, 240},
+    {I_VPMOVUSQB, 2, {MEMORY|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25008, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVUSQD[] = {
+    {I_VPMOVUSQD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25016, 240},
+    {I_VPMOVUSQD, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25024, 240},
+    {I_VPMOVUSQD, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25032, 241},
+    {I_VPMOVUSQD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25040, 240},
+    {I_VPMOVUSQD, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25048, 240},
+    {I_VPMOVUSQD, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25056, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVUSQW[] = {
+    {I_VPMOVUSQW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25064, 240},
+    {I_VPMOVUSQW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25072, 240},
+    {I_VPMOVUSQW, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25080, 241},
+    {I_VPMOVUSQW, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25088, 240},
+    {I_VPMOVUSQW, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25096, 240},
+    {I_VPMOVUSQW, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25104, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVUSWB[] = {
+    {I_VPMOVUSWB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25112, 244},
+    {I_VPMOVUSWB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25120, 244},
+    {I_VPMOVUSWB, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25128, 245},
+    {I_VPMOVUSWB, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25136, 244},
+    {I_VPMOVUSWB, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25144, 244},
+    {I_VPMOVUSWB, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25152, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVW2M[] = {
+    {I_VPMOVW2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+25160, 244},
+    {I_VPMOVW2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+25168, 244},
+    {I_VPMOVW2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+25176, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMOVWB[] = {
+    {I_VPMOVWB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25184, 244},
+    {I_VPMOVWB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25192, 244},
+    {I_VPMOVWB, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25200, 245},
+    {I_VPMOVWB, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25208, 244},
+    {I_VPMOVWB, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25216, 244},
+    {I_VPMOVWB, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25224, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULLQ[] = {
+    {I_VPMULLQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25616, 242},
+    {I_VPMULLQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25624, 242},
+    {I_VPMULLQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25632, 242},
+    {I_VPMULLQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25640, 242},
+    {I_VPMULLQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25648, 243},
+    {I_VPMULLQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25656, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMULTISHIFTQB[] = {
+    {I_VPMULTISHIFTQB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25712, 250},
+    {I_VPMULTISHIFTQB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25720, 250},
+    {I_VPMULTISHIFTQB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25728, 250},
+    {I_VPMULTISHIFTQB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25736, 250},
+    {I_VPMULTISHIFTQB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25744, 251},
+    {I_VPMULTISHIFTQB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25752, 251},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPORD[] = {
+    {I_VPORD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25808, 240},
+    {I_VPORD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25816, 240},
+    {I_VPORD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25824, 240},
+    {I_VPORD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25832, 240},
+    {I_VPORD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25840, 241},
+    {I_VPORD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25848, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPORQ[] = {
+    {I_VPORQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25856, 240},
+    {I_VPORQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25864, 240},
+    {I_VPORQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25872, 240},
+    {I_VPORQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25880, 240},
+    {I_VPORQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25888, 241},
+    {I_VPORQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25896, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROLD[] = {
+    {I_VPROLD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9775, 240},
+    {I_VPROLD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9784, 240},
+    {I_VPROLD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9793, 240},
+    {I_VPROLD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9802, 240},
+    {I_VPROLD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9811, 241},
+    {I_VPROLD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9820, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROLQ[] = {
+    {I_VPROLQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9829, 240},
+    {I_VPROLQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9838, 240},
+    {I_VPROLQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9847, 240},
+    {I_VPROLQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9856, 240},
+    {I_VPROLQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9865, 241},
+    {I_VPROLQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9874, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROLVD[] = {
+    {I_VPROLVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25904, 240},
+    {I_VPROLVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25912, 240},
+    {I_VPROLVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25920, 240},
+    {I_VPROLVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25928, 240},
+    {I_VPROLVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25936, 241},
+    {I_VPROLVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25944, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPROLVQ[] = {
+    {I_VPROLVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25952, 240},
+    {I_VPROLVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25960, 240},
+    {I_VPROLVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25968, 240},
+    {I_VPROLVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25976, 240},
+    {I_VPROLVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25984, 241},
+    {I_VPROLVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25992, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPRORD[] = {
+    {I_VPRORD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9883, 240},
+    {I_VPRORD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9892, 240},
+    {I_VPRORD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9901, 240},
+    {I_VPRORD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9910, 240},
+    {I_VPRORD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9919, 241},
+    {I_VPRORD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9928, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPRORQ[] = {
+    {I_VPRORQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9937, 240},
+    {I_VPRORQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9946, 240},
+    {I_VPRORQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9955, 240},
+    {I_VPRORQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9964, 240},
+    {I_VPRORQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9973, 241},
+    {I_VPRORQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9982, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPRORVD[] = {
+    {I_VPRORVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26000, 240},
+    {I_VPRORVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26008, 240},
+    {I_VPRORVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26016, 240},
+    {I_VPRORVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26024, 240},
+    {I_VPRORVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26032, 241},
+    {I_VPRORVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26040, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPRORVQ[] = {
+    {I_VPRORVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26048, 240},
+    {I_VPRORVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26056, 240},
+    {I_VPRORVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26064, 240},
+    {I_VPRORVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26072, 240},
+    {I_VPRORVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26080, 241},
+    {I_VPRORVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26088, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSCATTERDD[] = {
+    {I_VPSCATTERDD, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9991, 240},
+    {I_VPSCATTERDD, 2, {YMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10000, 240},
+    {I_VPSCATTERDD, 2, {ZMEM|BITS32,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10009, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSCATTERDQ[] = {
+    {I_VPSCATTERDQ, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10018, 240},
+    {I_VPSCATTERDQ, 2, {XMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10027, 240},
+    {I_VPSCATTERDQ, 2, {YMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10036, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSCATTERQD[] = {
+    {I_VPSCATTERQD, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10045, 240},
+    {I_VPSCATTERQD, 2, {YMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10054, 240},
+    {I_VPSCATTERQD, 2, {ZMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10063, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSCATTERQQ[] = {
+    {I_VPSCATTERQQ, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10072, 240},
+    {I_VPSCATTERQQ, 2, {YMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10081, 240},
+    {I_VPSCATTERQQ, 2, {ZMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10090, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSLLVW[] = {
+    {I_VPSLLVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26384, 244},
+    {I_VPSLLVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26392, 244},
+    {I_VPSLLVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26400, 244},
+    {I_VPSLLVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26408, 244},
+    {I_VPSLLVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26416, 245},
+    {I_VPSLLVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26424, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRAQ[] = {
+    {I_VPSRAQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26528, 240},
+    {I_VPSRAQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26536, 240},
+    {I_VPSRAQ, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26544, 240},
+    {I_VPSRAQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26552, 240},
+    {I_VPSRAQ, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26560, 241},
+    {I_VPSRAQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26568, 241},
+    {I_VPSRAQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10450, 240},
+    {I_VPSRAQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10459, 240},
+    {I_VPSRAQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10468, 240},
+    {I_VPSRAQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10477, 240},
+    {I_VPSRAQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10486, 241},
+    {I_VPSRAQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10495, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRAVQ[] = {
+    {I_VPSRAVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26624, 240},
+    {I_VPSRAVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26632, 240},
+    {I_VPSRAVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26640, 240},
+    {I_VPSRAVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26648, 240},
+    {I_VPSRAVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26656, 241},
+    {I_VPSRAVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26664, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRAVW[] = {
+    {I_VPSRAVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26672, 244},
+    {I_VPSRAVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26680, 244},
+    {I_VPSRAVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26688, 244},
+    {I_VPSRAVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26696, 244},
+    {I_VPSRAVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26704, 245},
+    {I_VPSRAVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26712, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSRLVW[] = {
+    {I_VPSRLVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26960, 244},
+    {I_VPSRLVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26968, 244},
+    {I_VPSRLVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26976, 244},
+    {I_VPSRLVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26984, 244},
+    {I_VPSRLVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26992, 245},
+    {I_VPSRLVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27000, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTERNLOGD[] = {
+    {I_VPTERNLOGD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10774, 240},
+    {I_VPTERNLOGD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10783, 240},
+    {I_VPTERNLOGD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10792, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTERNLOGQ[] = {
+    {I_VPTERNLOGQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10801, 240},
+    {I_VPTERNLOGQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10810, 240},
+    {I_VPTERNLOGQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10819, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTMB[] = {
+    {I_VPTESTMB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27440, 244},
+    {I_VPTESTMB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27448, 244},
+    {I_VPTESTMB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27456, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTMD[] = {
+    {I_VPTESTMD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27464, 240},
+    {I_VPTESTMD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27472, 240},
+    {I_VPTESTMD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27480, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTMQ[] = {
+    {I_VPTESTMQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27488, 240},
+    {I_VPTESTMQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27496, 240},
+    {I_VPTESTMQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27504, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTMW[] = {
+    {I_VPTESTMW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27512, 244},
+    {I_VPTESTMW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27520, 244},
+    {I_VPTESTMW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27528, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTNMB[] = {
+    {I_VPTESTNMB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27536, 244},
+    {I_VPTESTNMB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27544, 244},
+    {I_VPTESTNMB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27552, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTNMD[] = {
+    {I_VPTESTNMD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27560, 240},
+    {I_VPTESTNMD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27568, 240},
+    {I_VPTESTNMD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27576, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTNMQ[] = {
+    {I_VPTESTNMQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27584, 240},
+    {I_VPTESTNMQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27592, 240},
+    {I_VPTESTNMQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27600, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPTESTNMW[] = {
+    {I_VPTESTNMW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27608, 244},
+    {I_VPTESTNMW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27616, 244},
+    {I_VPTESTNMW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27624, 245},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPXORD[] = {
+    {I_VPXORD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28016, 240},
+    {I_VPXORD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28024, 240},
+    {I_VPXORD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28032, 240},
+    {I_VPXORD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28040, 240},
+    {I_VPXORD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28048, 241},
+    {I_VPXORD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28056, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPXORQ[] = {
+    {I_VPXORQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28064, 240},
+    {I_VPXORQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28072, 240},
+    {I_VPXORQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28080, 240},
+    {I_VPXORQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28088, 240},
+    {I_VPXORQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28096, 241},
+    {I_VPXORQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28104, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRANGEPD[] = {
+    {I_VRANGEPD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10828, 242},
+    {I_VRANGEPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10837, 242},
+    {I_VRANGEPD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10846, 242},
+    {I_VRANGEPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10855, 242},
+    {I_VRANGEPD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+10864, 243},
+    {I_VRANGEPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+10873, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRANGEPS[] = {
+    {I_VRANGEPS, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10882, 242},
+    {I_VRANGEPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10891, 242},
+    {I_VRANGEPS, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10900, 242},
+    {I_VRANGEPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10909, 242},
+    {I_VRANGEPS, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+10918, 243},
+    {I_VRANGEPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+10927, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRANGESD[] = {
+    {I_VRANGESD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+10936, 243},
+    {I_VRANGESD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+10945, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRANGESS[] = {
+    {I_VRANGESS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+10954, 243},
+    {I_VRANGESS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+10963, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP14PD[] = {
+    {I_VRCP14PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28112, 240},
+    {I_VRCP14PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28120, 240},
+    {I_VRCP14PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28128, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP14PS[] = {
+    {I_VRCP14PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28136, 240},
+    {I_VRCP14PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28144, 240},
+    {I_VRCP14PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28152, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP14SD[] = {
+    {I_VRCP14SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28160, 241},
+    {I_VRCP14SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28168, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP14SS[] = {
+    {I_VRCP14SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28176, 241},
+    {I_VRCP14SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28184, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP28PD[] = {
+    {I_VRCP28PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+28192, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP28PS[] = {
+    {I_VRCP28PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+28200, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP28SD[] = {
+    {I_VRCP28SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28208, 246},
+    {I_VRCP28SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28216, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCP28SS[] = {
+    {I_VRCP28SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28224, 246},
+    {I_VRCP28SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28232, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VREDUCEPD[] = {
+    {I_VREDUCEPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10972, 242},
+    {I_VREDUCEPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10981, 242},
+    {I_VREDUCEPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+10990, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VREDUCEPS[] = {
+    {I_VREDUCEPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10999, 242},
+    {I_VREDUCEPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11008, 242},
+    {I_VREDUCEPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+11017, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VREDUCESD[] = {
+    {I_VREDUCESD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11026, 243},
+    {I_VREDUCESD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11035, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VREDUCESS[] = {
+    {I_VREDUCESS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11044, 243},
+    {I_VREDUCESS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11053, 243},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRNDSCALEPD[] = {
+    {I_VRNDSCALEPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11062, 240},
+    {I_VRNDSCALEPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11071, 240},
+    {I_VRNDSCALEPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+11080, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRNDSCALEPS[] = {
+    {I_VRNDSCALEPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11089, 240},
+    {I_VRNDSCALEPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11098, 240},
+    {I_VRNDSCALEPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+11107, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRNDSCALESD[] = {
+    {I_VRNDSCALESD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11116, 241},
+    {I_VRNDSCALESD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11125, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRNDSCALESS[] = {
+    {I_VRNDSCALESS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11134, 241},
+    {I_VRNDSCALESS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11143, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT14PD[] = {
+    {I_VRSQRT14PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28240, 240},
+    {I_VRSQRT14PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28248, 240},
+    {I_VRSQRT14PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28256, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT14PS[] = {
+    {I_VRSQRT14PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28264, 240},
+    {I_VRSQRT14PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28272, 240},
+    {I_VRSQRT14PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28280, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT14SD[] = {
+    {I_VRSQRT14SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28288, 241},
+    {I_VRSQRT14SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28296, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT14SS[] = {
+    {I_VRSQRT14SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28304, 241},
+    {I_VRSQRT14SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28312, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT28PD[] = {
+    {I_VRSQRT28PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+28320, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT28PS[] = {
+    {I_VRSQRT28PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+28328, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT28SD[] = {
+    {I_VRSQRT28SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28336, 246},
+    {I_VRSQRT28SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28344, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRT28SS[] = {
+    {I_VRSQRT28SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28352, 246},
+    {I_VRSQRT28SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28360, 246},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCALEFPD[] = {
+    {I_VSCALEFPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28368, 240},
+    {I_VSCALEFPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28376, 240},
+    {I_VSCALEFPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28384, 240},
+    {I_VSCALEFPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28392, 240},
+    {I_VSCALEFPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+28400, 241},
+    {I_VSCALEFPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+28408, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCALEFPS[] = {
+    {I_VSCALEFPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28416, 240},
+    {I_VSCALEFPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28424, 240},
+    {I_VSCALEFPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28432, 240},
+    {I_VSCALEFPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28440, 240},
+    {I_VSCALEFPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+28448, 241},
+    {I_VSCALEFPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+28456, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCALEFSD[] = {
+    {I_VSCALEFSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28464, 241},
+    {I_VSCALEFSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28472, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCALEFSS[] = {
+    {I_VSCALEFSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28480, 241},
+    {I_VSCALEFSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28488, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERDPD[] = {
+    {I_VSCATTERDPD, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11152, 240},
+    {I_VSCATTERDPD, 2, {XMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11161, 240},
+    {I_VSCATTERDPD, 2, {YMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11170, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERDPS[] = {
+    {I_VSCATTERDPS, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11179, 240},
+    {I_VSCATTERDPS, 2, {YMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11188, 240},
+    {I_VSCATTERDPS, 2, {ZMEM|BITS32,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11197, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF0DPD[] = {
+    {I_VSCATTERPF0DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11206, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF0DPS[] = {
+    {I_VSCATTERPF0DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11215, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF0QPD[] = {
+    {I_VSCATTERPF0QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11224, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF0QPS[] = {
+    {I_VSCATTERPF0QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11233, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF1DPD[] = {
+    {I_VSCATTERPF1DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11242, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF1DPS[] = {
+    {I_VSCATTERPF1DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11251, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF1QPD[] = {
+    {I_VSCATTERPF1QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11260, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERPF1QPS[] = {
+    {I_VSCATTERPF1QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11269, 247},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERQPD[] = {
+    {I_VSCATTERQPD, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11278, 240},
+    {I_VSCATTERQPD, 2, {YMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11287, 240},
+    {I_VSCATTERQPD, 2, {ZMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11296, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCATTERQPS[] = {
+    {I_VSCATTERQPS, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11305, 240},
+    {I_VSCATTERQPS, 2, {YMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11314, 240},
+    {I_VSCATTERQPS, 2, {ZMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11323, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSHUFF32X4[] = {
+    {I_VSHUFF32X4, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11332, 240},
+    {I_VSHUFF32X4, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11341, 240},
+    {I_VSHUFF32X4, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11350, 241},
+    {I_VSHUFF32X4, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11359, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSHUFF64X2[] = {
+    {I_VSHUFF64X2, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11368, 240},
+    {I_VSHUFF64X2, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11377, 240},
+    {I_VSHUFF64X2, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11386, 241},
+    {I_VSHUFF64X2, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11395, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSHUFI32X4[] = {
+    {I_VSHUFI32X4, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11404, 240},
+    {I_VSHUFI32X4, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11413, 240},
+    {I_VSHUFI32X4, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11422, 241},
+    {I_VSHUFI32X4, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11431, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSHUFI64X2[] = {
+    {I_VSHUFI64X2, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11440, 240},
+    {I_VSHUFI64X2, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11449, 240},
+    {I_VSHUFI64X2, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11458, 241},
+    {I_VSHUFI64X2, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11467, 241},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDPKRU[] = {
+    {I_RDPKRU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46072, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRPKRU[] = {
+    {I_WRPKRU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46078, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDPID[] = {
+    {I_RDPID, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42322, 254},
+    {I_RDPID, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42321, 136},
+    {I_RDPID, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42322, 255},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLFLUSHOPT[] = {
+    {I_CLFLUSHOPT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45951, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLWB[] = {
+    {I_CLWB, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45957, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCOMMIT[] = {
+    {I_PCOMMIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45963, 256},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLZERO[] = {
+    {I_CLZERO, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45982, 257},
+    {I_CLZERO, 1, {REG_AX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45969, 258},
+    {I_CLZERO, 1, {REG_EAX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45975, 257},
+    {I_CLZERO, 1, {REG_RAX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45981, 259},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PTWRITE[] = {
+    {I_PTWRITE, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34020, 135},
+    {I_PTWRITE, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34019, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLDEMOTE[] = {
+    {I_CLDEMOTE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45987, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVDIRI[] = {
+    {I_MOVDIRI, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42328, 260},
+    {I_MOVDIRI, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42335, 261},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_MOVDIR64B[] = {
+    {I_MOVDIR64B, 2, {REG_GPR|BITS16,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29008, 254},
+    {I_MOVDIR64B, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29016, 135},
+    {I_MOVDIR64B, 2, {REG_GPR|BITS64,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+11584, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_PCONFIG[] = {
+    {I_PCONFIG, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45993, 135},
+    {I_PCONFIG, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45993, 285},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TPAUSE[] = {
+    {I_TPAUSE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45957, 135},
+    {I_TPAUSE, 3, {REG_GPR|BITS32,REG_EDX,REG_EAX,0,0}, NO_DECORATOR, nasm_bytecodes+45957, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UMONITOR[] = {
+    {I_UMONITOR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42342, 254},
+    {I_UMONITOR, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42349, 135},
+    {I_UMONITOR, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+29024, 136},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UMWAIT[] = {
+    {I_UMWAIT, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45999, 135},
+    {I_UMWAIT, 3, {REG_GPR|BITS32,REG_EDX,REG_EAX,0,0}, NO_DECORATOR, nasm_bytecodes+45999, 135},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WBNOINVD[] = {
+    {I_WBNOINVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49182, 135},
+    {I_WBNOINVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49182, 287},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_GF2P8AFFINEINVQB[] = {
+    {I_GF2P8AFFINEINVQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29032, 262},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGF2P8AFFINEINVQB[] = {
+    {I_VGF2P8AFFINEINVQB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29040, 263},
+    {I_VGF2P8AFFINEINVQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29048, 263},
+    {I_VGF2P8AFFINEINVQB, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29056, 263},
+    {I_VGF2P8AFFINEINVQB, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29064, 263},
+    {I_VGF2P8AFFINEINVQB, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11593, 264},
+    {I_VGF2P8AFFINEINVQB, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11602, 264},
+    {I_VGF2P8AFFINEINVQB, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11611, 264},
+    {I_VGF2P8AFFINEINVQB, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11620, 264},
+    {I_VGF2P8AFFINEINVQB, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11629, 265},
+    {I_VGF2P8AFFINEINVQB, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11638, 265},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_GF2P8AFFINEQB[] = {
+    {I_GF2P8AFFINEQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29072, 262},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGF2P8AFFINEQB[] = {
+    {I_VGF2P8AFFINEQB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29080, 263},
+    {I_VGF2P8AFFINEQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29088, 263},
+    {I_VGF2P8AFFINEQB, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29096, 263},
+    {I_VGF2P8AFFINEQB, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29104, 263},
+    {I_VGF2P8AFFINEQB, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11647, 264},
+    {I_VGF2P8AFFINEQB, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11656, 264},
+    {I_VGF2P8AFFINEQB, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11665, 264},
+    {I_VGF2P8AFFINEQB, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11674, 264},
+    {I_VGF2P8AFFINEQB, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11683, 265},
+    {I_VGF2P8AFFINEQB, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11692, 265},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_GF2P8MULB[] = {
+    {I_GF2P8MULB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+42356, 262},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGF2P8MULB[] = {
+    {I_VGF2P8MULB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+42363, 263},
+    {I_VGF2P8MULB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+42370, 263},
+    {I_VGF2P8MULB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+42377, 263},
+    {I_VGF2P8MULB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+42384, 263},
+    {I_VGF2P8MULB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29112, 264},
+    {I_VGF2P8MULB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29120, 264},
+    {I_VGF2P8MULB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29128, 264},
+    {I_VGF2P8MULB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29136, 264},
+    {I_VGF2P8MULB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29144, 265},
+    {I_VGF2P8MULB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29152, 265},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMPRESSB[] = {
+    {I_VPCOMPRESSB, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29160, 266},
+    {I_VPCOMPRESSB, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29168, 266},
+    {I_VPCOMPRESSB, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29176, 267},
+    {I_VPCOMPRESSB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29184, 266},
+    {I_VPCOMPRESSB, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29192, 266},
+    {I_VPCOMPRESSB, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29200, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPCOMPRESSW[] = {
+    {I_VPCOMPRESSW, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29208, 266},
+    {I_VPCOMPRESSW, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29216, 266},
+    {I_VPCOMPRESSW, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29224, 267},
+    {I_VPCOMPRESSW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29232, 266},
+    {I_VPCOMPRESSW, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29240, 266},
+    {I_VPCOMPRESSW, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29248, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXPANDB[] = {
+    {I_VPEXPANDB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29256, 266},
+    {I_VPEXPANDB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29264, 266},
+    {I_VPEXPANDB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29272, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPEXPANDW[] = {
+    {I_VPEXPANDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29280, 266},
+    {I_VPEXPANDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29288, 266},
+    {I_VPEXPANDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29296, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLDW[] = {
+    {I_VPSHLDW, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11701, 266},
+    {I_VPSHLDW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11710, 266},
+    {I_VPSHLDW, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11719, 266},
+    {I_VPSHLDW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11728, 266},
+    {I_VPSHLDW, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11737, 267},
+    {I_VPSHLDW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11746, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLDD[] = {
+    {I_VPSHLDD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11755, 266},
+    {I_VPSHLDD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11764, 266},
+    {I_VPSHLDD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11773, 266},
+    {I_VPSHLDD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11782, 266},
+    {I_VPSHLDD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11791, 267},
+    {I_VPSHLDD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11800, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLDQ[] = {
+    {I_VPSHLDQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11809, 266},
+    {I_VPSHLDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11818, 266},
+    {I_VPSHLDQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11827, 266},
+    {I_VPSHLDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11836, 266},
+    {I_VPSHLDQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11845, 267},
+    {I_VPSHLDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11854, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLDVW[] = {
+    {I_VPSHLDVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29304, 266},
+    {I_VPSHLDVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29312, 266},
+    {I_VPSHLDVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29320, 266},
+    {I_VPSHLDVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29328, 266},
+    {I_VPSHLDVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29336, 267},
+    {I_VPSHLDVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29344, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLDVD[] = {
+    {I_VPSHLDVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29352, 266},
+    {I_VPSHLDVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29360, 266},
+    {I_VPSHLDVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29368, 266},
+    {I_VPSHLDVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29376, 266},
+    {I_VPSHLDVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29384, 267},
+    {I_VPSHLDVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29392, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHLDVQ[] = {
+    {I_VPSHLDVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29400, 266},
+    {I_VPSHLDVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29408, 266},
+    {I_VPSHLDVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29416, 266},
+    {I_VPSHLDVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29424, 266},
+    {I_VPSHLDVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29432, 267},
+    {I_VPSHLDVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29440, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHRDW[] = {
+    {I_VPSHRDW, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11863, 266},
+    {I_VPSHRDW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11872, 266},
+    {I_VPSHRDW, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11881, 266},
+    {I_VPSHRDW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11890, 266},
+    {I_VPSHRDW, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11899, 267},
+    {I_VPSHRDW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11908, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHRDD[] = {
+    {I_VPSHRDD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11917, 266},
+    {I_VPSHRDD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11926, 266},
+    {I_VPSHRDD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11935, 266},
+    {I_VPSHRDD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11944, 266},
+    {I_VPSHRDD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11953, 267},
+    {I_VPSHRDD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11962, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHRDQ[] = {
+    {I_VPSHRDQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11971, 266},
+    {I_VPSHRDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11980, 266},
+    {I_VPSHRDQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11989, 266},
+    {I_VPSHRDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11998, 266},
+    {I_VPSHRDQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+12007, 267},
+    {I_VPSHRDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+12016, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHRDVW[] = {
+    {I_VPSHRDVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29448, 266},
+    {I_VPSHRDVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29456, 266},
+    {I_VPSHRDVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29464, 266},
+    {I_VPSHRDVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29472, 266},
+    {I_VPSHRDVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29480, 267},
+    {I_VPSHRDVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29488, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHRDVD[] = {
+    {I_VPSHRDVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29496, 266},
+    {I_VPSHRDVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29504, 266},
+    {I_VPSHRDVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29512, 266},
+    {I_VPSHRDVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29520, 266},
+    {I_VPSHRDVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29528, 267},
+    {I_VPSHRDVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29536, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHRDVQ[] = {
+    {I_VPSHRDVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29544, 266},
+    {I_VPSHRDVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29552, 266},
+    {I_VPSHRDVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29560, 266},
+    {I_VPSHRDVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29568, 266},
+    {I_VPSHRDVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29576, 267},
+    {I_VPSHRDVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29584, 267},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBUSD[] = {
+    {I_VPDPBUSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29592, 268},
+    {I_VPDPBUSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29600, 268},
+    {I_VPDPBUSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29608, 268},
+    {I_VPDPBUSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29616, 268},
+    {I_VPDPBUSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29624, 269},
+    {I_VPDPBUSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29632, 269},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPBUSDS[] = {
+    {I_VPDPBUSDS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29640, 268},
+    {I_VPDPBUSDS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29648, 268},
+    {I_VPDPBUSDS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29656, 268},
+    {I_VPDPBUSDS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29664, 268},
+    {I_VPDPBUSDS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29672, 269},
+    {I_VPDPBUSDS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29680, 269},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPWSSD[] = {
+    {I_VPDPWSSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29688, 268},
+    {I_VPDPWSSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29696, 268},
+    {I_VPDPWSSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29704, 268},
+    {I_VPDPWSSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29712, 268},
+    {I_VPDPWSSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29720, 269},
+    {I_VPDPWSSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29728, 269},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPDPWSSDS[] = {
+    {I_VPDPWSSDS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29736, 268},
+    {I_VPDPWSSDS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29744, 268},
+    {I_VPDPWSSDS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29752, 268},
+    {I_VPDPWSSDS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29760, 268},
+    {I_VPDPWSSDS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29768, 269},
+    {I_VPDPWSSDS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29776, 269},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPOPCNTB[] = {
+    {I_VPOPCNTB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29784, 270},
+    {I_VPOPCNTB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29792, 270},
+    {I_VPOPCNTB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29800, 271},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPOPCNTW[] = {
+    {I_VPOPCNTW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29808, 270},
+    {I_VPOPCNTW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29816, 270},
+    {I_VPOPCNTW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29824, 271},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPOPCNTD[] = {
+    {I_VPOPCNTD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29832, 272},
+    {I_VPOPCNTD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29840, 272},
+    {I_VPOPCNTD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29848, 273},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPOPCNTQ[] = {
+    {I_VPOPCNTQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29856, 272},
+    {I_VPOPCNTQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29864, 272},
+    {I_VPOPCNTQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29872, 273},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPSHUFBITQMB[] = {
+    {I_VPSHUFBITQMB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29880, 270},
+    {I_VPSHUFBITQMB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29888, 270},
+    {I_VPSHUFBITQMB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29896, 271},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_V4FMADDPS[] = {
+    {I_V4FMADDPS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29904, 274},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_V4FNMADDPS[] = {
+    {I_V4FNMADDPS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29912, 274},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_V4FMADDSS[] = {
+    {I_V4FMADDSS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29920, 274},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_V4FNMADDSS[] = {
+    {I_V4FNMADDSS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29928, 274},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_V4DPWSSDS[] = {
+    {I_V4DPWSSDS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29936, 275},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_V4DPWSSD[] = {
+    {I_V4DPWSSD, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29944, 275},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENCLS[] = {
+    {I_ENCLS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46005, 276},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENCLU[] = {
+    {I_ENCLU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46011, 276},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENCLV[] = {
+    {I_ENCLV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46017, 276},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLRSSBSY[] = {
+    {I_CLRSSBSY, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42350, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENDBR32[] = {
+    {I_ENDBR32, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46023, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENDBR64[] = {
+    {I_ENDBR64, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46029, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INCSSPD[] = {
+    {I_INCSSPD, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42391, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_INCSSPQ[] = {
+    {I_INCSSPQ, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42398, 278},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDSSPD[] = {
+    {I_RDSSPD, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42405, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDSSPQ[] = {
+    {I_RDSSPQ, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42412, 278},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RSTORSSP[] = {
+    {I_RSTORSSP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46035, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SAVEPREVSSP[] = {
+    {I_SAVEPREVSSP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46041, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SETSSBSY[] = {
+    {I_SETSSBSY, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46047, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRUSSD[] = {
+    {I_WRUSSD, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+29952, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRUSSQ[] = {
+    {I_WRUSSQ, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+29960, 278},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRSSD[] = {
+    {I_WRSSD, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42419, 277},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRSSQ[] = {
+    {I_WRSSQ, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42426, 278},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENQCMD[] = {
+    {I_ENQCMD, 2, {REG_GPR|BITS16,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29968, 279},
+    {I_ENQCMD, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29968, 279},
+    {I_ENQCMD, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29976, 280},
+    {I_ENQCMD, 2, {REG_GPR|BITS64,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29984, 281},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_ENQCMDS[] = {
+    {I_ENQCMDS, 2, {REG_GPR|BITS16,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29992, 282},
+    {I_ENQCMDS, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29992, 282},
+    {I_ENQCMDS, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+30000, 283},
+    {I_ENQCMDS, 2, {REG_GPR|BITS64,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+30008, 284},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SERIALIZE[] = {
+    {I_SERIALIZE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46053, 286},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XRESLDTRK[] = {
+    {I_XRESLDTRK, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46059, 288},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_XSUSLDTRK[] = {
+    {I_XSUSLDTRK, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46065, 288},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTNE2PS2BF16[] = {
+    {I_VCVTNE2PS2BF16, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30016, 289},
+    {I_VCVTNE2PS2BF16, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30024, 289},
+    {I_VCVTNE2PS2BF16, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30032, 289},
+    {I_VCVTNE2PS2BF16, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30040, 289},
+    {I_VCVTNE2PS2BF16, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30048, 289},
+    {I_VCVTNE2PS2BF16, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30056, 289},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDPBF16PS[] = {
+    {I_VDPBF16PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30112, 289},
+    {I_VDPBF16PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30120, 289},
+    {I_VDPBF16PS, 3, {YMMREG,YMMREG,RM_YMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30128, 289},
+    {I_VDPBF16PS, 2, {YMMREG,RM_YMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30136, 289},
+    {I_VDPBF16PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30144, 289},
+    {I_VDPBF16PS, 2, {ZMMREG,RM_ZMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30152, 289},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VP2INTERSECTD[] = {
+    {I_VP2INTERSECTD, 3, {KREG|RS2,XMMREG,RM_XMM|BITS128,0,0}, {0,0,B32,0,0}, nasm_bytecodes+30160, 289},
+    {I_VP2INTERSECTD, 3, {KREG|RS2,YMMREG,RM_YMM|BITS128,0,0}, {0,0,B32,0,0}, nasm_bytecodes+30168, 289},
+    {I_VP2INTERSECTD, 3, {KREG|RS2,ZMMREG,RM_ZMM|BITS128,0,0}, {0,0,B32,0,0}, nasm_bytecodes+30176, 289},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_LDTILECFG[] = {
+    {I_LDTILECFG, 1, {MEMORY|BITS512,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42433, 290},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STTILECFG[] = {
+    {I_STTILECFG, 1, {MEMORY|BITS512,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42440, 290},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TDPBF16PS[] = {
+    {I_TDPBF16PS, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42447, 291},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TDPBSSD[] = {
+    {I_TDPBSSD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42454, 292},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TDPBSUD[] = {
+    {I_TDPBSUD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42461, 292},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TDPBUSD[] = {
+    {I_TDPBUSD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42468, 292},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TDPBUUD[] = {
+    {I_TDPBUUD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42475, 292},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TILELOADD[] = {
+    {I_TILELOADD, 2, {TMMREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42482, 293},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TILELOADDT1[] = {
+    {I_TILELOADDT1, 2, {TMMREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42489, 293},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TILERELEASE[] = {
+    {I_TILERELEASE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42496, 294},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TILESTORED[] = {
+    {I_TILESTORED, 2, {MEMORY,TMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42503, 293},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TILEZERO[] = {
+    {I_TILEZERO, 1, {TMMREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+30184, 294},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDPH[] = {
+    {I_VADDPH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30192, 295},
+    {I_VADDPH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30200, 295},
+    {I_VADDPH, 3, {YMMREG,YMMREG,RM_YMM|BITS16,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30208, 295},
+    {I_VADDPH, 2, {YMMREG,RM_YMM|BITS16,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30216, 295},
+    {I_VADDPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS16,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+30224, 296},
+    {I_VADDPH, 2, {ZMMREG,RM_ZMM|BITS16,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30232, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VADDSH[] = {
+    {I_VADDSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+30240, 296},
+    {I_VADDSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+30248, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPPH[] = {
+    {I_VCMPPH, 4, {KREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,B16,0,0}, nasm_bytecodes+12025, 295},
+    {I_VCMPPH, 3, {KREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12034, 295},
+    {I_VCMPPH, 4, {KREG,YMMREG,RM_YMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,B16,0,0}, nasm_bytecodes+12043, 295},
+    {I_VCMPPH, 3, {KREG,RM_YMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12052, 295},
+    {I_VCMPPH, 4, {KREG,ZMMREG,RM_ZMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,B16|SAE,0,0}, nasm_bytecodes+12061, 296},
+    {I_VCMPPH, 3, {KREG,RM_ZMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,B16|SAE,0,0,0}, nasm_bytecodes+12070, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCMPSH[] = {
+    {I_VCMPSH, 4, {KREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+12079, 296},
+    {I_VCMPSH, 3, {KREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,SAE,0,0,0}, nasm_bytecodes+12088, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCOMISH[] = {
+    {I_VCOMISH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30256, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTDQ2PH[] = {
+    {I_VCVTDQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30264, 295},
+    {I_VCVTDQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30272, 295},
+    {I_VCVTDQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+30280, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPD2PH[] = {
+    {I_VCVTPD2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30288, 295},
+    {I_VCVTPD2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30296, 295},
+    {I_VCVTPD2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+30304, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2DQ[] = {
+    {I_VCVTPH2DQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30312, 295},
+    {I_VCVTPH2DQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30320, 295},
+    {I_VCVTPH2DQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30328, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2PD[] = {
+    {I_VCVTPH2PD, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30336, 295},
+    {I_VCVTPH2PD, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30344, 295},
+    {I_VCVTPH2PD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30352, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2PSX[] = {
+    {I_VCVTPH2PSX, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30360, 295},
+    {I_VCVTPH2PSX, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30368, 295},
+    {I_VCVTPH2PSX, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30376, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2QQ[] = {
+    {I_VCVTPH2QQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30384, 295},
+    {I_VCVTPH2QQ, 2, {YMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30392, 295},
+    {I_VCVTPH2QQ, 2, {ZMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30400, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2UDQ[] = {
+    {I_VCVTPH2UDQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30408, 295},
+    {I_VCVTPH2UDQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30416, 295},
+    {I_VCVTPH2UDQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30424, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2UQQ[] = {
+    {I_VCVTPH2UQQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30432, 295},
+    {I_VCVTPH2UQQ, 2, {YMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30440, 295},
+    {I_VCVTPH2UQQ, 2, {ZMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30448, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2UW[] = {
+    {I_VCVTPH2UW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30456, 295},
+    {I_VCVTPH2UW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30464, 295},
+    {I_VCVTPH2UW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30472, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTPH2W[] = {
+    {I_VCVTPH2W, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30480, 295},
+    {I_VCVTPH2W, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30488, 295},
+    {I_VCVTPH2W, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30496, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTQQ2PH[] = {
+    {I_VCVTQQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30528, 295},
+    {I_VCVTQQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30536, 295},
+    {I_VCVTQQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+30544, 295},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSD2SH[] = {
+    {I_VCVTSD2SH, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+30552, 296},
+    {I_VCVTSD2SH, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+30560, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSH2SD[] = {
+    {I_VCVTSH2SD, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {0,0,SAE,0,0}, nasm_bytecodes+30568, 296},
+    {I_VCVTSH2SD, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30576, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSH2SI[] = {
+    {I_VCVTSH2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30584, 296},
+    {I_VCVTSH2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30592, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSH2SS[] = {
+    {I_VCVTSH2SS, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+30600, 296},
+    {I_VCVTSH2SS, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+30608, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSH2USI[] = {
+    {I_VCVTSH2USI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30616, 296},
+    {I_VCVTSH2USI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30624, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSI2SH[] = {
+    {I_VCVTSI2SH, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,0,ER,0,0}, nasm_bytecodes+30632, 296},
+    {I_VCVTSI2SH, 2, {XMMREG,RM_GPR|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30640, 296},
+    {I_VCVTSI2SH, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,0,ER,0,0}, nasm_bytecodes+30648, 296},
+    {I_VCVTSI2SH, 2, {XMMREG,RM_GPR|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30656, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTSS2SH[] = {
+    {I_VCVTSS2SH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {0,0,ER,0,0}, nasm_bytecodes+30664, 296},
+    {I_VCVTSS2SH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30672, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPH2DQ[] = {
+    {I_VCVTTPH2DQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30680, 295},
+    {I_VCVTTPH2DQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30688, 295},
+    {I_VCVTTPH2DQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30696, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPH2QQ[] = {
+    {I_VCVTTPH2QQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30704, 295},
+    {I_VCVTTPH2QQ, 2, {YMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30712, 295},
+    {I_VCVTTPH2QQ, 2, {ZMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30720, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPH2UDQ[] = {
+    {I_VCVTTPH2UDQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30728, 295},
+    {I_VCVTTPH2UDQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30736, 295},
+    {I_VCVTTPH2UDQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30744, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPH2UQQ[] = {
+    {I_VCVTTPH2UQQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30752, 295},
+    {I_VCVTTPH2UQQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30760, 295},
+    {I_VCVTTPH2UQQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30768, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPH2UW[] = {
+    {I_VCVTTPH2UW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30776, 295},
+    {I_VCVTTPH2UW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30784, 295},
+    {I_VCVTTPH2UW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30792, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTPH2W[] = {
+    {I_VCVTTPH2W, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30800, 295},
+    {I_VCVTTPH2W, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30808, 295},
+    {I_VCVTTPH2W, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30816, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTSH2SI[] = {
+    {I_VCVTTSH2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30824, 296},
+    {I_VCVTTSH2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30832, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTTSH2USI[] = {
+    {I_VCVTTSH2USI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30840, 296},
+    {I_VCVTTSH2USI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30848, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUDQ2PH[] = {
+    {I_VCVTUDQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30856, 295},
+    {I_VCVTUDQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30864, 295},
+    {I_VCVTUDQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30872, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUQQ2PH[] = {
+    {I_VCVTUQQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30880, 295},
+    {I_VCVTUQQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30888, 295},
+    {I_VCVTUQQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30896, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUSI2SH[] = {
+    {I_VCVTUSI2SH, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,ER,0,0}, nasm_bytecodes+30904, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTUW2PH[] = {
+    {I_VCVTUW2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30920, 295},
+    {I_VCVTUW2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30928, 295},
+    {I_VCVTUW2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30936, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VCVTW2PH[] = {
+    {I_VCVTW2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30944, 295},
+    {I_VCVTW2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30952, 295},
+    {I_VCVTW2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30960, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDIVPH[] = {
+    {I_VDIVPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30968, 295},
+    {I_VDIVPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30976, 295},
+    {I_VDIVPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30984, 295},
+    {I_VDIVPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30992, 295},
+    {I_VDIVPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31000, 296},
+    {I_VDIVPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31008, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VDIVSH[] = {
+    {I_VDIVSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31016, 296},
+    {I_VDIVSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31024, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFCMADDCPH[] = {
+    {I_VFCMADDCPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31032, 295},
+    {I_VFCMADDCPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31040, 295},
+    {I_VFCMADDCPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31048, 295},
+    {I_VFCMADDCPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31056, 295},
+    {I_VFCMADDCPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31064, 295},
+    {I_VFCMADDCPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31072, 295},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDCPH[] = {
+    {I_VFMADDCPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31080, 295},
+    {I_VFMADDCPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31088, 295},
+    {I_VFMADDCPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31096, 295},
+    {I_VFMADDCPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31104, 295},
+    {I_VFMADDCPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31112, 295},
+    {I_VFMADDCPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31120, 295},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFCMADDCSH[] = {
+    {I_VFCMADDCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31128, 296},
+    {I_VFCMADDCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31136, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDCSH[] = {
+    {I_VFMADDCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31144, 296},
+    {I_VFMADDCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31152, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFCMULCPCH[] = {
+    {I_VFCMULCPCH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31160, 295},
+    {I_VFCMULCPCH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31168, 295},
+    {I_VFCMULCPCH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31176, 295},
+    {I_VFCMULCPCH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31184, 295},
+    {I_VFCMULCPCH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31192, 295},
+    {I_VFCMULCPCH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31200, 295},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMULCPCH[] = {
+    {I_VFMULCPCH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31208, 295},
+    {I_VFMULCPCH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31216, 295},
+    {I_VFMULCPCH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31224, 295},
+    {I_VFMULCPCH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31232, 295},
+    {I_VFMULCPCH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31240, 295},
+    {I_VFMULCPCH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31248, 295},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFCMULCSH[] = {
+    {I_VFCMULCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31256, 296},
+    {I_VFCMULCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31264, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMULCSH[] = {
+    {I_VFMULCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31272, 296},
+    {I_VFMULCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31280, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB132PH[] = {
+    {I_VFMADDSUB132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31288, 295},
+    {I_VFMADDSUB132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31296, 295},
+    {I_VFMADDSUB132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31304, 295},
+    {I_VFMADDSUB132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31312, 295},
+    {I_VFMADDSUB132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31320, 296},
+    {I_VFMADDSUB132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31328, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB213PH[] = {
+    {I_VFMADDSUB213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31336, 295},
+    {I_VFMADDSUB213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31344, 295},
+    {I_VFMADDSUB213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31352, 295},
+    {I_VFMADDSUB213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31360, 295},
+    {I_VFMADDSUB213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31368, 296},
+    {I_VFMADDSUB213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31376, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADDSUB231PH[] = {
+    {I_VFMADDSUB231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31384, 295},
+    {I_VFMADDSUB231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31392, 295},
+    {I_VFMADDSUB231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31400, 295},
+    {I_VFMADDSUB231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31408, 295},
+    {I_VFMADDSUB231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31416, 296},
+    {I_VFMADDSUB231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31424, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD132PH[] = {
+    {I_VFMSUBADD132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31432, 295},
+    {I_VFMSUBADD132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31440, 295},
+    {I_VFMSUBADD132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31448, 295},
+    {I_VFMSUBADD132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31456, 295},
+    {I_VFMSUBADD132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31464, 296},
+    {I_VFMSUBADD132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31472, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD213PH[] = {
+    {I_VFMSUBADD213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31480, 295},
+    {I_VFMSUBADD213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31488, 295},
+    {I_VFMSUBADD213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31496, 295},
+    {I_VFMSUBADD213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31504, 295},
+    {I_VFMSUBADD213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31512, 296},
+    {I_VFMSUBADD213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31520, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUBADD231PH[] = {
+    {I_VFMSUBADD231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31528, 295},
+    {I_VFMSUBADD231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31536, 295},
+    {I_VFMSUBADD231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31544, 295},
+    {I_VFMSUBADD231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31552, 295},
+    {I_VFMSUBADD231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31560, 296},
+    {I_VFMSUBADD231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31568, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD132PH[] = {
+    {I_VPMADD132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31576, 295},
+    {I_VPMADD132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31584, 295},
+    {I_VPMADD132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31592, 295},
+    {I_VPMADD132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31600, 295},
+    {I_VPMADD132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31608, 296},
+    {I_VPMADD132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31616, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD213PH[] = {
+    {I_VPMADD213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31624, 295},
+    {I_VPMADD213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31632, 295},
+    {I_VPMADD213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31640, 295},
+    {I_VPMADD213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31648, 295},
+    {I_VPMADD213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31656, 296},
+    {I_VPMADD213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31664, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD231PH[] = {
+    {I_VPMADD231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31672, 295},
+    {I_VPMADD231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31680, 295},
+    {I_VPMADD231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31688, 295},
+    {I_VPMADD231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31696, 295},
+    {I_VPMADD231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31704, 296},
+    {I_VPMADD231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31712, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD132PH[] = {
+    {I_VFMADD132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31720, 295},
+    {I_VFMADD132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31728, 295},
+    {I_VFMADD132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31736, 295},
+    {I_VFMADD132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31744, 295},
+    {I_VFMADD132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31752, 296},
+    {I_VFMADD132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31760, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD213PH[] = {
+    {I_VFMADD213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31768, 295},
+    {I_VFMADD213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31776, 295},
+    {I_VFMADD213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31784, 295},
+    {I_VFMADD213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31792, 295},
+    {I_VFMADD213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31800, 296},
+    {I_VFMADD213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31808, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMADD231PH[] = {
+    {I_VFMADD231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31816, 295},
+    {I_VFMADD231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31824, 295},
+    {I_VFMADD231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31832, 295},
+    {I_VFMADD231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31840, 295},
+    {I_VFMADD231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31848, 296},
+    {I_VFMADD231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31856, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD132SH[] = {
+    {I_VPMADD132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31864, 296},
+    {I_VPMADD132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31872, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD213SH[] = {
+    {I_VPMADD213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31880, 296},
+    {I_VPMADD213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31888, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMADD231SH[] = {
+    {I_VPMADD231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31896, 296},
+    {I_VPMADD231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31904, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPNMADD132SH[] = {
+    {I_VPNMADD132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31912, 296},
+    {I_VPNMADD132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31920, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPNMADD213SH[] = {
+    {I_VPNMADD213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31928, 296},
+    {I_VPNMADD213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31936, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPNMADD231SH[] = {
+    {I_VPNMADD231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31944, 296},
+    {I_VPNMADD231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31952, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMSUB132PH[] = {
+    {I_VPMSUB132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31960, 295},
+    {I_VPMSUB132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31968, 295},
+    {I_VPMSUB132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31976, 295},
+    {I_VPMSUB132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31984, 295},
+    {I_VPMSUB132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31992, 296},
+    {I_VPMSUB132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32000, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMSUB213PH[] = {
+    {I_VPMSUB213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32008, 295},
+    {I_VPMSUB213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32016, 295},
+    {I_VPMSUB213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32024, 295},
+    {I_VPMSUB213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32032, 295},
+    {I_VPMSUB213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32040, 296},
+    {I_VPMSUB213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32048, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMSUB231PH[] = {
+    {I_VPMSUB231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32056, 295},
+    {I_VPMSUB231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32064, 295},
+    {I_VPMSUB231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32072, 295},
+    {I_VPMSUB231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32080, 295},
+    {I_VPMSUB231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32088, 296},
+    {I_VPMSUB231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32096, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB132PH[] = {
+    {I_VFMSUB132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32104, 295},
+    {I_VFMSUB132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32112, 295},
+    {I_VFMSUB132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32120, 295},
+    {I_VFMSUB132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32128, 295},
+    {I_VFMSUB132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32136, 296},
+    {I_VFMSUB132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32144, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB213PH[] = {
+    {I_VFMSUB213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32152, 295},
+    {I_VFMSUB213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32160, 295},
+    {I_VFMSUB213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32168, 295},
+    {I_VFMSUB213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32176, 295},
+    {I_VFMSUB213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32184, 296},
+    {I_VFMSUB213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32192, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFMSUB231PH[] = {
+    {I_VFMSUB231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32200, 295},
+    {I_VFMSUB231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32208, 295},
+    {I_VFMSUB231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32216, 295},
+    {I_VFMSUB231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32224, 295},
+    {I_VFMSUB231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32232, 296},
+    {I_VFMSUB231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32240, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMSUB132SH[] = {
+    {I_VPMSUB132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32248, 296},
+    {I_VPMSUB132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32256, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMSUB213SH[] = {
+    {I_VPMSUB213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32264, 296},
+    {I_VPMSUB213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32272, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPMSUB231SH[] = {
+    {I_VPMSUB231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32280, 296},
+    {I_VPMSUB231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32288, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPNMSUB132SH[] = {
+    {I_VPNMSUB132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32296, 296},
+    {I_VPNMSUB132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32304, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPNMSUB213SH[] = {
+    {I_VPNMSUB213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32312, 296},
+    {I_VPNMSUB213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32320, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VPNMSUB231SH[] = {
+    {I_VPNMSUB231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32328, 296},
+    {I_VPNMSUB231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32336, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFPCLASSPH[] = {
+    {I_VFPCLASSPH, 3, {KREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12097, 295},
+    {I_VFPCLASSPH, 3, {KREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12106, 295},
+    {I_VFPCLASSPH, 3, {KREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12115, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VFPCLASSSH[] = {
+    {I_VFPCLASSSH, 3, {KREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+12124, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETEXPPH[] = {
+    {I_VGETEXPPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32344, 295},
+    {I_VGETEXPPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32352, 295},
+    {I_VGETEXPPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+32360, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETEXPSH[] = {
+    {I_VGETEXPSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32368, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMANTPH[] = {
+    {I_VGETMANTPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12133, 295},
+    {I_VGETMANTPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12142, 295},
+    {I_VGETMANTPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12151, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMANTSH[] = {
+    {I_VGETMANTSH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12160, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMAXPH[] = {
+    {I_VGETMAXPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32376, 295},
+    {I_VGETMAXPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32384, 295},
+    {I_VGETMAXPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+32392, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMAXSH[] = {
+    {I_VGETMAXSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32400, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMINPH[] = {
+    {I_VGETMINPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32408, 295},
+    {I_VGETMINPH, 2, {YMMREG,RM_XMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32416, 295},
+    {I_VGETMINPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+32424, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VGETMINSH[] = {
+    {I_VGETMINSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32432, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVSH[] = {
+    {I_VMOVSH, 2, {XMMREG,MEMORY|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32440, 296},
+    {I_VMOVSH, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+32448, 296},
+    {I_VMOVSH, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32456, 296},
+    {I_VMOVSH, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32464, 296},
+    {I_VMOVSH, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32472, 296},
+    {I_VMOVSH, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32480, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMOVW[] = {
+    {I_VMOVW, 2, {XMMREG,RM_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32488, 296},
+    {I_VMOVW, 2, {RM_GPR|BITS16,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+32496, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMULPH[] = {
+    {I_VMULPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32504, 295},
+    {I_VMULPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32512, 295},
+    {I_VMULPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32520, 295},
+    {I_VMULPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32528, 295},
+    {I_VMULPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32536, 296},
+    {I_VMULPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32544, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VMULSH[] = {
+    {I_VMULSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32552, 296},
+    {I_VMULSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32560, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCPPH[] = {
+    {I_VRCPPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32568, 295},
+    {I_VRCPPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32576, 295},
+    {I_VRCPPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32584, 295},
+    {I_VRCPPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32592, 295},
+    {I_VRCPPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32600, 296},
+    {I_VRCPPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32608, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRCPSH[] = {
+    {I_VRCPSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+32616, 296},
+    {I_VRCPSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32624, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VREDUCEPH[] = {
+    {I_VREDUCEPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12169, 295},
+    {I_VREDUCEPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12178, 295},
+    {I_VREDUCEPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12187, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VREDUCESH[] = {
+    {I_VREDUCESH, 4, {XMMREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+12196, 296},
+    {I_VREDUCESH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12205, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VENDSCALEPH[] = {
+    {I_VENDSCALEPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12214, 295},
+    {I_VENDSCALEPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12223, 295},
+    {I_VENDSCALEPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12232, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VENDSCALESH[] = {
+    {I_VENDSCALESH, 4, {XMMREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+12241, 296},
+    {I_VENDSCALESH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12250, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRTPH[] = {
+    {I_VRSQRTPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12259, 295},
+    {I_VRSQRTPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12268, 295},
+    {I_VRSQRTPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12277, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VRSQRTSH[] = {
+    {I_VRSQRTSH, 4, {XMMREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+12286, 296},
+    {I_VRSQRTSH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12295, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCALEFPH[] = {
+    {I_VSCALEFPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32632, 295},
+    {I_VSCALEFPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32640, 295},
+    {I_VSCALEFPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32648, 295},
+    {I_VSCALEFPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32656, 295},
+    {I_VSCALEFPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32664, 296},
+    {I_VSCALEFPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32672, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSCALEFSH[] = {
+    {I_VSCALEFSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32680, 296},
+    {I_VSCALEFSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32688, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSQRTPH[] = {
+    {I_VSQRTPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32696, 295},
+    {I_VSQRTPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32704, 295},
+    {I_VSQRTPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32712, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSQRTSH[] = {
+    {I_VSQRTSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32720, 296},
+    {I_VSQRTSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32728, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSUBPH[] = {
+    {I_VSUBPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32736, 295},
+    {I_VSUBPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32744, 295},
+    {I_VSUBPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32752, 295},
+    {I_VSUBPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32760, 295},
+    {I_VSUBPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32768, 296},
+    {I_VSUBPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32776, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VSUBSH[] = {
+    {I_VSUBSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32784, 296},
+    {I_VSUBSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32792, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_VUCOMISH[] = {
+    {I_VUCOMISH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+32800, 296},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AADD[] = {
+    {I_AADD, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32808, 299},
+    {I_AADD, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+32816, 300},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AAND[] = {
+    {I_AAND, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32824, 299},
+    {I_AAND, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+32832, 300},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_AXOR[] = {
+    {I_AXOR, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32840, 299},
+    {I_AXOR, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+32848, 300},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CLUI[] = {
+    {I_CLUI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46071, 301},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_SENDUIPI[] = {
+    {I_SENDUIPI, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42510, 301},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_STUI[] = {
+    {I_STUI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46077, 301},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_TESTUI[] = {
+    {I_TESTUI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46083, 301},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_UIRET[] = {
+    {I_UIRET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46089, 301},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPAXADD[] = {
+    {I_CMPAXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42517, 302},
+    {I_CMPAXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42629, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPAEXADD[] = {
+    {I_CMPAEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42524, 302},
+    {I_CMPAEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42636, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPBXADD[] = {
+    {I_CMPBXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42531, 302},
+    {I_CMPBXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42643, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPBEXADD[] = {
+    {I_CMPBEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42538, 302},
+    {I_CMPBEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42650, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPCXADD[] = {
+    {I_CMPCXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42531, 302},
+    {I_CMPCXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42643, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPEXADD[] = {
+    {I_CMPEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42545, 302},
+    {I_CMPEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42657, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPGXADD[] = {
+    {I_CMPGXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42552, 302},
+    {I_CMPGXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42664, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPGEXADD[] = {
+    {I_CMPGEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42559, 302},
+    {I_CMPGEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42671, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLXADD[] = {
+    {I_CMPLXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42566, 302},
+    {I_CMPLXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42678, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPLEXADD[] = {
+    {I_CMPLEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42573, 302},
+    {I_CMPLEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42685, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNAXADD[] = {
+    {I_CMPNAXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42538, 302},
+    {I_CMPNAXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42650, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNAEXADD[] = {
+    {I_CMPNAEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42531, 302},
+    {I_CMPNAEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42643, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNBXADD[] = {
+    {I_CMPNBXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42524, 302},
+    {I_CMPNBXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42636, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNBEXADD[] = {
+    {I_CMPNBEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42517, 302},
+    {I_CMPNBEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42629, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNCXADD[] = {
+    {I_CMPNCXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42524, 302},
+    {I_CMPNCXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42636, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNEXADD[] = {
+    {I_CMPNEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42580, 302},
+    {I_CMPNEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42692, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNGXADD[] = {
+    {I_CMPNGXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42573, 302},
+    {I_CMPNGXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42685, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNGEXADD[] = {
+    {I_CMPNGEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42566, 302},
+    {I_CMPNGEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42678, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLXADD[] = {
+    {I_CMPNLXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42559, 302},
+    {I_CMPNLXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42671, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNLEXADD[] = {
+    {I_CMPNLEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42552, 302},
+    {I_CMPNLEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42664, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNOXADD[] = {
+    {I_CMPNOXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42587, 302},
+    {I_CMPNOXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42699, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNPXADD[] = {
+    {I_CMPNPXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42594, 302},
+    {I_CMPNPXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42706, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNSXADD[] = {
+    {I_CMPNSXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42601, 302},
+    {I_CMPNSXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42713, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPNZXADD[] = {
+    {I_CMPNZXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42580, 302},
+    {I_CMPNZXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42692, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPOXADD[] = {
+    {I_CMPOXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42608, 302},
+    {I_CMPOXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42720, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPPXADD[] = {
+    {I_CMPPXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42615, 302},
+    {I_CMPPXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42727, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPPEXADD[] = {
+    {I_CMPPEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42615, 302},
+    {I_CMPPEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42727, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPPOXADD[] = {
+    {I_CMPPOXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42594, 302},
+    {I_CMPPOXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42706, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPSXADD[] = {
+    {I_CMPSXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42622, 302},
+    {I_CMPSXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42734, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_CMPZXADD[] = {
+    {I_CMPZXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42545, 302},
+    {I_CMPZXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42657, 303},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRMSRNS[] = {
+    {I_WRMSRNS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46095, 304},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_RDMSRLIST[] = {
+    {I_RDMSRLIST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46101, 305},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_WRMSRLIST[] = {
+    {I_WRMSRLIST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46107, 305},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HRESET[] = {
+    {I_HRESET, 2, {IMMEDIATE,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+32856, 306},
+    {I_HRESET, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+32856, 306},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP0[] = {
+    {I_HINT_NOP0, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46113, 307},
+    {I_HINT_NOP0, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46119, 307},
+    {I_HINT_NOP0, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46125, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP1[] = {
+    {I_HINT_NOP1, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46131, 307},
+    {I_HINT_NOP1, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46137, 307},
+    {I_HINT_NOP1, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46143, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP2[] = {
+    {I_HINT_NOP2, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46149, 307},
+    {I_HINT_NOP2, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46155, 307},
+    {I_HINT_NOP2, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46161, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP3[] = {
+    {I_HINT_NOP3, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46167, 307},
+    {I_HINT_NOP3, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46173, 307},
+    {I_HINT_NOP3, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46179, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP4[] = {
+    {I_HINT_NOP4, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46185, 307},
+    {I_HINT_NOP4, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46191, 307},
+    {I_HINT_NOP4, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46197, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP5[] = {
+    {I_HINT_NOP5, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46203, 307},
+    {I_HINT_NOP5, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46209, 307},
+    {I_HINT_NOP5, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46215, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP6[] = {
+    {I_HINT_NOP6, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46221, 307},
+    {I_HINT_NOP6, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46227, 307},
+    {I_HINT_NOP6, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46233, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP7[] = {
+    {I_HINT_NOP7, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46239, 307},
+    {I_HINT_NOP7, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46245, 307},
+    {I_HINT_NOP7, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46251, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP8[] = {
+    {I_HINT_NOP8, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46257, 307},
+    {I_HINT_NOP8, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46263, 307},
+    {I_HINT_NOP8, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46269, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP9[] = {
+    {I_HINT_NOP9, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46275, 307},
+    {I_HINT_NOP9, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46281, 307},
+    {I_HINT_NOP9, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46287, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP10[] = {
+    {I_HINT_NOP10, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46293, 307},
+    {I_HINT_NOP10, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46299, 307},
+    {I_HINT_NOP10, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46305, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP11[] = {
+    {I_HINT_NOP11, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46311, 307},
+    {I_HINT_NOP11, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46317, 307},
+    {I_HINT_NOP11, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46323, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP12[] = {
+    {I_HINT_NOP12, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46329, 307},
+    {I_HINT_NOP12, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46335, 307},
+    {I_HINT_NOP12, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46341, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP13[] = {
+    {I_HINT_NOP13, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46347, 307},
+    {I_HINT_NOP13, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46353, 307},
+    {I_HINT_NOP13, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46359, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP14[] = {
+    {I_HINT_NOP14, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46365, 307},
+    {I_HINT_NOP14, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46371, 307},
+    {I_HINT_NOP14, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46377, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP15[] = {
+    {I_HINT_NOP15, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46383, 307},
+    {I_HINT_NOP15, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46389, 307},
+    {I_HINT_NOP15, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46395, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP16[] = {
+    {I_HINT_NOP16, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46401, 307},
+    {I_HINT_NOP16, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46407, 307},
+    {I_HINT_NOP16, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46413, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP17[] = {
+    {I_HINT_NOP17, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46419, 307},
+    {I_HINT_NOP17, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46425, 307},
+    {I_HINT_NOP17, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46431, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP18[] = {
+    {I_HINT_NOP18, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46437, 307},
+    {I_HINT_NOP18, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46443, 307},
+    {I_HINT_NOP18, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46449, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP19[] = {
+    {I_HINT_NOP19, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46455, 307},
+    {I_HINT_NOP19, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46461, 307},
+    {I_HINT_NOP19, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46467, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP20[] = {
+    {I_HINT_NOP20, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46473, 307},
+    {I_HINT_NOP20, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46479, 307},
+    {I_HINT_NOP20, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46485, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP21[] = {
+    {I_HINT_NOP21, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46491, 307},
+    {I_HINT_NOP21, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46497, 307},
+    {I_HINT_NOP21, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46503, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP22[] = {
+    {I_HINT_NOP22, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46509, 307},
+    {I_HINT_NOP22, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46515, 307},
+    {I_HINT_NOP22, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46521, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP23[] = {
+    {I_HINT_NOP23, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46527, 307},
+    {I_HINT_NOP23, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46533, 307},
+    {I_HINT_NOP23, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46539, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP24[] = {
+    {I_HINT_NOP24, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46545, 307},
+    {I_HINT_NOP24, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46551, 307},
+    {I_HINT_NOP24, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46557, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP25[] = {
+    {I_HINT_NOP25, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46563, 307},
+    {I_HINT_NOP25, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46569, 307},
+    {I_HINT_NOP25, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46575, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP26[] = {
+    {I_HINT_NOP26, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46581, 307},
+    {I_HINT_NOP26, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46587, 307},
+    {I_HINT_NOP26, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46593, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP27[] = {
+    {I_HINT_NOP27, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46599, 307},
+    {I_HINT_NOP27, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46605, 307},
+    {I_HINT_NOP27, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46611, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP28[] = {
+    {I_HINT_NOP28, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46617, 307},
+    {I_HINT_NOP28, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46623, 307},
+    {I_HINT_NOP28, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46629, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP29[] = {
+    {I_HINT_NOP29, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46635, 307},
+    {I_HINT_NOP29, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46641, 307},
+    {I_HINT_NOP29, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46647, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP30[] = {
+    {I_HINT_NOP30, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46653, 307},
+    {I_HINT_NOP30, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46659, 307},
+    {I_HINT_NOP30, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46665, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP31[] = {
+    {I_HINT_NOP31, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46671, 307},
+    {I_HINT_NOP31, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46677, 307},
+    {I_HINT_NOP31, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46683, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP32[] = {
+    {I_HINT_NOP32, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46689, 307},
+    {I_HINT_NOP32, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46695, 307},
+    {I_HINT_NOP32, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46701, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP33[] = {
+    {I_HINT_NOP33, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46707, 307},
+    {I_HINT_NOP33, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46713, 307},
+    {I_HINT_NOP33, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46719, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP34[] = {
+    {I_HINT_NOP34, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46725, 307},
+    {I_HINT_NOP34, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46731, 307},
+    {I_HINT_NOP34, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46737, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP35[] = {
+    {I_HINT_NOP35, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46743, 307},
+    {I_HINT_NOP35, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46749, 307},
+    {I_HINT_NOP35, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46755, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP36[] = {
+    {I_HINT_NOP36, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46761, 307},
+    {I_HINT_NOP36, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46767, 307},
+    {I_HINT_NOP36, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46773, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP37[] = {
+    {I_HINT_NOP37, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46779, 307},
+    {I_HINT_NOP37, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46785, 307},
+    {I_HINT_NOP37, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46791, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP38[] = {
+    {I_HINT_NOP38, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46797, 307},
+    {I_HINT_NOP38, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46803, 307},
+    {I_HINT_NOP38, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46809, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP39[] = {
+    {I_HINT_NOP39, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46815, 307},
+    {I_HINT_NOP39, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46821, 307},
+    {I_HINT_NOP39, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46827, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP40[] = {
+    {I_HINT_NOP40, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46833, 307},
+    {I_HINT_NOP40, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46839, 307},
+    {I_HINT_NOP40, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46845, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP41[] = {
+    {I_HINT_NOP41, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46851, 307},
+    {I_HINT_NOP41, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46857, 307},
+    {I_HINT_NOP41, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46863, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP42[] = {
+    {I_HINT_NOP42, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46869, 307},
+    {I_HINT_NOP42, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46875, 307},
+    {I_HINT_NOP42, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46881, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP43[] = {
+    {I_HINT_NOP43, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46887, 307},
+    {I_HINT_NOP43, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46893, 307},
+    {I_HINT_NOP43, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46899, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP44[] = {
+    {I_HINT_NOP44, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46905, 307},
+    {I_HINT_NOP44, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46911, 307},
+    {I_HINT_NOP44, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46917, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP45[] = {
+    {I_HINT_NOP45, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46923, 307},
+    {I_HINT_NOP45, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46929, 307},
+    {I_HINT_NOP45, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46935, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP46[] = {
+    {I_HINT_NOP46, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46941, 307},
+    {I_HINT_NOP46, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46947, 307},
+    {I_HINT_NOP46, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46953, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP47[] = {
+    {I_HINT_NOP47, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46959, 307},
+    {I_HINT_NOP47, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46965, 307},
+    {I_HINT_NOP47, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46971, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP48[] = {
+    {I_HINT_NOP48, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46977, 307},
+    {I_HINT_NOP48, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46983, 307},
+    {I_HINT_NOP48, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46989, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP49[] = {
+    {I_HINT_NOP49, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46995, 307},
+    {I_HINT_NOP49, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47001, 307},
+    {I_HINT_NOP49, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47007, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP50[] = {
+    {I_HINT_NOP50, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47013, 307},
+    {I_HINT_NOP50, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47019, 307},
+    {I_HINT_NOP50, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47025, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP51[] = {
+    {I_HINT_NOP51, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47031, 307},
+    {I_HINT_NOP51, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47037, 307},
+    {I_HINT_NOP51, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47043, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP52[] = {
+    {I_HINT_NOP52, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47049, 307},
+    {I_HINT_NOP52, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47055, 307},
+    {I_HINT_NOP52, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47061, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP53[] = {
+    {I_HINT_NOP53, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47067, 307},
+    {I_HINT_NOP53, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47073, 307},
+    {I_HINT_NOP53, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47079, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP54[] = {
+    {I_HINT_NOP54, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47085, 307},
+    {I_HINT_NOP54, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47091, 307},
+    {I_HINT_NOP54, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47097, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP55[] = {
+    {I_HINT_NOP55, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47103, 307},
+    {I_HINT_NOP55, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47109, 307},
+    {I_HINT_NOP55, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47115, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP56[] = {
+    {I_HINT_NOP56, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43437, 307},
+    {I_HINT_NOP56, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43443, 307},
+    {I_HINT_NOP56, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43449, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP57[] = {
+    {I_HINT_NOP57, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47121, 307},
+    {I_HINT_NOP57, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47127, 307},
+    {I_HINT_NOP57, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47133, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP58[] = {
+    {I_HINT_NOP58, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47139, 307},
+    {I_HINT_NOP58, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47145, 307},
+    {I_HINT_NOP58, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47151, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP59[] = {
+    {I_HINT_NOP59, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47157, 307},
+    {I_HINT_NOP59, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47163, 307},
+    {I_HINT_NOP59, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47169, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP60[] = {
+    {I_HINT_NOP60, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47175, 307},
+    {I_HINT_NOP60, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47181, 307},
+    {I_HINT_NOP60, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47187, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP61[] = {
+    {I_HINT_NOP61, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47193, 307},
+    {I_HINT_NOP61, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47199, 307},
+    {I_HINT_NOP61, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47205, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP62[] = {
+    {I_HINT_NOP62, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47211, 307},
+    {I_HINT_NOP62, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47217, 307},
+    {I_HINT_NOP62, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47223, 308},
+    ITEMPLATE_END
+};
+
+static const struct itemplate instrux_HINT_NOP63[] = {
+    {I_HINT_NOP63, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47229, 307},
+    {I_HINT_NOP63, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47235, 307},
+    {I_HINT_NOP63, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47241, 308},
+    ITEMPLATE_END
+};
+
+const struct itemplate * const nasm_instructions[] = {
+    instrux_DB,
+    instrux_DW,
+    instrux_DD,
+    instrux_DQ,
+    instrux_DT,
+    instrux_DO,
+    instrux_DY,
+    instrux_DZ,
+    instrux_RESB,
+    instrux_RESW,
+    instrux_RESD,
+    instrux_RESQ,
+    instrux_REST,
+    instrux_RESO,
+    instrux_RESY,
+    instrux_RESZ,
+    instrux_INCBIN,
+    instrux_AAA,
+    instrux_AAD,
+    instrux_AAM,
+    instrux_AAS,
+    instrux_ADC,
+    instrux_ADD,
+    instrux_AND,
+    instrux_ARPL,
+    instrux_BB0_RESET,
+    instrux_BB1_RESET,
+    instrux_BOUND,
+    instrux_BSF,
+    instrux_BSR,
+    instrux_BSWAP,
+    instrux_BT,
+    instrux_BTC,
+    instrux_BTR,
+    instrux_BTS,
+    instrux_CALL,
+    instrux_CBW,
+    instrux_CDQ,
+    instrux_CDQE,
+    instrux_CLC,
+    instrux_CLD,
+    instrux_CLI,
+    instrux_CLTS,
+    instrux_CMC,
+    instrux_CMP,
+    instrux_CMPSB,
+    instrux_CMPSD,
+    instrux_CMPSQ,
+    instrux_CMPSW,
+    instrux_CMPXCHG,
+    instrux_CMPXCHG486,
+    instrux_CMPXCHG8B,
+    instrux_CMPXCHG16B,
+    instrux_CPUID,
+    instrux_CPU_READ,
+    instrux_CPU_WRITE,
+    instrux_CQO,
+    instrux_CWD,
+    instrux_CWDE,
+    instrux_DAA,
+    instrux_DAS,
+    instrux_DEC,
+    instrux_DIV,
+    instrux_DMINT,
+    instrux_EMMS,
+    instrux_ENTER,
+    instrux_EQU,
+    instrux_F2XM1,
+    instrux_FABS,
+    instrux_FADD,
+    instrux_FADDP,
+    instrux_FBLD,
+    instrux_FBSTP,
+    instrux_FCHS,
+    instrux_FCLEX,
+    instrux_FCMOVB,
+    instrux_FCMOVBE,
+    instrux_FCMOVE,
+    instrux_FCMOVNB,
+    instrux_FCMOVNBE,
+    instrux_FCMOVNE,
+    instrux_FCMOVNU,
+    instrux_FCMOVU,
+    instrux_FCOM,
+    instrux_FCOMI,
+    instrux_FCOMIP,
+    instrux_FCOMP,
+    instrux_FCOMPP,
+    instrux_FCOS,
+    instrux_FDECSTP,
+    instrux_FDISI,
+    instrux_FDIV,
+    instrux_FDIVP,
+    instrux_FDIVR,
+    instrux_FDIVRP,
+    instrux_FEMMS,
+    instrux_FENI,
+    instrux_FFREE,
+    instrux_FFREEP,
+    instrux_FIADD,
+    instrux_FICOM,
+    instrux_FICOMP,
+    instrux_FIDIV,
+    instrux_FIDIVR,
+    instrux_FILD,
+    instrux_FIMUL,
+    instrux_FINCSTP,
+    instrux_FINIT,
+    instrux_FIST,
+    instrux_FISTP,
+    instrux_FISTTP,
+    instrux_FISUB,
+    instrux_FISUBR,
+    instrux_FLD,
+    instrux_FLD1,
+    instrux_FLDCW,
+    instrux_FLDENV,
+    instrux_FLDL2E,
+    instrux_FLDL2T,
+    instrux_FLDLG2,
+    instrux_FLDLN2,
+    instrux_FLDPI,
+    instrux_FLDZ,
+    instrux_FMUL,
+    instrux_FMULP,
+    instrux_FNCLEX,
+    instrux_FNDISI,
+    instrux_FNENI,
+    instrux_FNINIT,
+    instrux_FNOP,
+    instrux_FNSAVE,
+    instrux_FNSTCW,
+    instrux_FNSTENV,
+    instrux_FNSTSW,
+    instrux_FPATAN,
+    instrux_FPREM,
+    instrux_FPREM1,
+    instrux_FPTAN,
+    instrux_FRNDINT,
+    instrux_FRSTOR,
+    instrux_FSAVE,
+    instrux_FSCALE,
+    instrux_FSETPM,
+    instrux_FSIN,
+    instrux_FSINCOS,
+    instrux_FSQRT,
+    instrux_FST,
+    instrux_FSTCW,
+    instrux_FSTENV,
+    instrux_FSTP,
+    instrux_FSTSW,
+    instrux_FSUB,
+    instrux_FSUBP,
+    instrux_FSUBR,
+    instrux_FSUBRP,
+    instrux_FTST,
+    instrux_FUCOM,
+    instrux_FUCOMI,
+    instrux_FUCOMIP,
+    instrux_FUCOMP,
+    instrux_FUCOMPP,
+    instrux_FXAM,
+    instrux_FXCH,
+    instrux_FXTRACT,
+    instrux_FYL2X,
+    instrux_FYL2XP1,
+    instrux_HLT,
+    instrux_IBTS,
+    instrux_ICEBP,
+    instrux_IDIV,
+    instrux_IMUL,
+    instrux_IN,
+    instrux_INC,
+    instrux_INSB,
+    instrux_INSD,
+    instrux_INSW,
+    instrux_INT,
+    instrux_INT01,
+    instrux_INT1,
+    instrux_INT03,
+    instrux_INT3,
+    instrux_INTO,
+    instrux_INVD,
+    instrux_INVPCID,
+    instrux_INVLPG,
+    instrux_INVLPGA,
+    instrux_IRET,
+    instrux_IRETD,
+    instrux_IRETQ,
+    instrux_IRETW,
+    instrux_JCXZ,
+    instrux_JECXZ,
+    instrux_JRCXZ,
+    instrux_JMP,
+    instrux_JMPE,
+    instrux_LAHF,
+    instrux_LAR,
+    instrux_LDS,
+    instrux_LEA,
+    instrux_LEAVE,
+    instrux_LES,
+    instrux_LFENCE,
+    instrux_LFS,
+    instrux_LGDT,
+    instrux_LGS,
+    instrux_LIDT,
+    instrux_LLDT,
+    instrux_LMSW,
+    instrux_LOADALL,
+    instrux_LOADALL286,
+    instrux_LODSB,
+    instrux_LODSD,
+    instrux_LODSQ,
+    instrux_LODSW,
+    instrux_LOOP,
+    instrux_LOOPE,
+    instrux_LOOPNE,
+    instrux_LOOPNZ,
+    instrux_LOOPZ,
+    instrux_LSL,
+    instrux_LSS,
+    instrux_LTR,
+    instrux_MFENCE,
+    instrux_MONITOR,
+    instrux_MONITORX,
+    instrux_MOV,
+    instrux_MOVD,
+    instrux_MOVQ,
+    instrux_MOVSB,
+    instrux_MOVSD,
+    instrux_MOVSQ,
+    instrux_MOVSW,
+    instrux_MOVSX,
+    instrux_MOVSXD,
+    instrux_MOVZX,
+    instrux_MUL,
+    instrux_MWAIT,
+    instrux_MWAITX,
+    instrux_NEG,
+    instrux_NOP,
+    instrux_NOT,
+    instrux_OR,
+    instrux_OUT,
+    instrux_OUTSB,
+    instrux_OUTSD,
+    instrux_OUTSW,
+    instrux_PACKSSDW,
+    instrux_PACKSSWB,
+    instrux_PACKUSWB,
+    instrux_PADDB,
+    instrux_PADDD,
+    instrux_PADDSB,
+    instrux_PADDSIW,
+    instrux_PADDSW,
+    instrux_PADDUSB,
+    instrux_PADDUSW,
+    instrux_PADDW,
+    instrux_PAND,
+    instrux_PANDN,
+    instrux_PAUSE,
+    instrux_PAVEB,
+    instrux_PAVGUSB,
+    instrux_PCMPEQB,
+    instrux_PCMPEQD,
+    instrux_PCMPEQW,
+    instrux_PCMPGTB,
+    instrux_PCMPGTD,
+    instrux_PCMPGTW,
+    instrux_PDISTIB,
+    instrux_PF2ID,
+    instrux_PFACC,
+    instrux_PFADD,
+    instrux_PFCMPEQ,
+    instrux_PFCMPGE,
+    instrux_PFCMPGT,
+    instrux_PFMAX,
+    instrux_PFMIN,
+    instrux_PFMUL,
+    instrux_PFRCP,
+    instrux_PFRCPIT1,
+    instrux_PFRCPIT2,
+    instrux_PFRSQIT1,
+    instrux_PFRSQRT,
+    instrux_PFSUB,
+    instrux_PFSUBR,
+    instrux_PI2FD,
+    instrux_PMACHRIW,
+    instrux_PMADDWD,
+    instrux_PMAGW,
+    instrux_PMULHRIW,
+    instrux_PMULHRWA,
+    instrux_PMULHRWC,
+    instrux_PMULHW,
+    instrux_PMULLW,
+    instrux_PMVGEZB,
+    instrux_PMVLZB,
+    instrux_PMVNZB,
+    instrux_PMVZB,
+    instrux_POP,
+    instrux_POPA,
+    instrux_POPAD,
+    instrux_POPAW,
+    instrux_POPF,
+    instrux_POPFD,
+    instrux_POPFQ,
+    instrux_POPFW,
+    instrux_POR,
+    instrux_PREFETCH,
+    instrux_PREFETCHW,
+    instrux_PSLLD,
+    instrux_PSLLQ,
+    instrux_PSLLW,
+    instrux_PSRAD,
+    instrux_PSRAW,
+    instrux_PSRLD,
+    instrux_PSRLQ,
+    instrux_PSRLW,
+    instrux_PSUBB,
+    instrux_PSUBD,
+    instrux_PSUBSB,
+    instrux_PSUBSIW,
+    instrux_PSUBSW,
+    instrux_PSUBUSB,
+    instrux_PSUBUSW,
+    instrux_PSUBW,
+    instrux_PUNPCKHBW,
+    instrux_PUNPCKHDQ,
+    instrux_PUNPCKHWD,
+    instrux_PUNPCKLBW,
+    instrux_PUNPCKLDQ,
+    instrux_PUNPCKLWD,
+    instrux_PUSH,
+    instrux_PUSHA,
+    instrux_PUSHAD,
+    instrux_PUSHAW,
+    instrux_PUSHF,
+    instrux_PUSHFD,
+    instrux_PUSHFQ,
+    instrux_PUSHFW,
+    instrux_PXOR,
+    instrux_RCL,
+    instrux_RCR,
+    instrux_RDSHR,
+    instrux_RDMSR,
+    instrux_RDPMC,
+    instrux_RDTSC,
+    instrux_RDTSCP,
+    instrux_RET,
+    instrux_RETF,
+    instrux_RETN,
+    instrux_RETW,
+    instrux_RETFW,
+    instrux_RETNW,
+    instrux_RETD,
+    instrux_RETFD,
+    instrux_RETND,
+    instrux_RETQ,
+    instrux_RETFQ,
+    instrux_RETNQ,
+    instrux_ROL,
+    instrux_ROR,
+    instrux_RDM,
+    instrux_RSDC,
+    instrux_RSLDT,
+    instrux_RSM,
+    instrux_RSTS,
+    instrux_SAHF,
+    instrux_SAL,
+    instrux_SALC,
+    instrux_SAR,
+    instrux_SBB,
+    instrux_SCASB,
+    instrux_SCASD,
+    instrux_SCASQ,
+    instrux_SCASW,
+    instrux_SFENCE,
+    instrux_SGDT,
+    instrux_SHL,
+    instrux_SHLD,
+    instrux_SHR,
+    instrux_SHRD,
+    instrux_SIDT,
+    instrux_SLDT,
+    instrux_SKINIT,
+    instrux_SMI,
+    instrux_SMINT,
+    instrux_SMINTOLD,
+    instrux_SMSW,
+    instrux_STC,
+    instrux_STD,
+    instrux_STI,
+    instrux_STOSB,
+    instrux_STOSD,
+    instrux_STOSQ,
+    instrux_STOSW,
+    instrux_STR,
+    instrux_SUB,
+    instrux_SVDC,
+    instrux_SVLDT,
+    instrux_SVTS,
+    instrux_SWAPGS,
+    instrux_SYSCALL,
+    instrux_SYSENTER,
+    instrux_SYSEXIT,
+    instrux_SYSRET,
+    instrux_TEST,
+    instrux_UD0,
+    instrux_UD1,
+    instrux_UD2B,
+    instrux_UD2,
+    instrux_UD2A,
+    instrux_UMOV,
+    instrux_VERR,
+    instrux_VERW,
+    instrux_FWAIT,
+    instrux_WBINVD,
+    instrux_WRSHR,
+    instrux_WRMSR,
+    instrux_XADD,
+    instrux_XBTS,
+    instrux_XCHG,
+    instrux_XLATB,
+    instrux_XLAT,
+    instrux_XOR,
+    instrux_CMOVA,
+    instrux_CMOVAE,
+    instrux_CMOVB,
+    instrux_CMOVBE,
+    instrux_CMOVC,
+    instrux_CMOVE,
+    instrux_CMOVG,
+    instrux_CMOVGE,
+    instrux_CMOVL,
+    instrux_CMOVLE,
+    instrux_CMOVNA,
+    instrux_CMOVNAE,
+    instrux_CMOVNB,
+    instrux_CMOVNBE,
+    instrux_CMOVNC,
+    instrux_CMOVNE,
+    instrux_CMOVNG,
+    instrux_CMOVNGE,
+    instrux_CMOVNL,
+    instrux_CMOVNLE,
+    instrux_CMOVNO,
+    instrux_CMOVNP,
+    instrux_CMOVNS,
+    instrux_CMOVNZ,
+    instrux_CMOVO,
+    instrux_CMOVP,
+    instrux_CMOVPE,
+    instrux_CMOVPO,
+    instrux_CMOVS,
+    instrux_CMOVZ,
+    instrux_JA,
+    instrux_JAE,
+    instrux_JB,
+    instrux_JBE,
+    instrux_JC,
+    instrux_JE,
+    instrux_JG,
+    instrux_JGE,
+    instrux_JL,
+    instrux_JLE,
+    instrux_JNA,
+    instrux_JNAE,
+    instrux_JNB,
+    instrux_JNBE,
+    instrux_JNC,
+    instrux_JNE,
+    instrux_JNG,
+    instrux_JNGE,
+    instrux_JNL,
+    instrux_JNLE,
+    instrux_JNO,
+    instrux_JNP,
+    instrux_JNS,
+    instrux_JNZ,
+    instrux_JO,
+    instrux_JP,
+    instrux_JPE,
+    instrux_JPO,
+    instrux_JS,
+    instrux_JZ,
+    instrux_SETA,
+    instrux_SETAE,
+    instrux_SETB,
+    instrux_SETBE,
+    instrux_SETC,
+    instrux_SETE,
+    instrux_SETG,
+    instrux_SETGE,
+    instrux_SETL,
+    instrux_SETLE,
+    instrux_SETNA,
+    instrux_SETNAE,
+    instrux_SETNB,
+    instrux_SETNBE,
+    instrux_SETNC,
+    instrux_SETNE,
+    instrux_SETNG,
+    instrux_SETNGE,
+    instrux_SETNL,
+    instrux_SETNLE,
+    instrux_SETNO,
+    instrux_SETNP,
+    instrux_SETNS,
+    instrux_SETNZ,
+    instrux_SETO,
+    instrux_SETP,
+    instrux_SETPE,
+    instrux_SETPO,
+    instrux_SETS,
+    instrux_SETZ,
+    instrux_ADDPS,
+    instrux_ADDSS,
+    instrux_ANDNPS,
+    instrux_ANDPS,
+    instrux_CMPEQPS,
+    instrux_CMPEQSS,
+    instrux_CMPLEPS,
+    instrux_CMPLESS,
+    instrux_CMPLTPS,
+    instrux_CMPLTSS,
+    instrux_CMPNEQPS,
+    instrux_CMPNEQSS,
+    instrux_CMPNLEPS,
+    instrux_CMPNLESS,
+    instrux_CMPNLTPS,
+    instrux_CMPNLTSS,
+    instrux_CMPORDPS,
+    instrux_CMPORDSS,
+    instrux_CMPUNORDPS,
+    instrux_CMPUNORDSS,
+    instrux_CMPPS,
+    instrux_CMPSS,
+    instrux_COMISS,
+    instrux_CVTPI2PS,
+    instrux_CVTPS2PI,
+    instrux_CVTSI2SS,
+    instrux_CVTSS2SI,
+    instrux_CVTTPS2PI,
+    instrux_CVTTSS2SI,
+    instrux_DIVPS,
+    instrux_DIVSS,
+    instrux_LDMXCSR,
+    instrux_MAXPS,
+    instrux_MAXSS,
+    instrux_MINPS,
+    instrux_MINSS,
+    instrux_MOVAPS,
+    instrux_MOVHPS,
+    instrux_MOVLHPS,
+    instrux_MOVLPS,
+    instrux_MOVHLPS,
+    instrux_MOVMSKPS,
+    instrux_MOVNTPS,
+    instrux_MOVSS,
+    instrux_MOVUPS,
+    instrux_MULPS,
+    instrux_MULSS,
+    instrux_ORPS,
+    instrux_RCPPS,
+    instrux_RCPSS,
+    instrux_RSQRTPS,
+    instrux_RSQRTSS,
+    instrux_SHUFPS,
+    instrux_SQRTPS,
+    instrux_SQRTSS,
+    instrux_STMXCSR,
+    instrux_SUBPS,
+    instrux_SUBSS,
+    instrux_UCOMISS,
+    instrux_UNPCKHPS,
+    instrux_UNPCKLPS,
+    instrux_XORPS,
+    instrux_FXRSTOR,
+    instrux_FXRSTOR64,
+    instrux_FXSAVE,
+    instrux_FXSAVE64,
+    instrux_XGETBV,
+    instrux_XSETBV,
+    instrux_XSAVE,
+    instrux_XSAVE64,
+    instrux_XSAVEC,
+    instrux_XSAVEC64,
+    instrux_XSAVEOPT,
+    instrux_XSAVEOPT64,
+    instrux_XSAVES,
+    instrux_XSAVES64,
+    instrux_XRSTOR,
+    instrux_XRSTOR64,
+    instrux_XRSTORS,
+    instrux_XRSTORS64,
+    instrux_PREFETCHNTA,
+    instrux_PREFETCHT0,
+    instrux_PREFETCHT1,
+    instrux_PREFETCHT2,
+    instrux_PREFETCHIT0,
+    instrux_PREFETCHIT1,
+    instrux_MASKMOVQ,
+    instrux_MOVNTQ,
+    instrux_PAVGB,
+    instrux_PAVGW,
+    instrux_PEXTRW,
+    instrux_PINSRW,
+    instrux_PMAXSW,
+    instrux_PMAXUB,
+    instrux_PMINSW,
+    instrux_PMINUB,
+    instrux_PMOVMSKB,
+    instrux_PMULHUW,
+    instrux_PSADBW,
+    instrux_PSHUFW,
+    instrux_PF2IW,
+    instrux_PFNACC,
+    instrux_PFPNACC,
+    instrux_PI2FW,
+    instrux_PSWAPD,
+    instrux_MASKMOVDQU,
+    instrux_CLFLUSH,
+    instrux_MOVNTDQ,
+    instrux_MOVNTI,
+    instrux_MOVNTPD,
+    instrux_MOVDQA,
+    instrux_MOVDQU,
+    instrux_MOVDQ2Q,
+    instrux_MOVQ2DQ,
+    instrux_PADDQ,
+    instrux_PMULUDQ,
+    instrux_PSHUFD,
+    instrux_PSHUFHW,
+    instrux_PSHUFLW,
+    instrux_PSLLDQ,
+    instrux_PSRLDQ,
+    instrux_PSUBQ,
+    instrux_PUNPCKHQDQ,
+    instrux_PUNPCKLQDQ,
+    instrux_ADDPD,
+    instrux_ADDSD,
+    instrux_ANDNPD,
+    instrux_ANDPD,
+    instrux_CMPEQPD,
+    instrux_CMPEQSD,
+    instrux_CMPLEPD,
+    instrux_CMPLESD,
+    instrux_CMPLTPD,
+    instrux_CMPLTSD,
+    instrux_CMPNEQPD,
+    instrux_CMPNEQSD,
+    instrux_CMPNLEPD,
+    instrux_CMPNLESD,
+    instrux_CMPNLTPD,
+    instrux_CMPNLTSD,
+    instrux_CMPORDPD,
+    instrux_CMPORDSD,
+    instrux_CMPUNORDPD,
+    instrux_CMPUNORDSD,
+    instrux_CMPPD,
+    instrux_COMISD,
+    instrux_CVTDQ2PD,
+    instrux_CVTDQ2PS,
+    instrux_CVTPD2DQ,
+    instrux_CVTPD2PI,
+    instrux_CVTPD2PS,
+    instrux_CVTPI2PD,
+    instrux_CVTPS2DQ,
+    instrux_CVTPS2PD,
+    instrux_CVTSD2SI,
+    instrux_CVTSD2SS,
+    instrux_CVTSI2SD,
+    instrux_CVTSS2SD,
+    instrux_CVTTPD2PI,
+    instrux_CVTTPD2DQ,
+    instrux_CVTTPS2DQ,
+    instrux_CVTTSD2SI,
+    instrux_DIVPD,
+    instrux_DIVSD,
+    instrux_MAXPD,
+    instrux_MAXSD,
+    instrux_MINPD,
+    instrux_MINSD,
+    instrux_MOVAPD,
+    instrux_MOVHPD,
+    instrux_MOVLPD,
+    instrux_MOVMSKPD,
+    instrux_MOVUPD,
+    instrux_MULPD,
+    instrux_MULSD,
+    instrux_ORPD,
+    instrux_SHUFPD,
+    instrux_SQRTPD,
+    instrux_SQRTSD,
+    instrux_SUBPD,
+    instrux_SUBSD,
+    instrux_UCOMISD,
+    instrux_UNPCKHPD,
+    instrux_UNPCKLPD,
+    instrux_XORPD,
+    instrux_ADDSUBPD,
+    instrux_ADDSUBPS,
+    instrux_HADDPD,
+    instrux_HADDPS,
+    instrux_HSUBPD,
+    instrux_HSUBPS,
+    instrux_LDDQU,
+    instrux_MOVDDUP,
+    instrux_MOVSHDUP,
+    instrux_MOVSLDUP,
+    instrux_CLGI,
+    instrux_STGI,
+    instrux_VMCALL,
+    instrux_VMCLEAR,
+    instrux_VMFUNC,
+    instrux_VMLAUNCH,
+    instrux_VMLOAD,
+    instrux_VMMCALL,
+    instrux_VMPTRLD,
+    instrux_VMPTRST,
+    instrux_VMREAD,
+    instrux_VMRESUME,
+    instrux_VMRUN,
+    instrux_VMSAVE,
+    instrux_VMWRITE,
+    instrux_VMXOFF,
+    instrux_VMXON,
+    instrux_INVEPT,
+    instrux_INVVPID,
+    instrux_PVALIDATE,
+    instrux_RMPADJUST,
+    instrux_VMGEXIT,
+    instrux_PABSB,
+    instrux_PABSW,
+    instrux_PABSD,
+    instrux_PALIGNR,
+    instrux_PHADDW,
+    instrux_PHADDD,
+    instrux_PHADDSW,
+    instrux_PHSUBW,
+    instrux_PHSUBD,
+    instrux_PHSUBSW,
+    instrux_PMADDUBSW,
+    instrux_PMULHRSW,
+    instrux_PSHUFB,
+    instrux_PSIGNB,
+    instrux_PSIGNW,
+    instrux_PSIGND,
+    instrux_EXTRQ,
+    instrux_INSERTQ,
+    instrux_MOVNTSD,
+    instrux_MOVNTSS,
+    instrux_LZCNT,
+    instrux_BLENDPD,
+    instrux_BLENDPS,
+    instrux_BLENDVPD,
+    instrux_BLENDVPS,
+    instrux_DPPD,
+    instrux_DPPS,
+    instrux_EXTRACTPS,
+    instrux_INSERTPS,
+    instrux_MOVNTDQA,
+    instrux_MPSADBW,
+    instrux_PACKUSDW,
+    instrux_PBLENDVB,
+    instrux_PBLENDW,
+    instrux_PCMPEQQ,
+    instrux_PEXTRB,
+    instrux_PEXTRD,
+    instrux_PEXTRQ,
+    instrux_PHMINPOSUW,
+    instrux_PINSRB,
+    instrux_PINSRD,
+    instrux_PINSRQ,
+    instrux_PMAXSB,
+    instrux_PMAXSD,
+    instrux_PMAXUD,
+    instrux_PMAXUW,
+    instrux_PMINSB,
+    instrux_PMINSD,
+    instrux_PMINUD,
+    instrux_PMINUW,
+    instrux_PMOVSXBW,
+    instrux_PMOVSXBD,
+    instrux_PMOVSXBQ,
+    instrux_PMOVSXWD,
+    instrux_PMOVSXWQ,
+    instrux_PMOVSXDQ,
+    instrux_PMOVZXBW,
+    instrux_PMOVZXBD,
+    instrux_PMOVZXBQ,
+    instrux_PMOVZXWD,
+    instrux_PMOVZXWQ,
+    instrux_PMOVZXDQ,
+    instrux_PMULDQ,
+    instrux_PMULLD,
+    instrux_PTEST,
+    instrux_ROUNDPD,
+    instrux_ROUNDPS,
+    instrux_ROUNDSD,
+    instrux_ROUNDSS,
+    instrux_CRC32,
+    instrux_PCMPESTRI,
+    instrux_PCMPESTRM,
+    instrux_PCMPISTRI,
+    instrux_PCMPISTRM,
+    instrux_PCMPGTQ,
+    instrux_POPCNT,
+    instrux_GETSEC,
+    instrux_PFRCPV,
+    instrux_PFRSQRTV,
+    instrux_MOVBE,
+    instrux_AESENC,
+    instrux_AESENCLAST,
+    instrux_AESDEC,
+    instrux_AESDECLAST,
+    instrux_AESIMC,
+    instrux_AESKEYGENASSIST,
+    instrux_VAESENC,
+    instrux_VAESENCLAST,
+    instrux_VAESDEC,
+    instrux_VAESDECLAST,
+    instrux_VAESIMC,
+    instrux_VAESKEYGENASSIST,
+    instrux_VADDPD,
+    instrux_VADDPS,
+    instrux_VADDSD,
+    instrux_VADDSS,
+    instrux_VADDSUBPD,
+    instrux_VADDSUBPS,
+    instrux_VANDPD,
+    instrux_VANDPS,
+    instrux_VANDNPD,
+    instrux_VANDNPS,
+    instrux_VBLENDPD,
+    instrux_VBLENDPS,
+    instrux_VBLENDVPD,
+    instrux_VBLENDVPS,
+    instrux_VBROADCASTSS,
+    instrux_VBROADCASTSD,
+    instrux_VBROADCASTF128,
+    instrux_VCMPEQ_OSPD,
+    instrux_VCMPEQPD,
+    instrux_VCMPLT_OSPD,
+    instrux_VCMPLTPD,
+    instrux_VCMPLE_OSPD,
+    instrux_VCMPLEPD,
+    instrux_VCMPUNORD_QPD,
+    instrux_VCMPUNORDPD,
+    instrux_VCMPNEQ_UQPD,
+    instrux_VCMPNEQPD,
+    instrux_VCMPNLT_USPD,
+    instrux_VCMPNLTPD,
+    instrux_VCMPNLE_USPD,
+    instrux_VCMPNLEPD,
+    instrux_VCMPORD_QPD,
+    instrux_VCMPORDPD,
+    instrux_VCMPEQ_UQPD,
+    instrux_VCMPNGE_USPD,
+    instrux_VCMPNGEPD,
+    instrux_VCMPNGT_USPD,
+    instrux_VCMPNGTPD,
+    instrux_VCMPFALSE_OQPD,
+    instrux_VCMPFALSEPD,
+    instrux_VCMPNEQ_OQPD,
+    instrux_VCMPGE_OSPD,
+    instrux_VCMPGEPD,
+    instrux_VCMPGT_OSPD,
+    instrux_VCMPGTPD,
+    instrux_VCMPTRUE_UQPD,
+    instrux_VCMPTRUEPD,
+    instrux_VCMPLT_OQPD,
+    instrux_VCMPLE_OQPD,
+    instrux_VCMPUNORD_SPD,
+    instrux_VCMPNEQ_USPD,
+    instrux_VCMPNLT_UQPD,
+    instrux_VCMPNLE_UQPD,
+    instrux_VCMPORD_SPD,
+    instrux_VCMPEQ_USPD,
+    instrux_VCMPNGE_UQPD,
+    instrux_VCMPNGT_UQPD,
+    instrux_VCMPFALSE_OSPD,
+    instrux_VCMPNEQ_OSPD,
+    instrux_VCMPGE_OQPD,
+    instrux_VCMPGT_OQPD,
+    instrux_VCMPTRUE_USPD,
+    instrux_VCMPPD,
+    instrux_VCMPEQ_OSPS,
+    instrux_VCMPEQPS,
+    instrux_VCMPLT_OSPS,
+    instrux_VCMPLTPS,
+    instrux_VCMPLE_OSPS,
+    instrux_VCMPLEPS,
+    instrux_VCMPUNORD_QPS,
+    instrux_VCMPUNORDPS,
+    instrux_VCMPNEQ_UQPS,
+    instrux_VCMPNEQPS,
+    instrux_VCMPNLT_USPS,
+    instrux_VCMPNLTPS,
+    instrux_VCMPNLE_USPS,
+    instrux_VCMPNLEPS,
+    instrux_VCMPORD_QPS,
+    instrux_VCMPORDPS,
+    instrux_VCMPEQ_UQPS,
+    instrux_VCMPNGE_USPS,
+    instrux_VCMPNGEPS,
+    instrux_VCMPNGT_USPS,
+    instrux_VCMPNGTPS,
+    instrux_VCMPFALSE_OQPS,
+    instrux_VCMPFALSEPS,
+    instrux_VCMPNEQ_OQPS,
+    instrux_VCMPGE_OSPS,
+    instrux_VCMPGEPS,
+    instrux_VCMPGT_OSPS,
+    instrux_VCMPGTPS,
+    instrux_VCMPTRUE_UQPS,
+    instrux_VCMPTRUEPS,
+    instrux_VCMPLT_OQPS,
+    instrux_VCMPLE_OQPS,
+    instrux_VCMPUNORD_SPS,
+    instrux_VCMPNEQ_USPS,
+    instrux_VCMPNLT_UQPS,
+    instrux_VCMPNLE_UQPS,
+    instrux_VCMPORD_SPS,
+    instrux_VCMPEQ_USPS,
+    instrux_VCMPNGE_UQPS,
+    instrux_VCMPNGT_UQPS,
+    instrux_VCMPFALSE_OSPS,
+    instrux_VCMPNEQ_OSPS,
+    instrux_VCMPGE_OQPS,
+    instrux_VCMPGT_OQPS,
+    instrux_VCMPTRUE_USPS,
+    instrux_VCMPPS,
+    instrux_VCMPEQ_OSSD,
+    instrux_VCMPEQSD,
+    instrux_VCMPLT_OSSD,
+    instrux_VCMPLTSD,
+    instrux_VCMPLE_OSSD,
+    instrux_VCMPLESD,
+    instrux_VCMPUNORD_QSD,
+    instrux_VCMPUNORDSD,
+    instrux_VCMPNEQ_UQSD,
+    instrux_VCMPNEQSD,
+    instrux_VCMPNLT_USSD,
+    instrux_VCMPNLTSD,
+    instrux_VCMPNLE_USSD,
+    instrux_VCMPNLESD,
+    instrux_VCMPORD_QSD,
+    instrux_VCMPORDSD,
+    instrux_VCMPEQ_UQSD,
+    instrux_VCMPNGE_USSD,
+    instrux_VCMPNGESD,
+    instrux_VCMPNGT_USSD,
+    instrux_VCMPNGTSD,
+    instrux_VCMPFALSE_OQSD,
+    instrux_VCMPFALSESD,
+    instrux_VCMPNEQ_OQSD,
+    instrux_VCMPGE_OSSD,
+    instrux_VCMPGESD,
+    instrux_VCMPGT_OSSD,
+    instrux_VCMPGTSD,
+    instrux_VCMPTRUE_UQSD,
+    instrux_VCMPTRUESD,
+    instrux_VCMPLT_OQSD,
+    instrux_VCMPLE_OQSD,
+    instrux_VCMPUNORD_SSD,
+    instrux_VCMPNEQ_USSD,
+    instrux_VCMPNLT_UQSD,
+    instrux_VCMPNLE_UQSD,
+    instrux_VCMPORD_SSD,
+    instrux_VCMPEQ_USSD,
+    instrux_VCMPNGE_UQSD,
+    instrux_VCMPNGT_UQSD,
+    instrux_VCMPFALSE_OSSD,
+    instrux_VCMPNEQ_OSSD,
+    instrux_VCMPGE_OQSD,
+    instrux_VCMPGT_OQSD,
+    instrux_VCMPTRUE_USSD,
+    instrux_VCMPSD,
+    instrux_VCMPEQ_OSSS,
+    instrux_VCMPEQSS,
+    instrux_VCMPLT_OSSS,
+    instrux_VCMPLTSS,
+    instrux_VCMPLE_OSSS,
+    instrux_VCMPLESS,
+    instrux_VCMPUNORD_QSS,
+    instrux_VCMPUNORDSS,
+    instrux_VCMPNEQ_UQSS,
+    instrux_VCMPNEQSS,
+    instrux_VCMPNLT_USSS,
+    instrux_VCMPNLTSS,
+    instrux_VCMPNLE_USSS,
+    instrux_VCMPNLESS,
+    instrux_VCMPORD_QSS,
+    instrux_VCMPORDSS,
+    instrux_VCMPEQ_UQSS,
+    instrux_VCMPNGE_USSS,
+    instrux_VCMPNGESS,
+    instrux_VCMPNGT_USSS,
+    instrux_VCMPNGTSS,
+    instrux_VCMPFALSE_OQSS,
+    instrux_VCMPFALSESS,
+    instrux_VCMPNEQ_OQSS,
+    instrux_VCMPGE_OSSS,
+    instrux_VCMPGESS,
+    instrux_VCMPGT_OSSS,
+    instrux_VCMPGTSS,
+    instrux_VCMPTRUE_UQSS,
+    instrux_VCMPTRUESS,
+    instrux_VCMPLT_OQSS,
+    instrux_VCMPLE_OQSS,
+    instrux_VCMPUNORD_SSS,
+    instrux_VCMPNEQ_USSS,
+    instrux_VCMPNLT_UQSS,
+    instrux_VCMPNLE_UQSS,
+    instrux_VCMPORD_SSS,
+    instrux_VCMPEQ_USSS,
+    instrux_VCMPNGE_UQSS,
+    instrux_VCMPNGT_UQSS,
+    instrux_VCMPFALSE_OSSS,
+    instrux_VCMPNEQ_OSSS,
+    instrux_VCMPGE_OQSS,
+    instrux_VCMPGT_OQSS,
+    instrux_VCMPTRUE_USSS,
+    instrux_VCMPSS,
+    instrux_VCOMISD,
+    instrux_VCOMISS,
+    instrux_VCVTDQ2PD,
+    instrux_VCVTDQ2PS,
+    instrux_VCVTPD2DQ,
+    instrux_VCVTPD2PS,
+    instrux_VCVTPS2DQ,
+    instrux_VCVTPS2PD,
+    instrux_VCVTSD2SI,
+    instrux_VCVTSD2SS,
+    instrux_VCVTSI2SD,
+    instrux_VCVTSI2SS,
+    instrux_VCVTSS2SD,
+    instrux_VCVTSS2SI,
+    instrux_VCVTTPD2DQ,
+    instrux_VCVTTPS2DQ,
+    instrux_VCVTTSD2SI,
+    instrux_VCVTTSS2SI,
+    instrux_VDIVPD,
+    instrux_VDIVPS,
+    instrux_VDIVSD,
+    instrux_VDIVSS,
+    instrux_VDPPD,
+    instrux_VDPPS,
+    instrux_VEXTRACTF128,
+    instrux_VEXTRACTPS,
+    instrux_VHADDPD,
+    instrux_VHADDPS,
+    instrux_VHSUBPD,
+    instrux_VHSUBPS,
+    instrux_VINSERTF128,
+    instrux_VINSERTPS,
+    instrux_VLDDQU,
+    instrux_VLDQQU,
+    instrux_VLDMXCSR,
+    instrux_VMASKMOVDQU,
+    instrux_VMASKMOVPS,
+    instrux_VMASKMOVPD,
+    instrux_VMAXPD,
+    instrux_VMAXPS,
+    instrux_VMAXSD,
+    instrux_VMAXSS,
+    instrux_VMINPD,
+    instrux_VMINPS,
+    instrux_VMINSD,
+    instrux_VMINSS,
+    instrux_VMOVAPD,
+    instrux_VMOVAPS,
+    instrux_VMOVD,
+    instrux_VMOVQ,
+    instrux_VMOVDDUP,
+    instrux_VMOVDQA,
+    instrux_VMOVQQA,
+    instrux_VMOVDQU,
+    instrux_VMOVQQU,
+    instrux_VMOVHLPS,
+    instrux_VMOVHPD,
+    instrux_VMOVHPS,
+    instrux_VMOVLHPS,
+    instrux_VMOVLPD,
+    instrux_VMOVLPS,
+    instrux_VMOVMSKPD,
+    instrux_VMOVMSKPS,
+    instrux_VMOVNTDQ,
+    instrux_VMOVNTQQ,
+    instrux_VMOVNTDQA,
+    instrux_VMOVNTPD,
+    instrux_VMOVNTPS,
+    instrux_VMOVSD,
+    instrux_VMOVSHDUP,
+    instrux_VMOVSLDUP,
+    instrux_VMOVSS,
+    instrux_VMOVUPD,
+    instrux_VMOVUPS,
+    instrux_VMPSADBW,
+    instrux_VMULPD,
+    instrux_VMULPS,
+    instrux_VMULSD,
+    instrux_VMULSS,
+    instrux_VORPD,
+    instrux_VORPS,
+    instrux_VPABSB,
+    instrux_VPABSW,
+    instrux_VPABSD,
+    instrux_VPACKSSWB,
+    instrux_VPACKSSDW,
+    instrux_VPACKUSWB,
+    instrux_VPACKUSDW,
+    instrux_VPADDB,
+    instrux_VPADDW,
+    instrux_VPADDD,
+    instrux_VPADDQ,
+    instrux_VPADDSB,
+    instrux_VPADDSW,
+    instrux_VPADDUSB,
+    instrux_VPADDUSW,
+    instrux_VPALIGNR,
+    instrux_VPAND,
+    instrux_VPANDN,
+    instrux_VPAVGB,
+    instrux_VPAVGW,
+    instrux_VPBLENDVB,
+    instrux_VPBLENDW,
+    instrux_VPCMPESTRI,
+    instrux_VPCMPESTRM,
+    instrux_VPCMPISTRI,
+    instrux_VPCMPISTRM,
+    instrux_VPCMPEQB,
+    instrux_VPCMPEQW,
+    instrux_VPCMPEQD,
+    instrux_VPCMPEQQ,
+    instrux_VPCMPGTB,
+    instrux_VPCMPGTW,
+    instrux_VPCMPGTD,
+    instrux_VPCMPGTQ,
+    instrux_VPERMILPD,
+    instrux_VPERMILPS,
+    instrux_VPERM2F128,
+    instrux_VPEXTRB,
+    instrux_VPEXTRW,
+    instrux_VPEXTRD,
+    instrux_VPEXTRQ,
+    instrux_VPHADDW,
+    instrux_VPHADDD,
+    instrux_VPHADDSW,
+    instrux_VPHMINPOSUW,
+    instrux_VPHSUBW,
+    instrux_VPHSUBD,
+    instrux_VPHSUBSW,
+    instrux_VPINSRB,
+    instrux_VPINSRW,
+    instrux_VPINSRD,
+    instrux_VPINSRQ,
+    instrux_VPMADDWD,
+    instrux_VPMADDUBSW,
+    instrux_VPMAXSB,
+    instrux_VPMAXSW,
+    instrux_VPMAXSD,
+    instrux_VPMAXUB,
+    instrux_VPMAXUW,
+    instrux_VPMAXUD,
+    instrux_VPMINSB,
+    instrux_VPMINSW,
+    instrux_VPMINSD,
+    instrux_VPMINUB,
+    instrux_VPMINUW,
+    instrux_VPMINUD,
+    instrux_VPMOVMSKB,
+    instrux_VPMOVSXBW,
+    instrux_VPMOVSXBD,
+    instrux_VPMOVSXBQ,
+    instrux_VPMOVSXWD,
+    instrux_VPMOVSXWQ,
+    instrux_VPMOVSXDQ,
+    instrux_VPMOVZXBW,
+    instrux_VPMOVZXBD,
+    instrux_VPMOVZXBQ,
+    instrux_VPMOVZXWD,
+    instrux_VPMOVZXWQ,
+    instrux_VPMOVZXDQ,
+    instrux_VPMULHUW,
+    instrux_VPMULHRSW,
+    instrux_VPMULHW,
+    instrux_VPMULLW,
+    instrux_VPMULLD,
+    instrux_VPMULUDQ,
+    instrux_VPMULDQ,
+    instrux_VPOR,
+    instrux_VPSADBW,
+    instrux_VPSHUFB,
+    instrux_VPSHUFD,
+    instrux_VPSHUFHW,
+    instrux_VPSHUFLW,
+    instrux_VPSIGNB,
+    instrux_VPSIGNW,
+    instrux_VPSIGND,
+    instrux_VPSLLDQ,
+    instrux_VPSRLDQ,
+    instrux_VPSLLW,
+    instrux_VPSLLD,
+    instrux_VPSLLQ,
+    instrux_VPSRAW,
+    instrux_VPSRAD,
+    instrux_VPSRLW,
+    instrux_VPSRLD,
+    instrux_VPSRLQ,
+    instrux_VPTEST,
+    instrux_VPSUBB,
+    instrux_VPSUBW,
+    instrux_VPSUBD,
+    instrux_VPSUBQ,
+    instrux_VPSUBSB,
+    instrux_VPSUBSW,
+    instrux_VPSUBUSB,
+    instrux_VPSUBUSW,
+    instrux_VPUNPCKHBW,
+    instrux_VPUNPCKHWD,
+    instrux_VPUNPCKHDQ,
+    instrux_VPUNPCKHQDQ,
+    instrux_VPUNPCKLBW,
+    instrux_VPUNPCKLWD,
+    instrux_VPUNPCKLDQ,
+    instrux_VPUNPCKLQDQ,
+    instrux_VPXOR,
+    instrux_VRCPPS,
+    instrux_VRCPSS,
+    instrux_VRSQRTPS,
+    instrux_VRSQRTSS,
+    instrux_VROUNDPD,
+    instrux_VROUNDPS,
+    instrux_VROUNDSD,
+    instrux_VROUNDSS,
+    instrux_VSHUFPD,
+    instrux_VSHUFPS,
+    instrux_VSQRTPD,
+    instrux_VSQRTPS,
+    instrux_VSQRTSD,
+    instrux_VSQRTSS,
+    instrux_VSTMXCSR,
+    instrux_VSUBPD,
+    instrux_VSUBPS,
+    instrux_VSUBSD,
+    instrux_VSUBSS,
+    instrux_VTESTPS,
+    instrux_VTESTPD,
+    instrux_VUCOMISD,
+    instrux_VUCOMISS,
+    instrux_VUNPCKHPD,
+    instrux_VUNPCKHPS,
+    instrux_VUNPCKLPD,
+    instrux_VUNPCKLPS,
+    instrux_VXORPD,
+    instrux_VXORPS,
+    instrux_VZEROALL,
+    instrux_VZEROUPPER,
+    instrux_PCLMULLQLQDQ,
+    instrux_PCLMULHQLQDQ,
+    instrux_PCLMULLQHQDQ,
+    instrux_PCLMULHQHQDQ,
+    instrux_PCLMULQDQ,
+    instrux_VPCLMULLQLQDQ,
+    instrux_VPCLMULHQLQDQ,
+    instrux_VPCLMULLQHQDQ,
+    instrux_VPCLMULHQHQDQ,
+    instrux_VPCLMULQDQ,
+    instrux_VFMADD132PS,
+    instrux_VFMADD132PD,
+    instrux_VFMADD312PS,
+    instrux_VFMADD312PD,
+    instrux_VFMADD213PS,
+    instrux_VFMADD213PD,
+    instrux_VFMADD123PS,
+    instrux_VFMADD123PD,
+    instrux_VFMADD231PS,
+    instrux_VFMADD231PD,
+    instrux_VFMADD321PS,
+    instrux_VFMADD321PD,
+    instrux_VFMADDSUB132PS,
+    instrux_VFMADDSUB132PD,
+    instrux_VFMADDSUB312PS,
+    instrux_VFMADDSUB312PD,
+    instrux_VFMADDSUB213PS,
+    instrux_VFMADDSUB213PD,
+    instrux_VFMADDSUB123PS,
+    instrux_VFMADDSUB123PD,
+    instrux_VFMADDSUB231PS,
+    instrux_VFMADDSUB231PD,
+    instrux_VFMADDSUB321PS,
+    instrux_VFMADDSUB321PD,
+    instrux_VFMSUB132PS,
+    instrux_VFMSUB132PD,
+    instrux_VFMSUB312PS,
+    instrux_VFMSUB312PD,
+    instrux_VFMSUB213PS,
+    instrux_VFMSUB213PD,
+    instrux_VFMSUB123PS,
+    instrux_VFMSUB123PD,
+    instrux_VFMSUB231PS,
+    instrux_VFMSUB231PD,
+    instrux_VFMSUB321PS,
+    instrux_VFMSUB321PD,
+    instrux_VFMSUBADD132PS,
+    instrux_VFMSUBADD132PD,
+    instrux_VFMSUBADD312PS,
+    instrux_VFMSUBADD312PD,
+    instrux_VFMSUBADD213PS,
+    instrux_VFMSUBADD213PD,
+    instrux_VFMSUBADD123PS,
+    instrux_VFMSUBADD123PD,
+    instrux_VFMSUBADD231PS,
+    instrux_VFMSUBADD231PD,
+    instrux_VFMSUBADD321PS,
+    instrux_VFMSUBADD321PD,
+    instrux_VFNMADD132PS,
+    instrux_VFNMADD132PD,
+    instrux_VFNMADD312PS,
+    instrux_VFNMADD312PD,
+    instrux_VFNMADD213PS,
+    instrux_VFNMADD213PD,
+    instrux_VFNMADD123PS,
+    instrux_VFNMADD123PD,
+    instrux_VFNMADD231PS,
+    instrux_VFNMADD231PD,
+    instrux_VFNMADD321PS,
+    instrux_VFNMADD321PD,
+    instrux_VFNMSUB132PS,
+    instrux_VFNMSUB132PD,
+    instrux_VFNMSUB312PS,
+    instrux_VFNMSUB312PD,
+    instrux_VFNMSUB213PS,
+    instrux_VFNMSUB213PD,
+    instrux_VFNMSUB123PS,
+    instrux_VFNMSUB123PD,
+    instrux_VFNMSUB231PS,
+    instrux_VFNMSUB231PD,
+    instrux_VFNMSUB321PS,
+    instrux_VFNMSUB321PD,
+    instrux_VFMADD132SS,
+    instrux_VFMADD132SD,
+    instrux_VFMADD312SS,
+    instrux_VFMADD312SD,
+    instrux_VFMADD213SS,
+    instrux_VFMADD213SD,
+    instrux_VFMADD123SS,
+    instrux_VFMADD123SD,
+    instrux_VFMADD231SS,
+    instrux_VFMADD231SD,
+    instrux_VFMADD321SS,
+    instrux_VFMADD321SD,
+    instrux_VFMSUB132SS,
+    instrux_VFMSUB132SD,
+    instrux_VFMSUB312SS,
+    instrux_VFMSUB312SD,
+    instrux_VFMSUB213SS,
+    instrux_VFMSUB213SD,
+    instrux_VFMSUB123SS,
+    instrux_VFMSUB123SD,
+    instrux_VFMSUB231SS,
+    instrux_VFMSUB231SD,
+    instrux_VFMSUB321SS,
+    instrux_VFMSUB321SD,
+    instrux_VFNMADD132SS,
+    instrux_VFNMADD132SD,
+    instrux_VFNMADD312SS,
+    instrux_VFNMADD312SD,
+    instrux_VFNMADD213SS,
+    instrux_VFNMADD213SD,
+    instrux_VFNMADD123SS,
+    instrux_VFNMADD123SD,
+    instrux_VFNMADD231SS,
+    instrux_VFNMADD231SD,
+    instrux_VFNMADD321SS,
+    instrux_VFNMADD321SD,
+    instrux_VFNMSUB132SS,
+    instrux_VFNMSUB132SD,
+    instrux_VFNMSUB312SS,
+    instrux_VFNMSUB312SD,
+    instrux_VFNMSUB213SS,
+    instrux_VFNMSUB213SD,
+    instrux_VFNMSUB123SS,
+    instrux_VFNMSUB123SD,
+    instrux_VFNMSUB231SS,
+    instrux_VFNMSUB231SD,
+    instrux_VFNMSUB321SS,
+    instrux_VFNMSUB321SD,
+    instrux_RDFSBASE,
+    instrux_RDGSBASE,
+    instrux_RDRAND,
+    instrux_WRFSBASE,
+    instrux_WRGSBASE,
+    instrux_VCVTPH2PS,
+    instrux_VCVTPS2PH,
+    instrux_ADCX,
+    instrux_ADOX,
+    instrux_RDSEED,
+    instrux_CLAC,
+    instrux_STAC,
+    instrux_XSTORE,
+    instrux_XCRYPTECB,
+    instrux_XCRYPTCBC,
+    instrux_XCRYPTCTR,
+    instrux_XCRYPTCFB,
+    instrux_XCRYPTOFB,
+    instrux_MONTMUL,
+    instrux_XSHA1,
+    instrux_XSHA256,
+    instrux_LLWPCB,
+    instrux_SLWPCB,
+    instrux_LWPVAL,
+    instrux_LWPINS,
+    instrux_VFMADDPD,
+    instrux_VFMADDPS,
+    instrux_VFMADDSD,
+    instrux_VFMADDSS,
+    instrux_VFMADDSUBPD,
+    instrux_VFMADDSUBPS,
+    instrux_VFMSUBADDPD,
+    instrux_VFMSUBADDPS,
+    instrux_VFMSUBPD,
+    instrux_VFMSUBPS,
+    instrux_VFMSUBSD,
+    instrux_VFMSUBSS,
+    instrux_VFNMADDPD,
+    instrux_VFNMADDPS,
+    instrux_VFNMADDSD,
+    instrux_VFNMADDSS,
+    instrux_VFNMSUBPD,
+    instrux_VFNMSUBPS,
+    instrux_VFNMSUBSD,
+    instrux_VFNMSUBSS,
+    instrux_VFRCZPD,
+    instrux_VFRCZPS,
+    instrux_VFRCZSD,
+    instrux_VFRCZSS,
+    instrux_VPCMOV,
+    instrux_VPCOMB,
+    instrux_VPCOMD,
+    instrux_VPCOMQ,
+    instrux_VPCOMUB,
+    instrux_VPCOMUD,
+    instrux_VPCOMUQ,
+    instrux_VPCOMUW,
+    instrux_VPCOMW,
+    instrux_VPHADDBD,
+    instrux_VPHADDBQ,
+    instrux_VPHADDBW,
+    instrux_VPHADDDQ,
+    instrux_VPHADDUBD,
+    instrux_VPHADDUBQ,
+    instrux_VPHADDUBW,
+    instrux_VPHADDUDQ,
+    instrux_VPHADDUWD,
+    instrux_VPHADDUWQ,
+    instrux_VPHADDWD,
+    instrux_VPHADDWQ,
+    instrux_VPHSUBBW,
+    instrux_VPHSUBDQ,
+    instrux_VPHSUBWD,
+    instrux_VPMACSDD,
+    instrux_VPMACSDQH,
+    instrux_VPMACSDQL,
+    instrux_VPMACSSDD,
+    instrux_VPMACSSDQH,
+    instrux_VPMACSSDQL,
+    instrux_VPMACSSWD,
+    instrux_VPMACSSWW,
+    instrux_VPMACSWD,
+    instrux_VPMACSWW,
+    instrux_VPMADCSSWD,
+    instrux_VPMADCSWD,
+    instrux_VPPERM,
+    instrux_VPROTB,
+    instrux_VPROTD,
+    instrux_VPROTQ,
+    instrux_VPROTW,
+    instrux_VPSHAB,
+    instrux_VPSHAD,
+    instrux_VPSHAQ,
+    instrux_VPSHAW,
+    instrux_VPSHLB,
+    instrux_VPSHLD,
+    instrux_VPSHLQ,
+    instrux_VPSHLW,
+    instrux_VBROADCASTI128,
+    instrux_VPBLENDD,
+    instrux_VPBROADCASTB,
+    instrux_VPBROADCASTW,
+    instrux_VPBROADCASTD,
+    instrux_VPBROADCASTQ,
+    instrux_VPERMD,
+    instrux_VPERMPD,
+    instrux_VPERMPS,
+    instrux_VPERMQ,
+    instrux_VPERM2I128,
+    instrux_VEXTRACTI128,
+    instrux_VINSERTI128,
+    instrux_VPMASKMOVD,
+    instrux_VPMASKMOVQ,
+    instrux_VPSLLVD,
+    instrux_VPSLLVQ,
+    instrux_VPSRAVD,
+    instrux_VPSRLVD,
+    instrux_VPSRLVQ,
+    instrux_VGATHERDPD,
+    instrux_VGATHERQPD,
+    instrux_VGATHERDPS,
+    instrux_VGATHERQPS,
+    instrux_VPGATHERDD,
+    instrux_VPGATHERQD,
+    instrux_VPGATHERDQ,
+    instrux_VPGATHERQQ,
+    instrux_XABORT,
+    instrux_XBEGIN,
+    instrux_XEND,
+    instrux_XTEST,
+    instrux_ANDN,
+    instrux_BEXTR,
+    instrux_BLCI,
+    instrux_BLCIC,
+    instrux_BLSI,
+    instrux_BLSIC,
+    instrux_BLCFILL,
+    instrux_BLSFILL,
+    instrux_BLCMSK,
+    instrux_BLSMSK,
+    instrux_BLSR,
+    instrux_BLCS,
+    instrux_BZHI,
+    instrux_MULX,
+    instrux_PDEP,
+    instrux_PEXT,
+    instrux_RORX,
+    instrux_SARX,
+    instrux_SHLX,
+    instrux_SHRX,
+    instrux_TZCNT,
+    instrux_TZMSK,
+    instrux_T1MSKC,
+    instrux_PREFETCHWT1,
+    instrux_BNDMK,
+    instrux_BNDCL,
+    instrux_BNDCU,
+    instrux_BNDCN,
+    instrux_BNDMOV,
+    instrux_BNDLDX,
+    instrux_BNDSTX,
+    instrux_SHA1MSG1,
+    instrux_SHA1MSG2,
+    instrux_SHA1NEXTE,
+    instrux_SHA1RNDS4,
+    instrux_SHA256MSG1,
+    instrux_SHA256MSG2,
+    instrux_SHA256RNDS2,
+    instrux_VBCSTNEBF16PS,
+    instrux_VBCSTNESH2PS,
+    instrux_VCVTNEEBF162PS,
+    instrux_VCVTNEEPH2PS,
+    instrux_VCVTNEOBF162PS,
+    instrux_VCVTNEOPH2PS,
+    instrux_VCVTNEPS2BF16,
+    instrux_VPDPBSSD,
+    instrux_VPDPBSSDS,
+    instrux_VPDPBSUD,
+    instrux_VPDPBSUDS,
+    instrux_VPDPBUUD,
+    instrux_VPDPBUUDS,
+    instrux_VPMADD52HUQ,
+    instrux_VPMADD52LUQ,
+    instrux_KADDB,
+    instrux_KADDD,
+    instrux_KADDQ,
+    instrux_KADDW,
+    instrux_KANDB,
+    instrux_KANDD,
+    instrux_KANDNB,
+    instrux_KANDND,
+    instrux_KANDNQ,
+    instrux_KANDNW,
+    instrux_KANDQ,
+    instrux_KANDW,
+    instrux_KMOVB,
+    instrux_KMOVD,
+    instrux_KMOVQ,
+    instrux_KMOVW,
+    instrux_KNOTB,
+    instrux_KNOTD,
+    instrux_KNOTQ,
+    instrux_KNOTW,
+    instrux_KORB,
+    instrux_KORD,
+    instrux_KORQ,
+    instrux_KORW,
+    instrux_KORTESTB,
+    instrux_KORTESTD,
+    instrux_KORTESTQ,
+    instrux_KORTESTW,
+    instrux_KSHIFTLB,
+    instrux_KSHIFTLD,
+    instrux_KSHIFTLQ,
+    instrux_KSHIFTLW,
+    instrux_KSHIFTRB,
+    instrux_KSHIFTRD,
+    instrux_KSHIFTRQ,
+    instrux_KSHIFTRW,
+    instrux_KTESTB,
+    instrux_KTESTD,
+    instrux_KTESTQ,
+    instrux_KTESTW,
+    instrux_KUNPCKBW,
+    instrux_KUNPCKDQ,
+    instrux_KUNPCKWD,
+    instrux_KXNORB,
+    instrux_KXNORD,
+    instrux_KXNORQ,
+    instrux_KXNORW,
+    instrux_KXORB,
+    instrux_KXORD,
+    instrux_KXORQ,
+    instrux_KXORW,
+    instrux_KADD,
+    instrux_KAND,
+    instrux_KANDN,
+    instrux_KMOV,
+    instrux_KNOT,
+    instrux_KOR,
+    instrux_KORTEST,
+    instrux_KSHIFTL,
+    instrux_KSHIFTR,
+    instrux_KTEST,
+    instrux_KUNPCK,
+    instrux_KXNOR,
+    instrux_KXOR,
+    instrux_VALIGND,
+    instrux_VALIGNQ,
+    instrux_VBLENDMPD,
+    instrux_VBLENDMPS,
+    instrux_VBROADCASTF32X2,
+    instrux_VBROADCASTF32X4,
+    instrux_VBROADCASTF32X8,
+    instrux_VBROADCASTF64X2,
+    instrux_VBROADCASTF64X4,
+    instrux_VBROADCASTI32X2,
+    instrux_VBROADCASTI32X4,
+    instrux_VBROADCASTI32X8,
+    instrux_VBROADCASTI64X2,
+    instrux_VBROADCASTI64X4,
+    instrux_VCMPEQ_OQPD,
+    instrux_VCMPEQ_OQPS,
+    instrux_VCMPEQ_OQSD,
+    instrux_VCMPEQ_OQSS,
+    instrux_VCOMPRESSPD,
+    instrux_VCOMPRESSPS,
+    instrux_VCVTPD2QQ,
+    instrux_VCVTPD2UDQ,
+    instrux_VCVTPD2UQQ,
+    instrux_VCVTPS2QQ,
+    instrux_VCVTPS2UDQ,
+    instrux_VCVTPS2UQQ,
+    instrux_VCVTQQ2PD,
+    instrux_VCVTQQ2PS,
+    instrux_VCVTSD2USI,
+    instrux_VCVTSS2USI,
+    instrux_VCVTTPD2QQ,
+    instrux_VCVTTPD2UDQ,
+    instrux_VCVTTPD2UQQ,
+    instrux_VCVTTPS2QQ,
+    instrux_VCVTTPS2UDQ,
+    instrux_VCVTTPS2UQQ,
+    instrux_VCVTTSD2USI,
+    instrux_VCVTTSS2USI,
+    instrux_VCVTUDQ2PD,
+    instrux_VCVTUDQ2PS,
+    instrux_VCVTUQQ2PD,
+    instrux_VCVTUQQ2PS,
+    instrux_VCVTUSI2SD,
+    instrux_VCVTUSI2SS,
+    instrux_VDBPSADBW,
+    instrux_VEXP2PD,
+    instrux_VEXP2PS,
+    instrux_VEXPANDPD,
+    instrux_VEXPANDPS,
+    instrux_VEXTRACTF32X4,
+    instrux_VEXTRACTF32X8,
+    instrux_VEXTRACTF64X2,
+    instrux_VEXTRACTF64X4,
+    instrux_VEXTRACTI32X4,
+    instrux_VEXTRACTI32X8,
+    instrux_VEXTRACTI64X2,
+    instrux_VEXTRACTI64X4,
+    instrux_VFIXUPIMMPD,
+    instrux_VFIXUPIMMPS,
+    instrux_VFIXUPIMMSD,
+    instrux_VFIXUPIMMSS,
+    instrux_VFPCLASSPD,
+    instrux_VFPCLASSPS,
+    instrux_VFPCLASSSD,
+    instrux_VFPCLASSSS,
+    instrux_VGATHERPF0DPD,
+    instrux_VGATHERPF0DPS,
+    instrux_VGATHERPF0QPD,
+    instrux_VGATHERPF0QPS,
+    instrux_VGATHERPF1DPD,
+    instrux_VGATHERPF1DPS,
+    instrux_VGATHERPF1QPD,
+    instrux_VGATHERPF1QPS,
+    instrux_VGETEXPPD,
+    instrux_VGETEXPPS,
+    instrux_VGETEXPSD,
+    instrux_VGETEXPSS,
+    instrux_VGETMANTPD,
+    instrux_VGETMANTPS,
+    instrux_VGETMANTSD,
+    instrux_VGETMANTSS,
+    instrux_VINSERTF32X4,
+    instrux_VINSERTF32X8,
+    instrux_VINSERTF64X2,
+    instrux_VINSERTF64X4,
+    instrux_VINSERTI32X4,
+    instrux_VINSERTI32X8,
+    instrux_VINSERTI64X2,
+    instrux_VINSERTI64X4,
+    instrux_VMOVDQA32,
+    instrux_VMOVDQA64,
+    instrux_VMOVDQU16,
+    instrux_VMOVDQU32,
+    instrux_VMOVDQU64,
+    instrux_VMOVDQU8,
+    instrux_VPABSQ,
+    instrux_VPANDD,
+    instrux_VPANDND,
+    instrux_VPANDNQ,
+    instrux_VPANDQ,
+    instrux_VPBLENDMB,
+    instrux_VPBLENDMD,
+    instrux_VPBLENDMQ,
+    instrux_VPBLENDMW,
+    instrux_VPBROADCASTMB2Q,
+    instrux_VPBROADCASTMW2D,
+    instrux_VPCMPEQUB,
+    instrux_VPCMPEQUD,
+    instrux_VPCMPEQUQ,
+    instrux_VPCMPEQUW,
+    instrux_VPCMPGEB,
+    instrux_VPCMPGED,
+    instrux_VPCMPGEQ,
+    instrux_VPCMPGEUB,
+    instrux_VPCMPGEUD,
+    instrux_VPCMPGEUQ,
+    instrux_VPCMPGEUW,
+    instrux_VPCMPGEW,
+    instrux_VPCMPGTUB,
+    instrux_VPCMPGTUD,
+    instrux_VPCMPGTUQ,
+    instrux_VPCMPGTUW,
+    instrux_VPCMPLEB,
+    instrux_VPCMPLED,
+    instrux_VPCMPLEQ,
+    instrux_VPCMPLEUB,
+    instrux_VPCMPLEUD,
+    instrux_VPCMPLEUQ,
+    instrux_VPCMPLEUW,
+    instrux_VPCMPLEW,
+    instrux_VPCMPLTB,
+    instrux_VPCMPLTD,
+    instrux_VPCMPLTQ,
+    instrux_VPCMPLTUB,
+    instrux_VPCMPLTUD,
+    instrux_VPCMPLTUQ,
+    instrux_VPCMPLTUW,
+    instrux_VPCMPLTW,
+    instrux_VPCMPNEQB,
+    instrux_VPCMPNEQD,
+    instrux_VPCMPNEQQ,
+    instrux_VPCMPNEQUB,
+    instrux_VPCMPNEQUD,
+    instrux_VPCMPNEQUQ,
+    instrux_VPCMPNEQUW,
+    instrux_VPCMPNEQW,
+    instrux_VPCMPNGTB,
+    instrux_VPCMPNGTD,
+    instrux_VPCMPNGTQ,
+    instrux_VPCMPNGTUB,
+    instrux_VPCMPNGTUD,
+    instrux_VPCMPNGTUQ,
+    instrux_VPCMPNGTUW,
+    instrux_VPCMPNGTW,
+    instrux_VPCMPNLEB,
+    instrux_VPCMPNLED,
+    instrux_VPCMPNLEQ,
+    instrux_VPCMPNLEUB,
+    instrux_VPCMPNLEUD,
+    instrux_VPCMPNLEUQ,
+    instrux_VPCMPNLEUW,
+    instrux_VPCMPNLEW,
+    instrux_VPCMPNLTB,
+    instrux_VPCMPNLTD,
+    instrux_VPCMPNLTQ,
+    instrux_VPCMPNLTUB,
+    instrux_VPCMPNLTUD,
+    instrux_VPCMPNLTUQ,
+    instrux_VPCMPNLTUW,
+    instrux_VPCMPNLTW,
+    instrux_VPCMPB,
+    instrux_VPCMPD,
+    instrux_VPCMPQ,
+    instrux_VPCMPUB,
+    instrux_VPCMPUD,
+    instrux_VPCMPUQ,
+    instrux_VPCMPUW,
+    instrux_VPCMPW,
+    instrux_VPCOMPRESSD,
+    instrux_VPCOMPRESSQ,
+    instrux_VPCONFLICTD,
+    instrux_VPCONFLICTQ,
+    instrux_VPERMB,
+    instrux_VPERMI2B,
+    instrux_VPERMI2D,
+    instrux_VPERMI2PD,
+    instrux_VPERMI2PS,
+    instrux_VPERMI2Q,
+    instrux_VPERMI2W,
+    instrux_VPERMT2B,
+    instrux_VPERMT2D,
+    instrux_VPERMT2PD,
+    instrux_VPERMT2PS,
+    instrux_VPERMT2Q,
+    instrux_VPERMT2W,
+    instrux_VPERMW,
+    instrux_VPEXPANDD,
+    instrux_VPEXPANDQ,
+    instrux_VPLZCNTD,
+    instrux_VPLZCNTQ,
+    instrux_VPMAXSQ,
+    instrux_VPMAXUQ,
+    instrux_VPMINSQ,
+    instrux_VPMINUQ,
+    instrux_VPMOVB2M,
+    instrux_VPMOVD2M,
+    instrux_VPMOVDB,
+    instrux_VPMOVDW,
+    instrux_VPMOVM2B,
+    instrux_VPMOVM2D,
+    instrux_VPMOVM2Q,
+    instrux_VPMOVM2W,
+    instrux_VPMOVQ2M,
+    instrux_VPMOVQB,
+    instrux_VPMOVQD,
+    instrux_VPMOVQW,
+    instrux_VPMOVSDB,
+    instrux_VPMOVSDW,
+    instrux_VPMOVSQB,
+    instrux_VPMOVSQD,
+    instrux_VPMOVSQW,
+    instrux_VPMOVSWB,
+    instrux_VPMOVUSDB,
+    instrux_VPMOVUSDW,
+    instrux_VPMOVUSQB,
+    instrux_VPMOVUSQD,
+    instrux_VPMOVUSQW,
+    instrux_VPMOVUSWB,
+    instrux_VPMOVW2M,
+    instrux_VPMOVWB,
+    instrux_VPMULLQ,
+    instrux_VPMULTISHIFTQB,
+    instrux_VPORD,
+    instrux_VPORQ,
+    instrux_VPROLD,
+    instrux_VPROLQ,
+    instrux_VPROLVD,
+    instrux_VPROLVQ,
+    instrux_VPRORD,
+    instrux_VPRORQ,
+    instrux_VPRORVD,
+    instrux_VPRORVQ,
+    instrux_VPSCATTERDD,
+    instrux_VPSCATTERDQ,
+    instrux_VPSCATTERQD,
+    instrux_VPSCATTERQQ,
+    instrux_VPSLLVW,
+    instrux_VPSRAQ,
+    instrux_VPSRAVQ,
+    instrux_VPSRAVW,
+    instrux_VPSRLVW,
+    instrux_VPTERNLOGD,
+    instrux_VPTERNLOGQ,
+    instrux_VPTESTMB,
+    instrux_VPTESTMD,
+    instrux_VPTESTMQ,
+    instrux_VPTESTMW,
+    instrux_VPTESTNMB,
+    instrux_VPTESTNMD,
+    instrux_VPTESTNMQ,
+    instrux_VPTESTNMW,
+    instrux_VPXORD,
+    instrux_VPXORQ,
+    instrux_VRANGEPD,
+    instrux_VRANGEPS,
+    instrux_VRANGESD,
+    instrux_VRANGESS,
+    instrux_VRCP14PD,
+    instrux_VRCP14PS,
+    instrux_VRCP14SD,
+    instrux_VRCP14SS,
+    instrux_VRCP28PD,
+    instrux_VRCP28PS,
+    instrux_VRCP28SD,
+    instrux_VRCP28SS,
+    instrux_VREDUCEPD,
+    instrux_VREDUCEPS,
+    instrux_VREDUCESD,
+    instrux_VREDUCESS,
+    instrux_VRNDSCALEPD,
+    instrux_VRNDSCALEPS,
+    instrux_VRNDSCALESD,
+    instrux_VRNDSCALESS,
+    instrux_VRSQRT14PD,
+    instrux_VRSQRT14PS,
+    instrux_VRSQRT14SD,
+    instrux_VRSQRT14SS,
+    instrux_VRSQRT28PD,
+    instrux_VRSQRT28PS,
+    instrux_VRSQRT28SD,
+    instrux_VRSQRT28SS,
+    instrux_VSCALEFPD,
+    instrux_VSCALEFPS,
+    instrux_VSCALEFSD,
+    instrux_VSCALEFSS,
+    instrux_VSCATTERDPD,
+    instrux_VSCATTERDPS,
+    instrux_VSCATTERPF0DPD,
+    instrux_VSCATTERPF0DPS,
+    instrux_VSCATTERPF0QPD,
+    instrux_VSCATTERPF0QPS,
+    instrux_VSCATTERPF1DPD,
+    instrux_VSCATTERPF1DPS,
+    instrux_VSCATTERPF1QPD,
+    instrux_VSCATTERPF1QPS,
+    instrux_VSCATTERQPD,
+    instrux_VSCATTERQPS,
+    instrux_VSHUFF32X4,
+    instrux_VSHUFF64X2,
+    instrux_VSHUFI32X4,
+    instrux_VSHUFI64X2,
+    instrux_RDPKRU,
+    instrux_WRPKRU,
+    instrux_RDPID,
+    instrux_CLFLUSHOPT,
+    instrux_CLWB,
+    instrux_PCOMMIT,
+    instrux_CLZERO,
+    instrux_PTWRITE,
+    instrux_CLDEMOTE,
+    instrux_MOVDIRI,
+    instrux_MOVDIR64B,
+    instrux_PCONFIG,
+    instrux_TPAUSE,
+    instrux_UMONITOR,
+    instrux_UMWAIT,
+    instrux_WBNOINVD,
+    instrux_GF2P8AFFINEINVQB,
+    instrux_VGF2P8AFFINEINVQB,
+    instrux_GF2P8AFFINEQB,
+    instrux_VGF2P8AFFINEQB,
+    instrux_GF2P8MULB,
+    instrux_VGF2P8MULB,
+    instrux_VPCOMPRESSB,
+    instrux_VPCOMPRESSW,
+    instrux_VPEXPANDB,
+    instrux_VPEXPANDW,
+    instrux_VPSHLDW,
+    instrux_VPSHLDD,
+    instrux_VPSHLDQ,
+    instrux_VPSHLDVW,
+    instrux_VPSHLDVD,
+    instrux_VPSHLDVQ,
+    instrux_VPSHRDW,
+    instrux_VPSHRDD,
+    instrux_VPSHRDQ,
+    instrux_VPSHRDVW,
+    instrux_VPSHRDVD,
+    instrux_VPSHRDVQ,
+    instrux_VPDPBUSD,
+    instrux_VPDPBUSDS,
+    instrux_VPDPWSSD,
+    instrux_VPDPWSSDS,
+    instrux_VPOPCNTB,
+    instrux_VPOPCNTW,
+    instrux_VPOPCNTD,
+    instrux_VPOPCNTQ,
+    instrux_VPSHUFBITQMB,
+    instrux_V4FMADDPS,
+    instrux_V4FNMADDPS,
+    instrux_V4FMADDSS,
+    instrux_V4FNMADDSS,
+    instrux_V4DPWSSDS,
+    instrux_V4DPWSSD,
+    instrux_ENCLS,
+    instrux_ENCLU,
+    instrux_ENCLV,
+    instrux_CLRSSBSY,
+    instrux_ENDBR32,
+    instrux_ENDBR64,
+    instrux_INCSSPD,
+    instrux_INCSSPQ,
+    instrux_RDSSPD,
+    instrux_RDSSPQ,
+    instrux_RSTORSSP,
+    instrux_SAVEPREVSSP,
+    instrux_SETSSBSY,
+    instrux_WRUSSD,
+    instrux_WRUSSQ,
+    instrux_WRSSD,
+    instrux_WRSSQ,
+    instrux_ENQCMD,
+    instrux_ENQCMDS,
+    instrux_SERIALIZE,
+    instrux_XRESLDTRK,
+    instrux_XSUSLDTRK,
+    instrux_VCVTNE2PS2BF16,
+    instrux_VDPBF16PS,
+    instrux_VP2INTERSECTD,
+    instrux_LDTILECFG,
+    instrux_STTILECFG,
+    instrux_TDPBF16PS,
+    instrux_TDPBSSD,
+    instrux_TDPBSUD,
+    instrux_TDPBUSD,
+    instrux_TDPBUUD,
+    instrux_TILELOADD,
+    instrux_TILELOADDT1,
+    instrux_TILERELEASE,
+    instrux_TILESTORED,
+    instrux_TILEZERO,
+    instrux_VADDPH,
+    instrux_VADDSH,
+    instrux_VCMPPH,
+    instrux_VCMPSH,
+    instrux_VCOMISH,
+    instrux_VCVTDQ2PH,
+    instrux_VCVTPD2PH,
+    instrux_VCVTPH2DQ,
+    instrux_VCVTPH2PD,
+    instrux_VCVTPH2PSX,
+    instrux_VCVTPH2QQ,
+    instrux_VCVTPH2UDQ,
+    instrux_VCVTPH2UQQ,
+    instrux_VCVTPH2UW,
+    instrux_VCVTPH2W,
+    instrux_VCVTQQ2PH,
+    instrux_VCVTSD2SH,
+    instrux_VCVTSH2SD,
+    instrux_VCVTSH2SI,
+    instrux_VCVTSH2SS,
+    instrux_VCVTSH2USI,
+    instrux_VCVTSI2SH,
+    instrux_VCVTSS2SH,
+    instrux_VCVTTPH2DQ,
+    instrux_VCVTTPH2QQ,
+    instrux_VCVTTPH2UDQ,
+    instrux_VCVTTPH2UQQ,
+    instrux_VCVTTPH2UW,
+    instrux_VCVTTPH2W,
+    instrux_VCVTTSH2SI,
+    instrux_VCVTTSH2USI,
+    instrux_VCVTUDQ2PH,
+    instrux_VCVTUQQ2PH,
+    instrux_VCVTUSI2SH,
+    instrux_VCVTUW2PH,
+    instrux_VCVTW2PH,
+    instrux_VDIVPH,
+    instrux_VDIVSH,
+    instrux_VFCMADDCPH,
+    instrux_VFMADDCPH,
+    instrux_VFCMADDCSH,
+    instrux_VFMADDCSH,
+    instrux_VFCMULCPCH,
+    instrux_VFMULCPCH,
+    instrux_VFCMULCSH,
+    instrux_VFMULCSH,
+    instrux_VFMADDSUB132PH,
+    instrux_VFMADDSUB213PH,
+    instrux_VFMADDSUB231PH,
+    instrux_VFMSUBADD132PH,
+    instrux_VFMSUBADD213PH,
+    instrux_VFMSUBADD231PH,
+    instrux_VPMADD132PH,
+    instrux_VPMADD213PH,
+    instrux_VPMADD231PH,
+    instrux_VFMADD132PH,
+    instrux_VFMADD213PH,
+    instrux_VFMADD231PH,
+    instrux_VPMADD132SH,
+    instrux_VPMADD213SH,
+    instrux_VPMADD231SH,
+    instrux_VPNMADD132SH,
+    instrux_VPNMADD213SH,
+    instrux_VPNMADD231SH,
+    instrux_VPMSUB132PH,
+    instrux_VPMSUB213PH,
+    instrux_VPMSUB231PH,
+    instrux_VFMSUB132PH,
+    instrux_VFMSUB213PH,
+    instrux_VFMSUB231PH,
+    instrux_VPMSUB132SH,
+    instrux_VPMSUB213SH,
+    instrux_VPMSUB231SH,
+    instrux_VPNMSUB132SH,
+    instrux_VPNMSUB213SH,
+    instrux_VPNMSUB231SH,
+    instrux_VFPCLASSPH,
+    instrux_VFPCLASSSH,
+    instrux_VGETEXPPH,
+    instrux_VGETEXPSH,
+    instrux_VGETMANTPH,
+    instrux_VGETMANTSH,
+    instrux_VGETMAXPH,
+    instrux_VGETMAXSH,
+    instrux_VGETMINPH,
+    instrux_VGETMINSH,
+    instrux_VMOVSH,
+    instrux_VMOVW,
+    instrux_VMULPH,
+    instrux_VMULSH,
+    instrux_VRCPPH,
+    instrux_VRCPSH,
+    instrux_VREDUCEPH,
+    instrux_VREDUCESH,
+    instrux_VENDSCALEPH,
+    instrux_VENDSCALESH,
+    instrux_VRSQRTPH,
+    instrux_VRSQRTSH,
+    instrux_VSCALEFPH,
+    instrux_VSCALEFSH,
+    instrux_VSQRTPH,
+    instrux_VSQRTSH,
+    instrux_VSUBPH,
+    instrux_VSUBSH,
+    instrux_VUCOMISH,
+    instrux_AADD,
+    instrux_AAND,
+    instrux_AXOR,
+    instrux_CLUI,
+    instrux_SENDUIPI,
+    instrux_STUI,
+    instrux_TESTUI,
+    instrux_UIRET,
+    instrux_CMPAXADD,
+    instrux_CMPAEXADD,
+    instrux_CMPBXADD,
+    instrux_CMPBEXADD,
+    instrux_CMPCXADD,
+    instrux_CMPEXADD,
+    instrux_CMPGXADD,
+    instrux_CMPGEXADD,
+    instrux_CMPLXADD,
+    instrux_CMPLEXADD,
+    instrux_CMPNAXADD,
+    instrux_CMPNAEXADD,
+    instrux_CMPNBXADD,
+    instrux_CMPNBEXADD,
+    instrux_CMPNCXADD,
+    instrux_CMPNEXADD,
+    instrux_CMPNGXADD,
+    instrux_CMPNGEXADD,
+    instrux_CMPNLXADD,
+    instrux_CMPNLEXADD,
+    instrux_CMPNOXADD,
+    instrux_CMPNPXADD,
+    instrux_CMPNSXADD,
+    instrux_CMPNZXADD,
+    instrux_CMPOXADD,
+    instrux_CMPPXADD,
+    instrux_CMPPEXADD,
+    instrux_CMPPOXADD,
+    instrux_CMPSXADD,
+    instrux_CMPZXADD,
+    instrux_WRMSRNS,
+    instrux_RDMSRLIST,
+    instrux_WRMSRLIST,
+    instrux_HRESET,
+    instrux_HINT_NOP0,
+    instrux_HINT_NOP1,
+    instrux_HINT_NOP2,
+    instrux_HINT_NOP3,
+    instrux_HINT_NOP4,
+    instrux_HINT_NOP5,
+    instrux_HINT_NOP6,
+    instrux_HINT_NOP7,
+    instrux_HINT_NOP8,
+    instrux_HINT_NOP9,
+    instrux_HINT_NOP10,
+    instrux_HINT_NOP11,
+    instrux_HINT_NOP12,
+    instrux_HINT_NOP13,
+    instrux_HINT_NOP14,
+    instrux_HINT_NOP15,
+    instrux_HINT_NOP16,
+    instrux_HINT_NOP17,
+    instrux_HINT_NOP18,
+    instrux_HINT_NOP19,
+    instrux_HINT_NOP20,
+    instrux_HINT_NOP21,
+    instrux_HINT_NOP22,
+    instrux_HINT_NOP23,
+    instrux_HINT_NOP24,
+    instrux_HINT_NOP25,
+    instrux_HINT_NOP26,
+    instrux_HINT_NOP27,
+    instrux_HINT_NOP28,
+    instrux_HINT_NOP29,
+    instrux_HINT_NOP30,
+    instrux_HINT_NOP31,
+    instrux_HINT_NOP32,
+    instrux_HINT_NOP33,
+    instrux_HINT_NOP34,
+    instrux_HINT_NOP35,
+    instrux_HINT_NOP36,
+    instrux_HINT_NOP37,
+    instrux_HINT_NOP38,
+    instrux_HINT_NOP39,
+    instrux_HINT_NOP40,
+    instrux_HINT_NOP41,
+    instrux_HINT_NOP42,
+    instrux_HINT_NOP43,
+    instrux_HINT_NOP44,
+    instrux_HINT_NOP45,
+    instrux_HINT_NOP46,
+    instrux_HINT_NOP47,
+    instrux_HINT_NOP48,
+    instrux_HINT_NOP49,
+    instrux_HINT_NOP50,
+    instrux_HINT_NOP51,
+    instrux_HINT_NOP52,
+    instrux_HINT_NOP53,
+    instrux_HINT_NOP54,
+    instrux_HINT_NOP55,
+    instrux_HINT_NOP56,
+    instrux_HINT_NOP57,
+    instrux_HINT_NOP58,
+    instrux_HINT_NOP59,
+    instrux_HINT_NOP60,
+    instrux_HINT_NOP61,
+    instrux_HINT_NOP62,
+    instrux_HINT_NOP63,
+};
diff --git a/vere/ext/nasm/x86/insnsb.c b/vere/ext/nasm/x86/insnsb.c
new file mode 100644
index 0000000..decc3db
--- /dev/null
+++ b/vere/ext/nasm/x86/insnsb.c
@@ -0,0 +1,6748 @@
+/* This file auto-generated from insns.dat by insns.pl - don't edit it */
+
+#include "nasm.h"
+#include "insns.h"
+
+const uint8_t nasm_bytecodes[50229] = {
+    /*     0 */ 0241,0203,041,0301,01,0104,0120,01,0,0,
+    /*    10 */ 0240,0203,041,0301,01,0104,0110,01,0,0,
+    /*    20 */ 0241,0203,041,0301,01,0104,0120,01,01,0,
+    /*    30 */ 0240,0203,041,0301,01,0104,0110,01,01,0,
+    /*    40 */ 0241,0203,041,0301,01,0104,0120,01,020,0,
+    /*    50 */ 0240,0203,041,0301,01,0104,0110,01,020,0,
+    /*    60 */ 0241,0203,041,0301,01,0104,0120,01,021,0,
+    /*    70 */ 0240,0203,041,0301,01,0104,0110,01,021,0,
+    /*    80 */ 0241,0203,045,0301,01,0104,0120,01,0,0,
+    /*    90 */ 0240,0203,045,0301,01,0104,0110,01,0,0,
+    /*   100 */ 0241,0203,045,0301,01,0104,0120,01,01,0,
+    /*   110 */ 0240,0203,045,0301,01,0104,0110,01,01,0,
+    /*   120 */ 0241,0203,045,0301,01,0104,0120,01,020,0,
+    /*   130 */ 0240,0203,045,0301,01,0104,0110,01,020,0,
+    /*   140 */ 0241,0203,045,0301,01,0104,0120,01,021,0,
+    /*   150 */ 0240,0203,045,0301,01,0104,0110,01,021,0,
+    /*   160 */ 0241,0203,051,0301,01,0104,0120,01,0,0,
+    /*   170 */ 0240,0203,051,0301,01,0104,0110,01,0,0,
+    /*   180 */ 0241,0203,051,0301,01,0104,0120,01,01,0,
+    /*   190 */ 0240,0203,051,0301,01,0104,0110,01,01,0,
+    /*   200 */ 0241,0203,051,0301,01,0104,0120,01,020,0,
+    /*   210 */ 0240,0203,051,0301,01,0104,0110,01,020,0,
+    /*   220 */ 0241,0203,051,0301,01,0104,0120,01,021,0,
+    /*   230 */ 0240,0203,051,0301,01,0104,0110,01,021,0,
+    /*   240 */ 0241,0201,021,0301,01,0302,0120,01,0,0,
+    /*   250 */ 0241,0201,025,0301,01,0302,0120,01,0,0,
+    /*   260 */ 0241,0201,031,0301,01,0302,0120,01,0,0,
+    /*   270 */ 0241,0201,0,0301,01,0302,0120,01,0,0,
+    /*   280 */ 0241,0201,04,0301,01,0302,0120,01,0,0,
+    /*   290 */ 0241,0201,010,0301,01,0302,0120,01,0,0,
+    /*   300 */ 0241,0201,023,0306,01,0302,0120,01,0,0,
+    /*   310 */ 0241,0201,02,0306,01,0302,0120,01,0,0,
+    /*   320 */ 0241,0201,021,0301,01,0302,0120,01,01,0,
+    /*   330 */ 0241,0201,025,0301,01,0302,0120,01,01,0,
+    /*   340 */ 0241,0201,031,0301,01,0302,0120,01,01,0,
+    /*   350 */ 0241,0201,0,0301,01,0302,0120,01,01,0,
+    /*   360 */ 0241,0201,04,0301,01,0302,0120,01,01,0,
+    /*   370 */ 0241,0201,010,0301,01,0302,0120,01,01,0,
+    /*   380 */ 0241,0201,023,0306,01,0302,0120,01,01,0,
+    /*   390 */ 0241,0201,02,0306,01,0302,0120,01,01,0,
+    /*   400 */ 0241,0201,021,0301,01,0302,0120,01,02,0,
+    /*   410 */ 0241,0201,025,0301,01,0302,0120,01,02,0,
+    /*   420 */ 0241,0201,031,0301,01,0302,0120,01,02,0,
+    /*   430 */ 0241,0201,0,0301,01,0302,0120,01,02,0,
+    /*   440 */ 0241,0201,04,0301,01,0302,0120,01,02,0,
+    /*   450 */ 0241,0201,010,0301,01,0302,0120,01,02,0,
+    /*   460 */ 0241,0201,023,0306,01,0302,0120,01,02,0,
+    /*   470 */ 0241,0201,02,0306,01,0302,0120,01,02,0,
+    /*   480 */ 0241,0201,021,0301,01,0302,0120,01,03,0,
+    /*   490 */ 0241,0201,025,0301,01,0302,0120,01,03,0,
+    /*   500 */ 0241,0201,031,0301,01,0302,0120,01,03,0,
+    /*   510 */ 0241,0201,0,0301,01,0302,0120,01,03,0,
+    /*   520 */ 0241,0201,04,0301,01,0302,0120,01,03,0,
+    /*   530 */ 0241,0201,010,0301,01,0302,0120,01,03,0,
+    /*   540 */ 0241,0201,023,0306,01,0302,0120,01,03,0,
+    /*   550 */ 0241,0201,02,0306,01,0302,0120,01,03,0,
+    /*   560 */ 0241,0201,021,0301,01,0302,0120,01,04,0,
+    /*   570 */ 0241,0201,025,0301,01,0302,0120,01,04,0,
+    /*   580 */ 0241,0201,031,0301,01,0302,0120,01,04,0,
+    /*   590 */ 0241,0201,0,0301,01,0302,0120,01,04,0,
+    /*   600 */ 0241,0201,04,0301,01,0302,0120,01,04,0,
+    /*   610 */ 0241,0201,010,0301,01,0302,0120,01,04,0,
+    /*   620 */ 0241,0201,023,0306,01,0302,0120,01,04,0,
+    /*   630 */ 0241,0201,02,0306,01,0302,0120,01,04,0,
+    /*   640 */ 0241,0201,021,0301,01,0302,0120,01,05,0,
+    /*   650 */ 0241,0201,025,0301,01,0302,0120,01,05,0,
+    /*   660 */ 0241,0201,031,0301,01,0302,0120,01,05,0,
+    /*   670 */ 0241,0201,0,0301,01,0302,0120,01,05,0,
+    /*   680 */ 0241,0201,04,0301,01,0302,0120,01,05,0,
+    /*   690 */ 0241,0201,010,0301,01,0302,0120,01,05,0,
+    /*   700 */ 0241,0201,023,0306,01,0302,0120,01,05,0,
+    /*   710 */ 0241,0201,02,0306,01,0302,0120,01,05,0,
+    /*   720 */ 0241,0201,021,0301,01,0302,0120,01,06,0,
+    /*   730 */ 0241,0201,025,0301,01,0302,0120,01,06,0,
+    /*   740 */ 0241,0201,031,0301,01,0302,0120,01,06,0,
+    /*   750 */ 0241,0201,0,0301,01,0302,0120,01,06,0,
+    /*   760 */ 0241,0201,04,0301,01,0302,0120,01,06,0,
+    /*   770 */ 0241,0201,010,0301,01,0302,0120,01,06,0,
+    /*   780 */ 0241,0201,023,0306,01,0302,0120,01,06,0,
+    /*   790 */ 0241,0201,02,0306,01,0302,0120,01,06,0,
+    /*   800 */ 0241,0201,021,0301,01,0302,0120,01,07,0,
+    /*   810 */ 0241,0201,025,0301,01,0302,0120,01,07,0,
+    /*   820 */ 0241,0201,031,0301,01,0302,0120,01,07,0,
+    /*   830 */ 0241,0201,0,0301,01,0302,0120,01,07,0,
+    /*   840 */ 0241,0201,04,0301,01,0302,0120,01,07,0,
+    /*   850 */ 0241,0201,010,0301,01,0302,0120,01,07,0,
+    /*   860 */ 0241,0201,023,0306,01,0302,0120,01,07,0,
+    /*   870 */ 0241,0201,02,0306,01,0302,0120,01,07,0,
+    /*   880 */ 0241,0201,021,0301,01,0302,0120,01,010,0,
+    /*   890 */ 0241,0201,025,0301,01,0302,0120,01,010,0,
+    /*   900 */ 0241,0201,031,0301,01,0302,0120,01,010,0,
+    /*   910 */ 0241,0201,0,0301,01,0302,0120,01,010,0,
+    /*   920 */ 0241,0201,04,0301,01,0302,0120,01,010,0,
+    /*   930 */ 0241,0201,010,0301,01,0302,0120,01,010,0,
+    /*   940 */ 0241,0201,023,0306,01,0302,0120,01,010,0,
+    /*   950 */ 0241,0201,02,0306,01,0302,0120,01,010,0,
+    /*   960 */ 0241,0201,021,0301,01,0302,0120,01,011,0,
+    /*   970 */ 0241,0201,025,0301,01,0302,0120,01,011,0,
+    /*   980 */ 0241,0201,031,0301,01,0302,0120,01,011,0,
+    /*   990 */ 0241,0201,0,0301,01,0302,0120,01,011,0,
+    /*  1000 */ 0241,0201,04,0301,01,0302,0120,01,011,0,
+    /*  1010 */ 0241,0201,010,0301,01,0302,0120,01,011,0,
+    /*  1020 */ 0241,0201,023,0306,01,0302,0120,01,011,0,
+    /*  1030 */ 0241,0201,02,0306,01,0302,0120,01,011,0,
+    /*  1040 */ 0241,0201,021,0301,01,0302,0120,01,012,0,
+    /*  1050 */ 0241,0201,025,0301,01,0302,0120,01,012,0,
+    /*  1060 */ 0241,0201,031,0301,01,0302,0120,01,012,0,
+    /*  1070 */ 0241,0201,0,0301,01,0302,0120,01,012,0,
+    /*  1080 */ 0241,0201,04,0301,01,0302,0120,01,012,0,
+    /*  1090 */ 0241,0201,010,0301,01,0302,0120,01,012,0,
+    /*  1100 */ 0241,0201,023,0306,01,0302,0120,01,012,0,
+    /*  1110 */ 0241,0201,02,0306,01,0302,0120,01,012,0,
+    /*  1120 */ 0241,0201,021,0301,01,0302,0120,01,013,0,
+    /*  1130 */ 0241,0201,025,0301,01,0302,0120,01,013,0,
+    /*  1140 */ 0241,0201,031,0301,01,0302,0120,01,013,0,
+    /*  1150 */ 0241,0201,0,0301,01,0302,0120,01,013,0,
+    /*  1160 */ 0241,0201,04,0301,01,0302,0120,01,013,0,
+    /*  1170 */ 0241,0201,010,0301,01,0302,0120,01,013,0,
+    /*  1180 */ 0241,0201,023,0306,01,0302,0120,01,013,0,
+    /*  1190 */ 0241,0201,02,0306,01,0302,0120,01,013,0,
+    /*  1200 */ 0241,0201,021,0301,01,0302,0120,01,014,0,
+    /*  1210 */ 0241,0201,025,0301,01,0302,0120,01,014,0,
+    /*  1220 */ 0241,0201,031,0301,01,0302,0120,01,014,0,
+    /*  1230 */ 0241,0201,0,0301,01,0302,0120,01,014,0,
+    /*  1240 */ 0241,0201,04,0301,01,0302,0120,01,014,0,
+    /*  1250 */ 0241,0201,010,0301,01,0302,0120,01,014,0,
+    /*  1260 */ 0241,0201,023,0306,01,0302,0120,01,014,0,
+    /*  1270 */ 0241,0201,02,0306,01,0302,0120,01,014,0,
+    /*  1280 */ 0241,0201,021,0301,01,0302,0120,01,015,0,
+    /*  1290 */ 0241,0201,025,0301,01,0302,0120,01,015,0,
+    /*  1300 */ 0241,0201,031,0301,01,0302,0120,01,015,0,
+    /*  1310 */ 0241,0201,0,0301,01,0302,0120,01,015,0,
+    /*  1320 */ 0241,0201,04,0301,01,0302,0120,01,015,0,
+    /*  1330 */ 0241,0201,010,0301,01,0302,0120,01,015,0,
+    /*  1340 */ 0241,0201,023,0306,01,0302,0120,01,015,0,
+    /*  1350 */ 0241,0201,02,0306,01,0302,0120,01,015,0,
+    /*  1360 */ 0241,0201,021,0301,01,0302,0120,01,016,0,
+    /*  1370 */ 0241,0201,025,0301,01,0302,0120,01,016,0,
+    /*  1380 */ 0241,0201,031,0301,01,0302,0120,01,016,0,
+    /*  1390 */ 0241,0201,0,0301,01,0302,0120,01,016,0,
+    /*  1400 */ 0241,0201,04,0301,01,0302,0120,01,016,0,
+    /*  1410 */ 0241,0201,010,0301,01,0302,0120,01,016,0,
+    /*  1420 */ 0241,0201,023,0306,01,0302,0120,01,016,0,
+    /*  1430 */ 0241,0201,02,0306,01,0302,0120,01,016,0,
+    /*  1440 */ 0241,0201,021,0301,01,0302,0120,01,017,0,
+    /*  1450 */ 0241,0201,025,0301,01,0302,0120,01,017,0,
+    /*  1460 */ 0241,0201,031,0301,01,0302,0120,01,017,0,
+    /*  1470 */ 0241,0201,0,0301,01,0302,0120,01,017,0,
+    /*  1480 */ 0241,0201,04,0301,01,0302,0120,01,017,0,
+    /*  1490 */ 0241,0201,010,0301,01,0302,0120,01,017,0,
+    /*  1500 */ 0241,0201,023,0306,01,0302,0120,01,017,0,
+    /*  1510 */ 0241,0201,02,0306,01,0302,0120,01,017,0,
+    /*  1520 */ 0241,0201,021,0301,01,0302,0120,01,020,0,
+    /*  1530 */ 0241,0201,025,0301,01,0302,0120,01,020,0,
+    /*  1540 */ 0241,0201,031,0301,01,0302,0120,01,020,0,
+    /*  1550 */ 0241,0201,0,0301,01,0302,0120,01,020,0,
+    /*  1560 */ 0241,0201,04,0301,01,0302,0120,01,020,0,
+    /*  1570 */ 0241,0201,010,0301,01,0302,0120,01,020,0,
+    /*  1580 */ 0241,0201,023,0306,01,0302,0120,01,020,0,
+    /*  1590 */ 0241,0201,02,0306,01,0302,0120,01,020,0,
+    /*  1600 */ 0241,0201,021,0301,01,0302,0120,01,021,0,
+    /*  1610 */ 0241,0201,025,0301,01,0302,0120,01,021,0,
+    /*  1620 */ 0241,0201,031,0301,01,0302,0120,01,021,0,
+    /*  1630 */ 0241,0201,0,0301,01,0302,0120,01,021,0,
+    /*  1640 */ 0241,0201,04,0301,01,0302,0120,01,021,0,
+    /*  1650 */ 0241,0201,010,0301,01,0302,0120,01,021,0,
+    /*  1660 */ 0241,0201,023,0306,01,0302,0120,01,021,0,
+    /*  1670 */ 0241,0201,02,0306,01,0302,0120,01,021,0,
+    /*  1680 */ 0241,0201,021,0301,01,0302,0120,01,022,0,
+    /*  1690 */ 0241,0201,025,0301,01,0302,0120,01,022,0,
+    /*  1700 */ 0241,0201,031,0301,01,0302,0120,01,022,0,
+    /*  1710 */ 0241,0201,0,0301,01,0302,0120,01,022,0,
+    /*  1720 */ 0241,0201,04,0301,01,0302,0120,01,022,0,
+    /*  1730 */ 0241,0201,010,0301,01,0302,0120,01,022,0,
+    /*  1740 */ 0241,0201,023,0306,01,0302,0120,01,022,0,
+    /*  1750 */ 0241,0201,02,0306,01,0302,0120,01,022,0,
+    /*  1760 */ 0241,0201,021,0301,01,0302,0120,01,023,0,
+    /*  1770 */ 0241,0201,025,0301,01,0302,0120,01,023,0,
+    /*  1780 */ 0241,0201,031,0301,01,0302,0120,01,023,0,
+    /*  1790 */ 0241,0201,0,0301,01,0302,0120,01,023,0,
+    /*  1800 */ 0241,0201,04,0301,01,0302,0120,01,023,0,
+    /*  1810 */ 0241,0201,010,0301,01,0302,0120,01,023,0,
+    /*  1820 */ 0241,0201,023,0306,01,0302,0120,01,023,0,
+    /*  1830 */ 0241,0201,02,0306,01,0302,0120,01,023,0,
+    /*  1840 */ 0241,0201,021,0301,01,0302,0120,01,024,0,
+    /*  1850 */ 0241,0201,025,0301,01,0302,0120,01,024,0,
+    /*  1860 */ 0241,0201,031,0301,01,0302,0120,01,024,0,
+    /*  1870 */ 0241,0201,0,0301,01,0302,0120,01,024,0,
+    /*  1880 */ 0241,0201,04,0301,01,0302,0120,01,024,0,
+    /*  1890 */ 0241,0201,010,0301,01,0302,0120,01,024,0,
+    /*  1900 */ 0241,0201,023,0306,01,0302,0120,01,024,0,
+    /*  1910 */ 0241,0201,02,0306,01,0302,0120,01,024,0,
+    /*  1920 */ 0241,0201,021,0301,01,0302,0120,01,025,0,
+    /*  1930 */ 0241,0201,025,0301,01,0302,0120,01,025,0,
+    /*  1940 */ 0241,0201,031,0301,01,0302,0120,01,025,0,
+    /*  1950 */ 0241,0201,0,0301,01,0302,0120,01,025,0,
+    /*  1960 */ 0241,0201,04,0301,01,0302,0120,01,025,0,
+    /*  1970 */ 0241,0201,010,0301,01,0302,0120,01,025,0,
+    /*  1980 */ 0241,0201,023,0306,01,0302,0120,01,025,0,
+    /*  1990 */ 0241,0201,02,0306,01,0302,0120,01,025,0,
+    /*  2000 */ 0241,0201,021,0301,01,0302,0120,01,026,0,
+    /*  2010 */ 0241,0201,025,0301,01,0302,0120,01,026,0,
+    /*  2020 */ 0241,0201,031,0301,01,0302,0120,01,026,0,
+    /*  2030 */ 0241,0201,0,0301,01,0302,0120,01,026,0,
+    /*  2040 */ 0241,0201,04,0301,01,0302,0120,01,026,0,
+    /*  2050 */ 0241,0201,010,0301,01,0302,0120,01,026,0,
+    /*  2060 */ 0241,0201,023,0306,01,0302,0120,01,026,0,
+    /*  2070 */ 0241,0201,02,0306,01,0302,0120,01,026,0,
+    /*  2080 */ 0241,0201,021,0301,01,0302,0120,01,027,0,
+    /*  2090 */ 0241,0201,025,0301,01,0302,0120,01,027,0,
+    /*  2100 */ 0241,0201,031,0301,01,0302,0120,01,027,0,
+    /*  2110 */ 0241,0201,0,0301,01,0302,0120,01,027,0,
+    /*  2120 */ 0241,0201,04,0301,01,0302,0120,01,027,0,
+    /*  2130 */ 0241,0201,010,0301,01,0302,0120,01,027,0,
+    /*  2140 */ 0241,0201,023,0306,01,0302,0120,01,027,0,
+    /*  2150 */ 0241,0201,02,0306,01,0302,0120,01,027,0,
+    /*  2160 */ 0241,0201,021,0301,01,0302,0120,01,030,0,
+    /*  2170 */ 0241,0201,025,0301,01,0302,0120,01,030,0,
+    /*  2180 */ 0241,0201,031,0301,01,0302,0120,01,030,0,
+    /*  2190 */ 0241,0201,0,0301,01,0302,0120,01,030,0,
+    /*  2200 */ 0241,0201,04,0301,01,0302,0120,01,030,0,
+    /*  2210 */ 0241,0201,010,0301,01,0302,0120,01,030,0,
+    /*  2220 */ 0241,0201,023,0306,01,0302,0120,01,030,0,
+    /*  2230 */ 0241,0201,02,0306,01,0302,0120,01,030,0,
+    /*  2240 */ 0241,0201,021,0301,01,0302,0120,01,031,0,
+    /*  2250 */ 0241,0201,025,0301,01,0302,0120,01,031,0,
+    /*  2260 */ 0241,0201,031,0301,01,0302,0120,01,031,0,
+    /*  2270 */ 0241,0201,0,0301,01,0302,0120,01,031,0,
+    /*  2280 */ 0241,0201,04,0301,01,0302,0120,01,031,0,
+    /*  2290 */ 0241,0201,010,0301,01,0302,0120,01,031,0,
+    /*  2300 */ 0241,0201,023,0306,01,0302,0120,01,031,0,
+    /*  2310 */ 0241,0201,02,0306,01,0302,0120,01,031,0,
+    /*  2320 */ 0241,0201,021,0301,01,0302,0120,01,032,0,
+    /*  2330 */ 0241,0201,025,0301,01,0302,0120,01,032,0,
+    /*  2340 */ 0241,0201,031,0301,01,0302,0120,01,032,0,
+    /*  2350 */ 0241,0201,0,0301,01,0302,0120,01,032,0,
+    /*  2360 */ 0241,0201,04,0301,01,0302,0120,01,032,0,
+    /*  2370 */ 0241,0201,010,0301,01,0302,0120,01,032,0,
+    /*  2380 */ 0241,0201,023,0306,01,0302,0120,01,032,0,
+    /*  2390 */ 0241,0201,02,0306,01,0302,0120,01,032,0,
+    /*  2400 */ 0241,0201,021,0301,01,0302,0120,01,033,0,
+    /*  2410 */ 0241,0201,025,0301,01,0302,0120,01,033,0,
+    /*  2420 */ 0241,0201,031,0301,01,0302,0120,01,033,0,
+    /*  2430 */ 0241,0201,0,0301,01,0302,0120,01,033,0,
+    /*  2440 */ 0241,0201,04,0301,01,0302,0120,01,033,0,
+    /*  2450 */ 0241,0201,010,0301,01,0302,0120,01,033,0,
+    /*  2460 */ 0241,0201,023,0306,01,0302,0120,01,033,0,
+    /*  2470 */ 0241,0201,02,0306,01,0302,0120,01,033,0,
+    /*  2480 */ 0241,0201,021,0301,01,0302,0120,01,034,0,
+    /*  2490 */ 0241,0201,025,0301,01,0302,0120,01,034,0,
+    /*  2500 */ 0241,0201,031,0301,01,0302,0120,01,034,0,
+    /*  2510 */ 0241,0201,0,0301,01,0302,0120,01,034,0,
+    /*  2520 */ 0241,0201,04,0301,01,0302,0120,01,034,0,
+    /*  2530 */ 0241,0201,010,0301,01,0302,0120,01,034,0,
+    /*  2540 */ 0241,0201,023,0306,01,0302,0120,01,034,0,
+    /*  2550 */ 0241,0201,02,0306,01,0302,0120,01,034,0,
+    /*  2560 */ 0241,0201,021,0301,01,0302,0120,01,035,0,
+    /*  2570 */ 0241,0201,025,0301,01,0302,0120,01,035,0,
+    /*  2580 */ 0241,0201,031,0301,01,0302,0120,01,035,0,
+    /*  2590 */ 0241,0201,0,0301,01,0302,0120,01,035,0,
+    /*  2600 */ 0241,0201,04,0301,01,0302,0120,01,035,0,
+    /*  2610 */ 0241,0201,010,0301,01,0302,0120,01,035,0,
+    /*  2620 */ 0241,0201,023,0306,01,0302,0120,01,035,0,
+    /*  2630 */ 0241,0201,02,0306,01,0302,0120,01,035,0,
+    /*  2640 */ 0241,0201,021,0301,01,0302,0120,01,036,0,
+    /*  2650 */ 0241,0201,025,0301,01,0302,0120,01,036,0,
+    /*  2660 */ 0241,0201,031,0301,01,0302,0120,01,036,0,
+    /*  2670 */ 0241,0201,0,0301,01,0302,0120,01,036,0,
+    /*  2680 */ 0241,0201,04,0301,01,0302,0120,01,036,0,
+    /*  2690 */ 0241,0201,010,0301,01,0302,0120,01,036,0,
+    /*  2700 */ 0241,0201,023,0306,01,0302,0120,01,036,0,
+    /*  2710 */ 0241,0201,02,0306,01,0302,0120,01,036,0,
+    /*  2720 */ 0241,0201,021,0301,01,0302,0120,01,037,0,
+    /*  2730 */ 0241,0201,025,0301,01,0302,0120,01,037,0,
+    /*  2740 */ 0241,0201,031,0301,01,0302,0120,01,037,0,
+    /*  2750 */ 0241,0201,0,0301,01,0302,0120,01,037,0,
+    /*  2760 */ 0241,0201,04,0301,01,0302,0120,01,037,0,
+    /*  2770 */ 0241,0201,010,0301,01,0302,0120,01,037,0,
+    /*  2780 */ 0241,0201,023,0306,01,0302,0120,01,037,0,
+    /*  2790 */ 0241,0201,02,0306,01,0302,0120,01,037,0,
+    /*  2800 */ 0241,0203,01,0303,01,077,0120,01,0,0,
+    /*  2810 */ 0241,0203,05,0303,01,077,0120,01,0,0,
+    /*  2820 */ 0241,0203,011,0303,01,077,0120,01,0,0,
+    /*  2830 */ 0241,0203,01,0301,01,037,0120,01,0,0,
+    /*  2840 */ 0241,0203,05,0301,01,037,0120,01,0,0,
+    /*  2850 */ 0241,0203,011,0301,01,037,0120,01,0,0,
+    /*  2860 */ 0241,0203,021,0301,01,037,0120,01,0,0,
+    /*  2870 */ 0241,0203,025,0301,01,037,0120,01,0,0,
+    /*  2880 */ 0241,0203,031,0301,01,037,0120,01,0,0,
+    /*  2890 */ 0241,0203,01,0303,01,076,0120,01,0,0,
+    /*  2900 */ 0241,0203,05,0303,01,076,0120,01,0,0,
+    /*  2910 */ 0241,0203,011,0303,01,076,0120,01,0,0,
+    /*  2920 */ 0241,0203,01,0301,01,036,0120,01,0,0,
+    /*  2930 */ 0241,0203,05,0301,01,036,0120,01,0,0,
+    /*  2940 */ 0241,0203,011,0301,01,036,0120,01,0,0,
+    /*  2950 */ 0241,0203,021,0301,01,036,0120,01,0,0,
+    /*  2960 */ 0241,0203,025,0301,01,036,0120,01,0,0,
+    /*  2970 */ 0241,0203,031,0301,01,036,0120,01,0,0,
+    /*  2980 */ 0241,0203,021,0303,01,076,0120,01,0,0,
+    /*  2990 */ 0241,0203,025,0303,01,076,0120,01,0,0,
+    /*  3000 */ 0241,0203,031,0303,01,076,0120,01,0,0,
+    /*  3010 */ 0241,0203,021,0303,01,077,0120,01,0,0,
+    /*  3020 */ 0241,0203,025,0303,01,077,0120,01,0,0,
+    /*  3030 */ 0241,0203,031,0303,01,077,0120,01,0,0,
+    /*  3040 */ 0241,0203,01,0303,01,077,0120,01,05,0,
+    /*  3050 */ 0241,0203,05,0303,01,077,0120,01,05,0,
+    /*  3060 */ 0241,0203,011,0303,01,077,0120,01,05,0,
+    /*  3070 */ 0241,0203,01,0301,01,037,0120,01,05,0,
+    /*  3080 */ 0241,0203,05,0301,01,037,0120,01,05,0,
+    /*  3090 */ 0241,0203,011,0301,01,037,0120,01,05,0,
+    /*  3100 */ 0241,0203,021,0301,01,037,0120,01,05,0,
+    /*  3110 */ 0241,0203,025,0301,01,037,0120,01,05,0,
+    /*  3120 */ 0241,0203,031,0301,01,037,0120,01,05,0,
+    /*  3130 */ 0241,0203,01,0303,01,076,0120,01,05,0,
+    /*  3140 */ 0241,0203,05,0303,01,076,0120,01,05,0,
+    /*  3150 */ 0241,0203,011,0303,01,076,0120,01,05,0,
+    /*  3160 */ 0241,0203,01,0301,01,036,0120,01,05,0,
+    /*  3170 */ 0241,0203,05,0301,01,036,0120,01,05,0,
+    /*  3180 */ 0241,0203,011,0301,01,036,0120,01,05,0,
+    /*  3190 */ 0241,0203,021,0301,01,036,0120,01,05,0,
+    /*  3200 */ 0241,0203,025,0301,01,036,0120,01,05,0,
+    /*  3210 */ 0241,0203,031,0301,01,036,0120,01,05,0,
+    /*  3220 */ 0241,0203,021,0303,01,076,0120,01,05,0,
+    /*  3230 */ 0241,0203,025,0303,01,076,0120,01,05,0,
+    /*  3240 */ 0241,0203,031,0303,01,076,0120,01,05,0,
+    /*  3250 */ 0241,0203,021,0303,01,077,0120,01,05,0,
+    /*  3260 */ 0241,0203,025,0303,01,077,0120,01,05,0,
+    /*  3270 */ 0241,0203,031,0303,01,077,0120,01,05,0,
+    /*  3280 */ 0241,0203,01,0303,01,077,0120,01,06,0,
+    /*  3290 */ 0241,0203,05,0303,01,077,0120,01,06,0,
+    /*  3300 */ 0241,0203,011,0303,01,077,0120,01,06,0,
+    /*  3310 */ 0241,0203,01,0301,01,037,0120,01,06,0,
+    /*  3320 */ 0241,0203,05,0301,01,037,0120,01,06,0,
+    /*  3330 */ 0241,0203,011,0301,01,037,0120,01,06,0,
+    /*  3340 */ 0241,0203,021,0301,01,037,0120,01,06,0,
+    /*  3350 */ 0241,0203,025,0301,01,037,0120,01,06,0,
+    /*  3360 */ 0241,0203,031,0301,01,037,0120,01,06,0,
+    /*  3370 */ 0241,0203,01,0303,01,076,0120,01,06,0,
+    /*  3380 */ 0241,0203,05,0303,01,076,0120,01,06,0,
+    /*  3390 */ 0241,0203,011,0303,01,076,0120,01,06,0,
+    /*  3400 */ 0241,0203,01,0301,01,036,0120,01,06,0,
+    /*  3410 */ 0241,0203,05,0301,01,036,0120,01,06,0,
+    /*  3420 */ 0241,0203,011,0301,01,036,0120,01,06,0,
+    /*  3430 */ 0241,0203,021,0301,01,036,0120,01,06,0,
+    /*  3440 */ 0241,0203,025,0301,01,036,0120,01,06,0,
+    /*  3450 */ 0241,0203,031,0301,01,036,0120,01,06,0,
+    /*  3460 */ 0241,0203,021,0303,01,076,0120,01,06,0,
+    /*  3470 */ 0241,0203,025,0303,01,076,0120,01,06,0,
+    /*  3480 */ 0241,0203,031,0303,01,076,0120,01,06,0,
+    /*  3490 */ 0241,0203,021,0303,01,077,0120,01,06,0,
+    /*  3500 */ 0241,0203,025,0303,01,077,0120,01,06,0,
+    /*  3510 */ 0241,0203,031,0303,01,077,0120,01,06,0,
+    /*  3520 */ 0241,0203,01,0303,01,077,0120,01,02,0,
+    /*  3530 */ 0241,0203,05,0303,01,077,0120,01,02,0,
+    /*  3540 */ 0241,0203,011,0303,01,077,0120,01,02,0,
+    /*  3550 */ 0241,0203,01,0301,01,037,0120,01,02,0,
+    /*  3560 */ 0241,0203,05,0301,01,037,0120,01,02,0,
+    /*  3570 */ 0241,0203,011,0301,01,037,0120,01,02,0,
+    /*  3580 */ 0241,0203,021,0301,01,037,0120,01,02,0,
+    /*  3590 */ 0241,0203,025,0301,01,037,0120,01,02,0,
+    /*  3600 */ 0241,0203,031,0301,01,037,0120,01,02,0,
+    /*  3610 */ 0241,0203,01,0303,01,076,0120,01,02,0,
+    /*  3620 */ 0241,0203,05,0303,01,076,0120,01,02,0,
+    /*  3630 */ 0241,0203,011,0303,01,076,0120,01,02,0,
+    /*  3640 */ 0241,0203,01,0301,01,036,0120,01,02,0,
+    /*  3650 */ 0241,0203,05,0301,01,036,0120,01,02,0,
+    /*  3660 */ 0241,0203,011,0301,01,036,0120,01,02,0,
+    /*  3670 */ 0241,0203,021,0301,01,036,0120,01,02,0,
+    /*  3680 */ 0241,0203,025,0301,01,036,0120,01,02,0,
+    /*  3690 */ 0241,0203,031,0301,01,036,0120,01,02,0,
+    /*  3700 */ 0241,0203,021,0303,01,076,0120,01,02,0,
+    /*  3710 */ 0241,0203,025,0303,01,076,0120,01,02,0,
+    /*  3720 */ 0241,0203,031,0303,01,076,0120,01,02,0,
+    /*  3730 */ 0241,0203,021,0303,01,077,0120,01,02,0,
+    /*  3740 */ 0241,0203,025,0303,01,077,0120,01,02,0,
+    /*  3750 */ 0241,0203,031,0303,01,077,0120,01,02,0,
+    /*  3760 */ 0241,0203,01,0303,01,077,0120,01,01,0,
+    /*  3770 */ 0241,0203,05,0303,01,077,0120,01,01,0,
+    /*  3780 */ 0241,0203,011,0303,01,077,0120,01,01,0,
+    /*  3790 */ 0241,0203,01,0301,01,037,0120,01,01,0,
+    /*  3800 */ 0241,0203,05,0301,01,037,0120,01,01,0,
+    /*  3810 */ 0241,0203,011,0301,01,037,0120,01,01,0,
+    /*  3820 */ 0241,0203,021,0301,01,037,0120,01,01,0,
+    /*  3830 */ 0241,0203,025,0301,01,037,0120,01,01,0,
+    /*  3840 */ 0241,0203,031,0301,01,037,0120,01,01,0,
+    /*  3850 */ 0241,0203,01,0303,01,076,0120,01,01,0,
+    /*  3860 */ 0241,0203,05,0303,01,076,0120,01,01,0,
+    /*  3870 */ 0241,0203,011,0303,01,076,0120,01,01,0,
+    /*  3880 */ 0241,0203,01,0301,01,036,0120,01,01,0,
+    /*  3890 */ 0241,0203,05,0301,01,036,0120,01,01,0,
+    /*  3900 */ 0241,0203,011,0301,01,036,0120,01,01,0,
+    /*  3910 */ 0241,0203,021,0301,01,036,0120,01,01,0,
+    /*  3920 */ 0241,0203,025,0301,01,036,0120,01,01,0,
+    /*  3930 */ 0241,0203,031,0301,01,036,0120,01,01,0,
+    /*  3940 */ 0241,0203,021,0303,01,076,0120,01,01,0,
+    /*  3950 */ 0241,0203,025,0303,01,076,0120,01,01,0,
+    /*  3960 */ 0241,0203,031,0303,01,076,0120,01,01,0,
+    /*  3970 */ 0241,0203,021,0303,01,077,0120,01,01,0,
+    /*  3980 */ 0241,0203,025,0303,01,077,0120,01,01,0,
+    /*  3990 */ 0241,0203,031,0303,01,077,0120,01,01,0,
+    /*  4000 */ 0241,0203,01,0303,01,077,0120,01,04,0,
+    /*  4010 */ 0241,0203,05,0303,01,077,0120,01,04,0,
+    /*  4020 */ 0241,0203,011,0303,01,077,0120,01,04,0,
+    /*  4030 */ 0241,0203,01,0301,01,037,0120,01,04,0,
+    /*  4040 */ 0241,0203,05,0301,01,037,0120,01,04,0,
+    /*  4050 */ 0241,0203,011,0301,01,037,0120,01,04,0,
+    /*  4060 */ 0241,0203,021,0301,01,037,0120,01,04,0,
+    /*  4070 */ 0241,0203,025,0301,01,037,0120,01,04,0,
+    /*  4080 */ 0241,0203,031,0301,01,037,0120,01,04,0,
+    /*  4090 */ 0241,0203,01,0303,01,076,0120,01,04,0,
+    /*  4100 */ 0241,0203,05,0303,01,076,0120,01,04,0,
+    /*  4110 */ 0241,0203,011,0303,01,076,0120,01,04,0,
+    /*  4120 */ 0241,0203,01,0301,01,036,0120,01,04,0,
+    /*  4130 */ 0241,0203,05,0301,01,036,0120,01,04,0,
+    /*  4140 */ 0241,0203,011,0301,01,036,0120,01,04,0,
+    /*  4150 */ 0241,0203,021,0301,01,036,0120,01,04,0,
+    /*  4160 */ 0241,0203,025,0301,01,036,0120,01,04,0,
+    /*  4170 */ 0241,0203,031,0301,01,036,0120,01,04,0,
+    /*  4180 */ 0241,0203,021,0303,01,076,0120,01,04,0,
+    /*  4190 */ 0241,0203,025,0303,01,076,0120,01,04,0,
+    /*  4200 */ 0241,0203,031,0303,01,076,0120,01,04,0,
+    /*  4210 */ 0241,0203,021,0303,01,077,0120,01,04,0,
+    /*  4220 */ 0241,0203,025,0303,01,077,0120,01,04,0,
+    /*  4230 */ 0241,0203,031,0303,01,077,0120,01,04,0,
+    /*  4240 */ 0324,0361,03,017,072,027,0101,026,0,
+    /*  4249 */ 0323,0361,03,017,072,024,0101,026,0,
+    /*  4258 */ 0317,0361,03,017,072,026,0101,026,0,
+    /*  4267 */ 0324,0361,03,017,072,026,0101,026,0,
+    /*  4276 */ 0324,0361,03,017,072,025,0101,026,0,
+    /*  4285 */ 0325,0361,03,017,072,040,0110,026,0,
+    /*  4294 */ 0317,0361,03,017,072,042,0110,026,0,
+    /*  4303 */ 0324,0361,03,017,072,042,0110,026,0,
+    /*  4312 */ 0261,01,041,01,0302,0120,01,020,0,
+    /*  4321 */ 0260,01,041,01,0302,0110,01,020,0,
+    /*  4330 */ 0261,01,045,01,0302,0120,01,020,0,
+    /*  4339 */ 0260,01,045,01,0302,0110,01,020,0,
+    /*  4348 */ 0261,01,041,01,0302,0120,01,0,0,
+    /*  4357 */ 0260,01,041,01,0302,0110,01,0,0,
+    /*  4366 */ 0261,01,045,01,0302,0120,01,0,0,
+    /*  4375 */ 0260,01,045,01,0302,0110,01,0,0,
+    /*  4384 */ 0261,01,041,01,0302,0120,01,01,0,
+    /*  4393 */ 0260,01,041,01,0302,0110,01,01,0,
+    /*  4402 */ 0261,01,045,01,0302,0120,01,01,0,
+    /*  4411 */ 0260,01,045,01,0302,0110,01,01,0,
+    /*  4420 */ 0261,01,041,01,0302,0120,01,02,0,
+    /*  4429 */ 0260,01,041,01,0302,0110,01,02,0,
+    /*  4438 */ 0261,01,045,01,0302,0120,01,02,0,
+    /*  4447 */ 0260,01,045,01,0302,0110,01,02,0,
+    /*  4456 */ 0261,01,041,01,0302,0120,01,03,0,
+    /*  4465 */ 0260,01,041,01,0302,0110,01,03,0,
+    /*  4474 */ 0261,01,045,01,0302,0120,01,03,0,
+    /*  4483 */ 0260,01,045,01,0302,0110,01,03,0,
+    /*  4492 */ 0261,01,041,01,0302,0120,01,04,0,
+    /*  4501 */ 0260,01,041,01,0302,0110,01,04,0,
+    /*  4510 */ 0261,01,045,01,0302,0120,01,04,0,
+    /*  4519 */ 0260,01,045,01,0302,0110,01,04,0,
+    /*  4528 */ 0261,01,041,01,0302,0120,01,05,0,
+    /*  4537 */ 0260,01,041,01,0302,0110,01,05,0,
+    /*  4546 */ 0261,01,045,01,0302,0120,01,05,0,
+    /*  4555 */ 0260,01,045,01,0302,0110,01,05,0,
+    /*  4564 */ 0261,01,041,01,0302,0120,01,06,0,
+    /*  4573 */ 0260,01,041,01,0302,0110,01,06,0,
+    /*  4582 */ 0261,01,045,01,0302,0120,01,06,0,
+    /*  4591 */ 0260,01,045,01,0302,0110,01,06,0,
+    /*  4600 */ 0261,01,041,01,0302,0120,01,07,0,
+    /*  4609 */ 0260,01,041,01,0302,0110,01,07,0,
+    /*  4618 */ 0261,01,045,01,0302,0120,01,07,0,
+    /*  4627 */ 0260,01,045,01,0302,0110,01,07,0,
+    /*  4636 */ 0261,01,041,01,0302,0120,01,010,0,
+    /*  4645 */ 0260,01,041,01,0302,0110,01,010,0,
+    /*  4654 */ 0261,01,045,01,0302,0120,01,010,0,
+    /*  4663 */ 0260,01,045,01,0302,0110,01,010,0,
+    /*  4672 */ 0261,01,041,01,0302,0120,01,011,0,
+    /*  4681 */ 0260,01,041,01,0302,0110,01,011,0,
+    /*  4690 */ 0261,01,045,01,0302,0120,01,011,0,
+    /*  4699 */ 0260,01,045,01,0302,0110,01,011,0,
+    /*  4708 */ 0261,01,041,01,0302,0120,01,012,0,
+    /*  4717 */ 0260,01,041,01,0302,0110,01,012,0,
+    /*  4726 */ 0261,01,045,01,0302,0120,01,012,0,
+    /*  4735 */ 0260,01,045,01,0302,0110,01,012,0,
+    /*  4744 */ 0261,01,041,01,0302,0120,01,013,0,
+    /*  4753 */ 0260,01,041,01,0302,0110,01,013,0,
+    /*  4762 */ 0261,01,045,01,0302,0120,01,013,0,
+    /*  4771 */ 0260,01,045,01,0302,0110,01,013,0,
+    /*  4780 */ 0261,01,041,01,0302,0120,01,014,0,
+    /*  4789 */ 0260,01,041,01,0302,0110,01,014,0,
+    /*  4798 */ 0261,01,045,01,0302,0120,01,014,0,
+    /*  4807 */ 0260,01,045,01,0302,0110,01,014,0,
+    /*  4816 */ 0261,01,041,01,0302,0120,01,015,0,
+    /*  4825 */ 0260,01,041,01,0302,0110,01,015,0,
+    /*  4834 */ 0261,01,045,01,0302,0120,01,015,0,
+    /*  4843 */ 0260,01,045,01,0302,0110,01,015,0,
+    /*  4852 */ 0261,01,041,01,0302,0120,01,016,0,
+    /*  4861 */ 0260,01,041,01,0302,0110,01,016,0,
+    /*  4870 */ 0261,01,045,01,0302,0120,01,016,0,
+    /*  4879 */ 0260,01,045,01,0302,0110,01,016,0,
+    /*  4888 */ 0261,01,041,01,0302,0120,01,017,0,
+    /*  4897 */ 0260,01,041,01,0302,0110,01,017,0,
+    /*  4906 */ 0261,01,045,01,0302,0120,01,017,0,
+    /*  4915 */ 0260,01,045,01,0302,0110,01,017,0,
+    /*  4924 */ 0261,01,041,01,0302,0120,01,021,0,
+    /*  4933 */ 0260,01,041,01,0302,0110,01,021,0,
+    /*  4942 */ 0261,01,045,01,0302,0120,01,021,0,
+    /*  4951 */ 0260,01,045,01,0302,0110,01,021,0,
+    /*  4960 */ 0261,01,041,01,0302,0120,01,022,0,
+    /*  4969 */ 0260,01,041,01,0302,0110,01,022,0,
+    /*  4978 */ 0261,01,045,01,0302,0120,01,022,0,
+    /*  4987 */ 0260,01,045,01,0302,0110,01,022,0,
+    /*  4996 */ 0261,01,041,01,0302,0120,01,023,0,
+    /*  5005 */ 0260,01,041,01,0302,0110,01,023,0,
+    /*  5014 */ 0261,01,045,01,0302,0120,01,023,0,
+    /*  5023 */ 0260,01,045,01,0302,0110,01,023,0,
+    /*  5032 */ 0261,01,041,01,0302,0120,01,024,0,
+    /*  5041 */ 0260,01,041,01,0302,0110,01,024,0,
+    /*  5050 */ 0261,01,045,01,0302,0120,01,024,0,
+    /*  5059 */ 0260,01,045,01,0302,0110,01,024,0,
+    /*  5068 */ 0261,01,041,01,0302,0120,01,025,0,
+    /*  5077 */ 0260,01,041,01,0302,0110,01,025,0,
+    /*  5086 */ 0261,01,045,01,0302,0120,01,025,0,
+    /*  5095 */ 0260,01,045,01,0302,0110,01,025,0,
+    /*  5104 */ 0261,01,041,01,0302,0120,01,026,0,
+    /*  5113 */ 0260,01,041,01,0302,0110,01,026,0,
+    /*  5122 */ 0261,01,045,01,0302,0120,01,026,0,
+    /*  5131 */ 0260,01,045,01,0302,0110,01,026,0,
+    /*  5140 */ 0261,01,041,01,0302,0120,01,027,0,
+    /*  5149 */ 0260,01,041,01,0302,0110,01,027,0,
+    /*  5158 */ 0261,01,045,01,0302,0120,01,027,0,
+    /*  5167 */ 0260,01,045,01,0302,0110,01,027,0,
+    /*  5176 */ 0261,01,041,01,0302,0120,01,030,0,
+    /*  5185 */ 0260,01,041,01,0302,0110,01,030,0,
+    /*  5194 */ 0261,01,045,01,0302,0120,01,030,0,
+    /*  5203 */ 0260,01,045,01,0302,0110,01,030,0,
+    /*  5212 */ 0261,01,041,01,0302,0120,01,031,0,
+    /*  5221 */ 0260,01,041,01,0302,0110,01,031,0,
+    /*  5230 */ 0261,01,045,01,0302,0120,01,031,0,
+    /*  5239 */ 0260,01,045,01,0302,0110,01,031,0,
+    /*  5248 */ 0261,01,041,01,0302,0120,01,032,0,
+    /*  5257 */ 0260,01,041,01,0302,0110,01,032,0,
+    /*  5266 */ 0261,01,045,01,0302,0120,01,032,0,
+    /*  5275 */ 0260,01,045,01,0302,0110,01,032,0,
+    /*  5284 */ 0261,01,041,01,0302,0120,01,033,0,
+    /*  5293 */ 0260,01,041,01,0302,0110,01,033,0,
+    /*  5302 */ 0261,01,045,01,0302,0120,01,033,0,
+    /*  5311 */ 0260,01,045,01,0302,0110,01,033,0,
+    /*  5320 */ 0261,01,041,01,0302,0120,01,034,0,
+    /*  5329 */ 0260,01,041,01,0302,0110,01,034,0,
+    /*  5338 */ 0261,01,045,01,0302,0120,01,034,0,
+    /*  5347 */ 0260,01,045,01,0302,0110,01,034,0,
+    /*  5356 */ 0261,01,041,01,0302,0120,01,035,0,
+    /*  5365 */ 0260,01,041,01,0302,0110,01,035,0,
+    /*  5374 */ 0261,01,045,01,0302,0120,01,035,0,
+    /*  5383 */ 0260,01,045,01,0302,0110,01,035,0,
+    /*  5392 */ 0261,01,041,01,0302,0120,01,036,0,
+    /*  5401 */ 0260,01,041,01,0302,0110,01,036,0,
+    /*  5410 */ 0261,01,045,01,0302,0120,01,036,0,
+    /*  5419 */ 0260,01,045,01,0302,0110,01,036,0,
+    /*  5428 */ 0261,01,041,01,0302,0120,01,037,0,
+    /*  5437 */ 0260,01,041,01,0302,0110,01,037,0,
+    /*  5446 */ 0261,01,045,01,0302,0120,01,037,0,
+    /*  5455 */ 0260,01,045,01,0302,0110,01,037,0,
+    /*  5464 */ 0261,01,040,01,0302,0120,01,020,0,
+    /*  5473 */ 0260,01,040,01,0302,0110,01,020,0,
+    /*  5482 */ 0261,01,044,01,0302,0120,01,020,0,
+    /*  5491 */ 0260,01,044,01,0302,0110,01,020,0,
+    /*  5500 */ 0261,01,040,01,0302,0120,01,0,0,
+    /*  5509 */ 0260,01,040,01,0302,0110,01,0,0,
+    /*  5518 */ 0261,01,044,01,0302,0120,01,0,0,
+    /*  5527 */ 0260,01,044,01,0302,0110,01,0,0,
+    /*  5536 */ 0261,01,040,01,0302,0120,01,01,0,
+    /*  5545 */ 0260,01,040,01,0302,0110,01,01,0,
+    /*  5554 */ 0261,01,044,01,0302,0120,01,01,0,
+    /*  5563 */ 0260,01,044,01,0302,0110,01,01,0,
+    /*  5572 */ 0261,01,040,01,0302,0120,01,02,0,
+    /*  5581 */ 0260,01,040,01,0302,0110,01,02,0,
+    /*  5590 */ 0261,01,044,01,0302,0120,01,02,0,
+    /*  5599 */ 0260,01,044,01,0302,0110,01,02,0,
+    /*  5608 */ 0261,01,040,01,0302,0120,01,03,0,
+    /*  5617 */ 0260,01,040,01,0302,0110,01,03,0,
+    /*  5626 */ 0261,01,044,01,0302,0120,01,03,0,
+    /*  5635 */ 0260,01,044,01,0302,0110,01,03,0,
+    /*  5644 */ 0261,01,040,01,0302,0120,01,04,0,
+    /*  5653 */ 0260,01,040,01,0302,0110,01,04,0,
+    /*  5662 */ 0261,01,044,01,0302,0120,01,04,0,
+    /*  5671 */ 0260,01,044,01,0302,0110,01,04,0,
+    /*  5680 */ 0261,01,040,01,0302,0120,01,05,0,
+    /*  5689 */ 0260,01,040,01,0302,0110,01,05,0,
+    /*  5698 */ 0261,01,044,01,0302,0120,01,05,0,
+    /*  5707 */ 0260,01,044,01,0302,0110,01,05,0,
+    /*  5716 */ 0261,01,040,01,0302,0120,01,06,0,
+    /*  5725 */ 0260,01,040,01,0302,0110,01,06,0,
+    /*  5734 */ 0261,01,044,01,0302,0120,01,06,0,
+    /*  5743 */ 0260,01,044,01,0302,0110,01,06,0,
+    /*  5752 */ 0261,01,040,01,0302,0120,01,07,0,
+    /*  5761 */ 0260,01,040,01,0302,0110,01,07,0,
+    /*  5770 */ 0261,01,044,01,0302,0120,01,07,0,
+    /*  5779 */ 0260,01,044,01,0302,0110,01,07,0,
+    /*  5788 */ 0261,01,040,01,0302,0120,01,010,0,
+    /*  5797 */ 0260,01,040,01,0302,0110,01,010,0,
+    /*  5806 */ 0261,01,044,01,0302,0120,01,010,0,
+    /*  5815 */ 0260,01,044,01,0302,0110,01,010,0,
+    /*  5824 */ 0261,01,040,01,0302,0120,01,011,0,
+    /*  5833 */ 0260,01,040,01,0302,0110,01,011,0,
+    /*  5842 */ 0261,01,044,01,0302,0120,01,011,0,
+    /*  5851 */ 0260,01,044,01,0302,0110,01,011,0,
+    /*  5860 */ 0261,01,040,01,0302,0120,01,012,0,
+    /*  5869 */ 0260,01,040,01,0302,0110,01,012,0,
+    /*  5878 */ 0261,01,044,01,0302,0120,01,012,0,
+    /*  5887 */ 0260,01,044,01,0302,0110,01,012,0,
+    /*  5896 */ 0261,01,040,01,0302,0120,01,013,0,
+    /*  5905 */ 0260,01,040,01,0302,0110,01,013,0,
+    /*  5914 */ 0261,01,044,01,0302,0120,01,013,0,
+    /*  5923 */ 0260,01,044,01,0302,0110,01,013,0,
+    /*  5932 */ 0261,01,040,01,0302,0120,01,014,0,
+    /*  5941 */ 0260,01,040,01,0302,0110,01,014,0,
+    /*  5950 */ 0261,01,044,01,0302,0120,01,014,0,
+    /*  5959 */ 0260,01,044,01,0302,0110,01,014,0,
+    /*  5968 */ 0261,01,040,01,0302,0120,01,015,0,
+    /*  5977 */ 0260,01,040,01,0302,0110,01,015,0,
+    /*  5986 */ 0261,01,044,01,0302,0120,01,015,0,
+    /*  5995 */ 0260,01,044,01,0302,0110,01,015,0,
+    /*  6004 */ 0261,01,040,01,0302,0120,01,016,0,
+    /*  6013 */ 0260,01,040,01,0302,0110,01,016,0,
+    /*  6022 */ 0261,01,044,01,0302,0120,01,016,0,
+    /*  6031 */ 0260,01,044,01,0302,0110,01,016,0,
+    /*  6040 */ 0261,01,040,01,0302,0120,01,017,0,
+    /*  6049 */ 0260,01,040,01,0302,0110,01,017,0,
+    /*  6058 */ 0261,01,044,01,0302,0120,01,017,0,
+    /*  6067 */ 0260,01,044,01,0302,0110,01,017,0,
+    /*  6076 */ 0261,01,040,01,0302,0120,01,021,0,
+    /*  6085 */ 0260,01,040,01,0302,0110,01,021,0,
+    /*  6094 */ 0261,01,044,01,0302,0120,01,021,0,
+    /*  6103 */ 0260,01,044,01,0302,0110,01,021,0,
+    /*  6112 */ 0261,01,040,01,0302,0120,01,022,0,
+    /*  6121 */ 0260,01,040,01,0302,0110,01,022,0,
+    /*  6130 */ 0261,01,044,01,0302,0120,01,022,0,
+    /*  6139 */ 0260,01,044,01,0302,0110,01,022,0,
+    /*  6148 */ 0261,01,040,01,0302,0120,01,023,0,
+    /*  6157 */ 0260,01,040,01,0302,0110,01,023,0,
+    /*  6166 */ 0261,01,044,01,0302,0120,01,023,0,
+    /*  6175 */ 0260,01,044,01,0302,0110,01,023,0,
+    /*  6184 */ 0261,01,040,01,0302,0120,01,024,0,
+    /*  6193 */ 0260,01,040,01,0302,0110,01,024,0,
+    /*  6202 */ 0261,01,044,01,0302,0120,01,024,0,
+    /*  6211 */ 0260,01,044,01,0302,0110,01,024,0,
+    /*  6220 */ 0261,01,040,01,0302,0120,01,025,0,
+    /*  6229 */ 0260,01,040,01,0302,0110,01,025,0,
+    /*  6238 */ 0261,01,044,01,0302,0120,01,025,0,
+    /*  6247 */ 0260,01,044,01,0302,0110,01,025,0,
+    /*  6256 */ 0261,01,040,01,0302,0120,01,026,0,
+    /*  6265 */ 0260,01,040,01,0302,0110,01,026,0,
+    /*  6274 */ 0261,01,044,01,0302,0120,01,026,0,
+    /*  6283 */ 0260,01,044,01,0302,0110,01,026,0,
+    /*  6292 */ 0261,01,040,01,0302,0120,01,027,0,
+    /*  6301 */ 0260,01,040,01,0302,0110,01,027,0,
+    /*  6310 */ 0261,01,044,01,0302,0120,01,027,0,
+    /*  6319 */ 0260,01,044,01,0302,0110,01,027,0,
+    /*  6328 */ 0261,01,040,01,0302,0120,01,030,0,
+    /*  6337 */ 0260,01,040,01,0302,0110,01,030,0,
+    /*  6346 */ 0261,01,044,01,0302,0120,01,030,0,
+    /*  6355 */ 0260,01,044,01,0302,0110,01,030,0,
+    /*  6364 */ 0261,01,040,01,0302,0120,01,031,0,
+    /*  6373 */ 0260,01,040,01,0302,0110,01,031,0,
+    /*  6382 */ 0261,01,044,01,0302,0120,01,031,0,
+    /*  6391 */ 0260,01,044,01,0302,0110,01,031,0,
+    /*  6400 */ 0261,01,040,01,0302,0120,01,032,0,
+    /*  6409 */ 0260,01,040,01,0302,0110,01,032,0,
+    /*  6418 */ 0261,01,044,01,0302,0120,01,032,0,
+    /*  6427 */ 0260,01,044,01,0302,0110,01,032,0,
+    /*  6436 */ 0261,01,040,01,0302,0120,01,033,0,
+    /*  6445 */ 0260,01,040,01,0302,0110,01,033,0,
+    /*  6454 */ 0261,01,044,01,0302,0120,01,033,0,
+    /*  6463 */ 0260,01,044,01,0302,0110,01,033,0,
+    /*  6472 */ 0261,01,040,01,0302,0120,01,034,0,
+    /*  6481 */ 0260,01,040,01,0302,0110,01,034,0,
+    /*  6490 */ 0261,01,044,01,0302,0120,01,034,0,
+    /*  6499 */ 0260,01,044,01,0302,0110,01,034,0,
+    /*  6508 */ 0261,01,040,01,0302,0120,01,035,0,
+    /*  6517 */ 0260,01,040,01,0302,0110,01,035,0,
+    /*  6526 */ 0261,01,044,01,0302,0120,01,035,0,
+    /*  6535 */ 0260,01,044,01,0302,0110,01,035,0,
+    /*  6544 */ 0261,01,040,01,0302,0120,01,036,0,
+    /*  6553 */ 0260,01,040,01,0302,0110,01,036,0,
+    /*  6562 */ 0261,01,044,01,0302,0120,01,036,0,
+    /*  6571 */ 0260,01,044,01,0302,0110,01,036,0,
+    /*  6580 */ 0261,01,040,01,0302,0120,01,037,0,
+    /*  6589 */ 0260,01,040,01,0302,0110,01,037,0,
+    /*  6598 */ 0261,01,044,01,0302,0120,01,037,0,
+    /*  6607 */ 0260,01,044,01,0302,0110,01,037,0,
+    /*  6616 */ 0261,01,053,01,0302,0120,01,020,0,
+    /*  6625 */ 0260,01,053,01,0302,0110,01,020,0,
+    /*  6634 */ 0261,01,053,01,0302,0120,01,0,0,
+    /*  6643 */ 0260,01,053,01,0302,0110,01,0,0,
+    /*  6652 */ 0261,01,053,01,0302,0120,01,01,0,
+    /*  6661 */ 0260,01,053,01,0302,0110,01,01,0,
+    /*  6670 */ 0261,01,053,01,0302,0120,01,02,0,
+    /*  6679 */ 0260,01,053,01,0302,0110,01,02,0,
+    /*  6688 */ 0261,01,053,01,0302,0120,01,03,0,
+    /*  6697 */ 0260,01,053,01,0302,0110,01,03,0,
+    /*  6706 */ 0261,01,053,01,0302,0120,01,04,0,
+    /*  6715 */ 0260,01,053,01,0302,0110,01,04,0,
+    /*  6724 */ 0261,01,053,01,0302,0120,01,05,0,
+    /*  6733 */ 0260,01,053,01,0302,0110,01,05,0,
+    /*  6742 */ 0261,01,053,01,0302,0120,01,06,0,
+    /*  6751 */ 0260,01,053,01,0302,0110,01,06,0,
+    /*  6760 */ 0261,01,053,01,0302,0120,01,07,0,
+    /*  6769 */ 0260,01,053,01,0302,0110,01,07,0,
+    /*  6778 */ 0261,01,053,01,0302,0120,01,010,0,
+    /*  6787 */ 0260,01,053,01,0302,0110,01,010,0,
+    /*  6796 */ 0261,01,053,01,0302,0120,01,011,0,
+    /*  6805 */ 0260,01,053,01,0302,0110,01,011,0,
+    /*  6814 */ 0261,01,053,01,0302,0120,01,012,0,
+    /*  6823 */ 0260,01,053,01,0302,0110,01,012,0,
+    /*  6832 */ 0261,01,053,01,0302,0120,01,013,0,
+    /*  6841 */ 0260,01,053,01,0302,0110,01,013,0,
+    /*  6850 */ 0261,01,053,01,0302,0120,01,014,0,
+    /*  6859 */ 0260,01,053,01,0302,0110,01,014,0,
+    /*  6868 */ 0261,01,053,01,0302,0120,01,015,0,
+    /*  6877 */ 0260,01,053,01,0302,0110,01,015,0,
+    /*  6886 */ 0261,01,053,01,0302,0120,01,016,0,
+    /*  6895 */ 0260,01,053,01,0302,0110,01,016,0,
+    /*  6904 */ 0261,01,053,01,0302,0120,01,017,0,
+    /*  6913 */ 0260,01,053,01,0302,0110,01,017,0,
+    /*  6922 */ 0261,01,053,01,0302,0120,01,021,0,
+    /*  6931 */ 0260,01,053,01,0302,0110,01,021,0,
+    /*  6940 */ 0261,01,053,01,0302,0120,01,022,0,
+    /*  6949 */ 0260,01,053,01,0302,0110,01,022,0,
+    /*  6958 */ 0261,01,053,01,0302,0120,01,023,0,
+    /*  6967 */ 0260,01,053,01,0302,0110,01,023,0,
+    /*  6976 */ 0261,01,053,01,0302,0120,01,024,0,
+    /*  6985 */ 0260,01,053,01,0302,0110,01,024,0,
+    /*  6994 */ 0261,01,053,01,0302,0120,01,025,0,
+    /*  7003 */ 0260,01,053,01,0302,0110,01,025,0,
+    /*  7012 */ 0261,01,053,01,0302,0120,01,026,0,
+    /*  7021 */ 0260,01,053,01,0302,0110,01,026,0,
+    /*  7030 */ 0261,01,053,01,0302,0120,01,027,0,
+    /*  7039 */ 0260,01,053,01,0302,0110,01,027,0,
+    /*  7048 */ 0261,01,053,01,0302,0120,01,030,0,
+    /*  7057 */ 0260,01,053,01,0302,0110,01,030,0,
+    /*  7066 */ 0261,01,053,01,0302,0120,01,031,0,
+    /*  7075 */ 0260,01,053,01,0302,0110,01,031,0,
+    /*  7084 */ 0261,01,053,01,0302,0120,01,032,0,
+    /*  7093 */ 0260,01,053,01,0302,0110,01,032,0,
+    /*  7102 */ 0261,01,053,01,0302,0120,01,033,0,
+    /*  7111 */ 0260,01,053,01,0302,0110,01,033,0,
+    /*  7120 */ 0261,01,053,01,0302,0120,01,034,0,
+    /*  7129 */ 0260,01,053,01,0302,0110,01,034,0,
+    /*  7138 */ 0261,01,053,01,0302,0120,01,035,0,
+    /*  7147 */ 0260,01,053,01,0302,0110,01,035,0,
+    /*  7156 */ 0261,01,053,01,0302,0120,01,036,0,
+    /*  7165 */ 0260,01,053,01,0302,0110,01,036,0,
+    /*  7174 */ 0261,01,053,01,0302,0120,01,037,0,
+    /*  7183 */ 0260,01,053,01,0302,0110,01,037,0,
+    /*  7192 */ 0261,01,052,01,0302,0120,01,020,0,
+    /*  7201 */ 0260,01,052,01,0302,0110,01,020,0,
+    /*  7210 */ 0261,01,052,01,0302,0120,01,0,0,
+    /*  7219 */ 0260,01,052,01,0302,0110,01,0,0,
+    /*  7228 */ 0261,01,052,01,0302,0120,01,01,0,
+    /*  7237 */ 0260,01,052,01,0302,0110,01,01,0,
+    /*  7246 */ 0261,01,052,01,0302,0120,01,02,0,
+    /*  7255 */ 0260,01,052,01,0302,0110,01,02,0,
+    /*  7264 */ 0261,01,052,01,0302,0120,01,03,0,
+    /*  7273 */ 0260,01,052,01,0302,0110,01,03,0,
+    /*  7282 */ 0261,01,052,01,0302,0120,01,04,0,
+    /*  7291 */ 0260,01,052,01,0302,0110,01,04,0,
+    /*  7300 */ 0261,01,052,01,0302,0120,01,05,0,
+    /*  7309 */ 0260,01,052,01,0302,0110,01,05,0,
+    /*  7318 */ 0261,01,052,01,0302,0120,01,06,0,
+    /*  7327 */ 0260,01,052,01,0302,0110,01,06,0,
+    /*  7336 */ 0261,01,052,01,0302,0120,01,07,0,
+    /*  7345 */ 0260,01,052,01,0302,0110,01,07,0,
+    /*  7354 */ 0261,01,052,01,0302,0120,01,010,0,
+    /*  7363 */ 0260,01,052,01,0302,0110,01,010,0,
+    /*  7372 */ 0261,01,052,01,0302,0120,01,011,0,
+    /*  7381 */ 0260,01,052,01,0302,0110,01,011,0,
+    /*  7390 */ 0261,01,052,01,0302,0120,01,012,0,
+    /*  7399 */ 0260,01,052,01,0302,0110,01,012,0,
+    /*  7408 */ 0261,01,052,01,0302,0120,01,013,0,
+    /*  7417 */ 0260,01,052,01,0302,0110,01,013,0,
+    /*  7426 */ 0261,01,052,01,0302,0120,01,014,0,
+    /*  7435 */ 0260,01,052,01,0302,0110,01,014,0,
+    /*  7444 */ 0261,01,052,01,0302,0120,01,015,0,
+    /*  7453 */ 0260,01,052,01,0302,0110,01,015,0,
+    /*  7462 */ 0261,01,052,01,0302,0120,01,016,0,
+    /*  7471 */ 0260,01,052,01,0302,0110,01,016,0,
+    /*  7480 */ 0261,01,052,01,0302,0120,01,017,0,
+    /*  7489 */ 0260,01,052,01,0302,0110,01,017,0,
+    /*  7498 */ 0261,01,052,01,0302,0120,01,021,0,
+    /*  7507 */ 0260,01,052,01,0302,0110,01,021,0,
+    /*  7516 */ 0261,01,052,01,0302,0120,01,022,0,
+    /*  7525 */ 0260,01,052,01,0302,0110,01,022,0,
+    /*  7534 */ 0261,01,052,01,0302,0120,01,023,0,
+    /*  7543 */ 0260,01,052,01,0302,0110,01,023,0,
+    /*  7552 */ 0261,01,052,01,0302,0120,01,024,0,
+    /*  7561 */ 0260,01,052,01,0302,0110,01,024,0,
+    /*  7570 */ 0261,01,052,01,0302,0120,01,025,0,
+    /*  7579 */ 0260,01,052,01,0302,0110,01,025,0,
+    /*  7588 */ 0261,01,052,01,0302,0120,01,026,0,
+    /*  7597 */ 0260,01,052,01,0302,0110,01,026,0,
+    /*  7606 */ 0261,01,052,01,0302,0120,01,027,0,
+    /*  7615 */ 0260,01,052,01,0302,0110,01,027,0,
+    /*  7624 */ 0261,01,052,01,0302,0120,01,030,0,
+    /*  7633 */ 0260,01,052,01,0302,0110,01,030,0,
+    /*  7642 */ 0261,01,052,01,0302,0120,01,031,0,
+    /*  7651 */ 0260,01,052,01,0302,0110,01,031,0,
+    /*  7660 */ 0261,01,052,01,0302,0120,01,032,0,
+    /*  7669 */ 0260,01,052,01,0302,0110,01,032,0,
+    /*  7678 */ 0261,01,052,01,0302,0120,01,033,0,
+    /*  7687 */ 0260,01,052,01,0302,0110,01,033,0,
+    /*  7696 */ 0261,01,052,01,0302,0120,01,034,0,
+    /*  7705 */ 0260,01,052,01,0302,0110,01,034,0,
+    /*  7714 */ 0261,01,052,01,0302,0120,01,035,0,
+    /*  7723 */ 0260,01,052,01,0302,0110,01,035,0,
+    /*  7732 */ 0261,01,052,01,0302,0120,01,036,0,
+    /*  7741 */ 0260,01,052,01,0302,0110,01,036,0,
+    /*  7750 */ 0261,01,052,01,0302,0120,01,037,0,
+    /*  7759 */ 0260,01,052,01,0302,0110,01,037,0,
+    /*  7768 */ 0361,03,017,072,0104,0110,01,0,0,
+    /*  7777 */ 0361,03,017,072,0104,0110,01,01,0,
+    /*  7786 */ 0361,03,017,072,0104,0110,01,020,0,
+    /*  7795 */ 0361,03,017,072,0104,0110,01,021,0,
+    /*  7804 */ 0261,03,041,01,0104,0120,01,0,0,
+    /*  7813 */ 0260,03,041,01,0104,0110,01,0,0,
+    /*  7822 */ 0261,03,041,01,0104,0120,01,01,0,
+    /*  7831 */ 0260,03,041,01,0104,0110,01,01,0,
+    /*  7840 */ 0261,03,041,01,0104,0120,01,020,0,
+    /*  7849 */ 0260,03,041,01,0104,0110,01,020,0,
+    /*  7858 */ 0261,03,041,01,0104,0120,01,021,0,
+    /*  7867 */ 0260,03,041,01,0104,0110,01,021,0,
+    /*  7876 */ 0261,03,045,01,0104,0120,01,0,0,
+    /*  7885 */ 0260,03,045,01,0104,0110,01,0,0,
+    /*  7894 */ 0261,03,045,01,0104,0120,01,01,0,
+    /*  7903 */ 0260,03,045,01,0104,0110,01,01,0,
+    /*  7912 */ 0261,03,045,01,0104,0120,01,020,0,
+    /*  7921 */ 0260,03,045,01,0104,0110,01,020,0,
+    /*  7930 */ 0261,03,045,01,0104,0120,01,021,0,
+    /*  7939 */ 0260,03,045,01,0104,0110,01,021,0,
+    /*  7948 */ 0241,0203,041,0301,01,0104,0120,023,0,
+    /*  7957 */ 0240,0203,041,0301,01,0104,0110,022,0,
+    /*  7966 */ 0241,0203,045,0301,01,0104,0120,023,0,
+    /*  7975 */ 0240,0203,045,0301,01,0104,0110,022,0,
+    /*  7984 */ 0241,0203,051,0301,01,0104,0120,023,0,
+    /*  7993 */ 0240,0203,051,0301,01,0104,0110,022,0,
+    /*  8002 */ 0241,0203,01,0301,01,03,0120,023,0,
+    /*  8011 */ 0240,0203,01,0301,01,03,0110,022,0,
+    /*  8020 */ 0241,0203,05,0301,01,03,0120,023,0,
+    /*  8029 */ 0240,0203,05,0301,01,03,0110,022,0,
+    /*  8038 */ 0241,0203,011,0301,01,03,0120,023,0,
+    /*  8047 */ 0240,0203,011,0301,01,03,0110,022,0,
+    /*  8056 */ 0241,0203,021,0301,01,03,0120,023,0,
+    /*  8065 */ 0240,0203,021,0301,01,03,0110,022,0,
+    /*  8074 */ 0241,0203,025,0301,01,03,0120,023,0,
+    /*  8083 */ 0240,0203,025,0301,01,03,0110,022,0,
+    /*  8092 */ 0241,0203,031,0301,01,03,0120,023,0,
+    /*  8101 */ 0240,0203,031,0301,01,03,0110,022,0,
+    /*  8110 */ 0241,0201,021,0301,01,0302,0120,023,0,
+    /*  8119 */ 0241,0201,025,0301,01,0302,0120,023,0,
+    /*  8128 */ 0241,0201,031,0301,01,0302,0120,023,0,
+    /*  8137 */ 0241,0201,0,0301,01,0302,0120,023,0,
+    /*  8146 */ 0241,0201,04,0301,01,0302,0120,023,0,
+    /*  8155 */ 0241,0201,010,0301,01,0302,0120,023,0,
+    /*  8164 */ 0241,0201,023,0306,01,0302,0120,023,0,
+    /*  8173 */ 0241,0201,02,0306,01,0302,0120,023,0,
+    /*  8182 */ 0250,0203,01,0314,01,035,0101,022,0,
+    /*  8191 */ 0250,0203,05,0314,01,035,0101,022,0,
+    /*  8200 */ 0250,0203,011,0314,01,035,0101,022,0,
+    /*  8209 */ 0241,0203,01,0303,01,0102,0120,023,0,
+    /*  8218 */ 0240,0203,01,0303,01,0102,0110,022,0,
+    /*  8227 */ 0241,0203,05,0303,01,0102,0120,023,0,
+    /*  8236 */ 0240,0203,05,0303,01,0102,0110,022,0,
+    /*  8245 */ 0241,0203,011,0303,01,0102,0120,023,0,
+    /*  8254 */ 0240,0203,011,0303,01,0102,0110,022,0,
+    /*  8263 */ 0250,0203,05,0300,01,031,0101,022,0,
+    /*  8272 */ 0250,0203,011,0300,01,031,0101,022,0,
+    /*  8281 */ 0250,0203,05,0312,01,031,0101,022,0,
+    /*  8290 */ 0250,0203,011,0312,01,031,0101,022,0,
+    /*  8299 */ 0250,0203,011,0300,01,033,0101,022,0,
+    /*  8308 */ 0250,0203,011,0313,01,033,0101,022,0,
+    /*  8317 */ 0250,0203,025,0300,01,031,0101,022,0,
+    /*  8326 */ 0250,0203,031,0300,01,031,0101,022,0,
+    /*  8335 */ 0250,0203,025,0311,01,031,0101,022,0,
+    /*  8344 */ 0250,0203,031,0311,01,031,0101,022,0,
+    /*  8353 */ 0250,0203,031,0300,01,033,0101,022,0,
+    /*  8362 */ 0250,0203,031,0312,01,033,0101,022,0,
+    /*  8371 */ 0250,0203,05,0300,01,071,0101,022,0,
+    /*  8380 */ 0250,0203,011,0300,01,071,0101,022,0,
+    /*  8389 */ 0250,0203,05,0312,01,071,0101,022,0,
+    /*  8398 */ 0250,0203,011,0312,01,071,0101,022,0,
+    /*  8407 */ 0250,0203,011,0300,01,073,0101,022,0,
+    /*  8416 */ 0250,0203,011,0313,01,073,0101,022,0,
+    /*  8425 */ 0250,0203,025,0300,01,071,0101,022,0,
+    /*  8434 */ 0250,0203,031,0300,01,071,0101,022,0,
+    /*  8443 */ 0250,0203,025,0311,01,071,0101,022,0,
+    /*  8452 */ 0250,0203,031,0311,01,071,0101,022,0,
+    /*  8461 */ 0250,0203,031,0300,01,073,0101,022,0,
+    /*  8470 */ 0250,0203,031,0312,01,073,0101,022,0,
+    /*  8479 */ 0250,0203,041,0306,01,027,0101,022,0,
+    /*  8488 */ 0241,0203,021,0301,01,0124,0120,023,0,
+    /*  8497 */ 0240,0203,021,0301,01,0124,0110,022,0,
+    /*  8506 */ 0241,0203,025,0301,01,0124,0120,023,0,
+    /*  8515 */ 0240,0203,025,0301,01,0124,0110,022,0,
+    /*  8524 */ 0241,0203,031,0301,01,0124,0120,023,0,
+    /*  8533 */ 0240,0203,031,0301,01,0124,0110,022,0,
+    /*  8542 */ 0241,0203,01,0301,01,0124,0120,023,0,
+    /*  8551 */ 0240,0203,01,0301,01,0124,0110,022,0,
+    /*  8560 */ 0241,0203,05,0301,01,0124,0120,023,0,
+    /*  8569 */ 0240,0203,05,0301,01,0124,0110,022,0,
+    /*  8578 */ 0241,0203,011,0301,01,0124,0120,023,0,
+    /*  8587 */ 0240,0203,011,0301,01,0124,0110,022,0,
+    /*  8596 */ 0241,0203,021,0306,01,0125,0120,023,0,
+    /*  8605 */ 0240,0203,021,0306,01,0125,0110,022,0,
+    /*  8614 */ 0241,0203,01,0306,01,0125,0120,023,0,
+    /*  8623 */ 0240,0203,01,0306,01,0125,0110,022,0,
+    /*  8632 */ 0250,0203,021,0301,01,0146,0110,022,0,
+    /*  8641 */ 0250,0203,025,0301,01,0146,0110,022,0,
+    /*  8650 */ 0250,0203,031,0301,01,0146,0110,022,0,
+    /*  8659 */ 0250,0203,01,0301,01,0146,0110,022,0,
+    /*  8668 */ 0250,0203,05,0301,01,0146,0110,022,0,
+    /*  8677 */ 0250,0203,011,0301,01,0146,0110,022,0,
+    /*  8686 */ 0250,0203,021,0306,01,0147,0110,022,0,
+    /*  8695 */ 0250,0203,01,0306,01,0147,0110,022,0,
+    /*  8704 */ 0374,0250,0202,021,0306,01,0222,0110,0,
+    /*  8713 */ 0374,0250,0202,025,0306,01,0222,0110,0,
+    /*  8722 */ 0375,0250,0202,031,0306,01,0222,0110,0,
+    /*  8731 */ 0374,0250,0202,01,0306,01,0222,0110,0,
+    /*  8740 */ 0375,0250,0202,05,0306,01,0222,0110,0,
+    /*  8749 */ 0376,0250,0202,011,0306,01,0222,0110,0,
+    /*  8758 */ 0375,0250,0202,031,0306,01,0306,0201,0,
+    /*  8767 */ 0376,0250,0202,011,0306,01,0306,0201,0,
+    /*  8776 */ 0376,0250,0202,031,0306,01,0307,0201,0,
+    /*  8785 */ 0376,0250,0202,011,0306,01,0307,0201,0,
+    /*  8794 */ 0375,0250,0202,031,0306,01,0306,0202,0,
+    /*  8803 */ 0376,0250,0202,011,0306,01,0306,0202,0,
+    /*  8812 */ 0376,0250,0202,031,0306,01,0307,0202,0,
+    /*  8821 */ 0376,0250,0202,011,0306,01,0307,0202,0,
+    /*  8830 */ 0374,0250,0202,021,0306,01,0223,0110,0,
+    /*  8839 */ 0375,0250,0202,025,0306,01,0223,0110,0,
+    /*  8848 */ 0376,0250,0202,031,0306,01,0223,0110,0,
+    /*  8857 */ 0374,0250,0202,01,0306,01,0223,0110,0,
+    /*  8866 */ 0375,0250,0202,05,0306,01,0223,0110,0,
+    /*  8875 */ 0376,0250,0202,011,0306,01,0223,0110,0,
+    /*  8884 */ 0250,0203,021,0301,01,046,0110,022,0,
+    /*  8893 */ 0250,0203,025,0301,01,046,0110,022,0,
+    /*  8902 */ 0250,0203,031,0301,01,046,0110,022,0,
+    /*  8911 */ 0250,0203,01,0301,01,046,0110,022,0,
+    /*  8920 */ 0250,0203,05,0301,01,046,0110,022,0,
+    /*  8929 */ 0250,0203,011,0301,01,046,0110,022,0,
+    /*  8938 */ 0241,0203,021,0306,01,047,0120,023,0,
+    /*  8947 */ 0241,0203,01,0306,01,047,0120,023,0,
+    /*  8956 */ 0241,0203,05,0312,01,030,0120,023,0,
+    /*  8965 */ 0240,0203,05,0312,01,030,0110,022,0,
+    /*  8974 */ 0241,0203,011,0312,01,030,0120,023,0,
+    /*  8983 */ 0240,0203,011,0312,01,030,0110,022,0,
+    /*  8992 */ 0241,0203,011,0313,01,032,0120,023,0,
+    /*  9001 */ 0240,0203,011,0313,01,032,0110,022,0,
+    /*  9010 */ 0241,0203,025,0311,01,030,0120,023,0,
+    /*  9019 */ 0240,0203,025,0311,01,030,0110,022,0,
+    /*  9028 */ 0241,0203,031,0311,01,030,0120,023,0,
+    /*  9037 */ 0240,0203,031,0311,01,030,0110,022,0,
+    /*  9046 */ 0241,0203,031,0312,01,032,0120,023,0,
+    /*  9055 */ 0240,0203,031,0312,01,032,0110,022,0,
+    /*  9064 */ 0241,0203,05,0312,01,070,0120,023,0,
+    /*  9073 */ 0240,0203,05,0312,01,070,0110,022,0,
+    /*  9082 */ 0241,0203,011,0312,01,070,0120,023,0,
+    /*  9091 */ 0240,0203,011,0312,01,070,0110,022,0,
+    /*  9100 */ 0241,0203,011,0313,01,072,0120,023,0,
+    /*  9109 */ 0240,0203,011,0313,01,072,0110,022,0,
+    /*  9118 */ 0241,0203,025,0311,01,070,0120,023,0,
+    /*  9127 */ 0240,0203,025,0311,01,070,0110,022,0,
+    /*  9136 */ 0241,0203,031,0311,01,070,0120,023,0,
+    /*  9145 */ 0240,0203,031,0311,01,070,0110,022,0,
+    /*  9154 */ 0241,0203,031,0312,01,072,0120,023,0,
+    /*  9163 */ 0240,0203,031,0312,01,072,0110,022,0,
+    /*  9172 */ 0241,0203,01,0306,01,041,0120,023,0,
+    /*  9181 */ 0240,0203,01,0306,01,041,0110,022,0,
+    /*  9190 */ 0241,0203,041,0303,01,017,0120,023,0,
+    /*  9199 */ 0240,0203,041,0303,01,017,0110,022,0,
+    /*  9208 */ 0241,0203,045,0303,01,017,0120,023,0,
+    /*  9217 */ 0240,0203,045,0303,01,017,0110,022,0,
+    /*  9226 */ 0241,0203,051,0303,01,017,0120,023,0,
+    /*  9235 */ 0240,0203,051,0303,01,017,0110,022,0,
+    /*  9244 */ 0241,0203,01,0303,01,077,0120,023,0,
+    /*  9253 */ 0241,0203,05,0303,01,077,0120,023,0,
+    /*  9262 */ 0241,0203,011,0303,01,077,0120,023,0,
+    /*  9271 */ 0241,0203,01,0301,01,037,0120,023,0,
+    /*  9280 */ 0241,0203,05,0301,01,037,0120,023,0,
+    /*  9289 */ 0241,0203,011,0301,01,037,0120,023,0,
+    /*  9298 */ 0241,0203,021,0301,01,037,0120,023,0,
+    /*  9307 */ 0241,0203,025,0301,01,037,0120,023,0,
+    /*  9316 */ 0241,0203,031,0301,01,037,0120,023,0,
+    /*  9325 */ 0241,0203,01,0303,01,076,0120,023,0,
+    /*  9334 */ 0241,0203,05,0303,01,076,0120,023,0,
+    /*  9343 */ 0241,0203,011,0303,01,076,0120,023,0,
+    /*  9352 */ 0241,0203,01,0301,01,036,0120,023,0,
+    /*  9361 */ 0241,0203,05,0301,01,036,0120,023,0,
+    /*  9370 */ 0241,0203,011,0301,01,036,0120,023,0,
+    /*  9379 */ 0241,0203,021,0301,01,036,0120,023,0,
+    /*  9388 */ 0241,0203,025,0301,01,036,0120,023,0,
+    /*  9397 */ 0241,0203,031,0301,01,036,0120,023,0,
+    /*  9406 */ 0241,0203,021,0303,01,076,0120,023,0,
+    /*  9415 */ 0241,0203,025,0303,01,076,0120,023,0,
+    /*  9424 */ 0241,0203,031,0303,01,076,0120,023,0,
+    /*  9433 */ 0241,0203,021,0303,01,077,0120,023,0,
+    /*  9442 */ 0241,0203,025,0303,01,077,0120,023,0,
+    /*  9451 */ 0241,0203,031,0303,01,077,0120,023,0,
+    /*  9460 */ 0250,0203,021,0301,01,05,0110,022,0,
+    /*  9469 */ 0250,0203,025,0301,01,05,0110,022,0,
+    /*  9478 */ 0250,0203,031,0301,01,05,0110,022,0,
+    /*  9487 */ 0250,0203,01,0301,01,04,0110,022,0,
+    /*  9496 */ 0250,0203,05,0301,01,04,0110,022,0,
+    /*  9505 */ 0250,0203,011,0301,01,04,0110,022,0,
+    /*  9514 */ 0250,0203,025,0301,01,01,0110,022,0,
+    /*  9523 */ 0250,0203,031,0301,01,01,0110,022,0,
+    /*  9532 */ 0250,0203,025,0301,01,0,0110,022,0,
+    /*  9541 */ 0250,0203,031,0301,01,0,0110,022,0,
+    /*  9550 */ 0250,0203,041,0304,01,024,0101,022,0,
+    /*  9559 */ 0250,0203,01,0306,01,026,0101,022,0,
+    /*  9568 */ 0250,0203,021,0306,01,026,0101,022,0,
+    /*  9577 */ 0250,0203,041,0305,01,025,0101,022,0,
+    /*  9586 */ 0250,0201,041,0300,01,0305,0110,022,0,
+    /*  9595 */ 0374,0250,0202,01,0306,01,0220,0110,0,
+    /*  9604 */ 0375,0250,0202,05,0306,01,0220,0110,0,
+    /*  9613 */ 0376,0250,0202,011,0306,01,0220,0110,0,
+    /*  9622 */ 0374,0250,0202,021,0306,01,0220,0110,0,
+    /*  9631 */ 0374,0250,0202,025,0306,01,0220,0110,0,
+    /*  9640 */ 0375,0250,0202,031,0306,01,0220,0110,0,
+    /*  9649 */ 0374,0250,0202,01,0306,01,0221,0110,0,
+    /*  9658 */ 0375,0250,0202,05,0306,01,0221,0110,0,
+    /*  9667 */ 0376,0250,0202,011,0306,01,0221,0110,0,
+    /*  9676 */ 0374,0250,0202,021,0306,01,0221,0110,0,
+    /*  9685 */ 0375,0250,0202,025,0306,01,0221,0110,0,
+    /*  9694 */ 0376,0250,0202,031,0306,01,0221,0110,0,
+    /*  9703 */ 0241,0203,041,0304,01,040,0120,023,0,
+    /*  9712 */ 0240,0203,041,0304,01,040,0110,022,0,
+    /*  9721 */ 0241,0203,01,0306,01,042,0120,023,0,
+    /*  9730 */ 0240,0203,01,0306,01,042,0110,022,0,
+    /*  9739 */ 0241,0203,021,0306,01,042,0120,023,0,
+    /*  9748 */ 0240,0203,021,0306,01,042,0110,022,0,
+    /*  9757 */ 0241,0201,041,0305,01,0304,0120,023,0,
+    /*  9766 */ 0240,0201,041,0305,01,0304,0110,022,0,
+    /*  9775 */ 0240,0201,01,0301,01,0162,0211,022,0,
+    /*  9784 */ 0240,0201,01,0301,01,0162,0201,021,0,
+    /*  9793 */ 0240,0201,05,0301,01,0162,0211,022,0,
+    /*  9802 */ 0240,0201,05,0301,01,0162,0201,021,0,
+    /*  9811 */ 0240,0201,011,0301,01,0162,0211,022,0,
+    /*  9820 */ 0240,0201,011,0301,01,0162,0201,021,0,
+    /*  9829 */ 0240,0201,021,0301,01,0162,0211,022,0,
+    /*  9838 */ 0240,0201,021,0301,01,0162,0201,021,0,
+    /*  9847 */ 0240,0201,025,0301,01,0162,0211,022,0,
+    /*  9856 */ 0240,0201,025,0301,01,0162,0201,021,0,
+    /*  9865 */ 0240,0201,031,0301,01,0162,0211,022,0,
+    /*  9874 */ 0240,0201,031,0301,01,0162,0201,021,0,
+    /*  9883 */ 0240,0201,01,0301,01,0162,0210,022,0,
+    /*  9892 */ 0240,0201,01,0301,01,0162,0200,021,0,
+    /*  9901 */ 0240,0201,05,0301,01,0162,0210,022,0,
+    /*  9910 */ 0240,0201,05,0301,01,0162,0200,021,0,
+    /*  9919 */ 0240,0201,011,0301,01,0162,0210,022,0,
+    /*  9928 */ 0240,0201,011,0301,01,0162,0200,021,0,
+    /*  9937 */ 0240,0201,021,0301,01,0162,0210,022,0,
+    /*  9946 */ 0240,0201,021,0301,01,0162,0200,021,0,
+    /*  9955 */ 0240,0201,025,0301,01,0162,0210,022,0,
+    /*  9964 */ 0240,0201,025,0301,01,0162,0200,021,0,
+    /*  9973 */ 0240,0201,031,0301,01,0162,0210,022,0,
+    /*  9982 */ 0240,0201,031,0301,01,0162,0200,021,0,
+    /*  9991 */ 0374,0250,0202,01,0306,01,0240,0101,0,
+    /* 10000 */ 0375,0250,0202,05,0306,01,0240,0101,0,
+    /* 10009 */ 0376,0250,0202,011,0306,01,0240,0101,0,
+    /* 10018 */ 0374,0250,0202,021,0306,01,0240,0101,0,
+    /* 10027 */ 0374,0250,0202,025,0306,01,0240,0101,0,
+    /* 10036 */ 0375,0250,0202,031,0306,01,0240,0101,0,
+    /* 10045 */ 0374,0250,0202,01,0306,01,0241,0101,0,
+    /* 10054 */ 0375,0250,0202,05,0306,01,0241,0101,0,
+    /* 10063 */ 0376,0250,0202,011,0306,01,0241,0101,0,
+    /* 10072 */ 0374,0250,0202,021,0306,01,0241,0101,0,
+    /* 10081 */ 0375,0250,0202,025,0306,01,0241,0101,0,
+    /* 10090 */ 0376,0250,0202,031,0306,01,0241,0101,0,
+    /* 10099 */ 0250,0201,01,0301,01,0160,0110,022,0,
+    /* 10108 */ 0250,0201,05,0301,01,0160,0110,022,0,
+    /* 10117 */ 0250,0201,011,0301,01,0160,0110,022,0,
+    /* 10126 */ 0250,0201,042,0303,01,0160,0110,022,0,
+    /* 10135 */ 0250,0201,046,0303,01,0160,0110,022,0,
+    /* 10144 */ 0250,0201,052,0303,01,0160,0110,022,0,
+    /* 10153 */ 0250,0201,043,0303,01,0160,0110,022,0,
+    /* 10162 */ 0250,0201,047,0303,01,0160,0110,022,0,
+    /* 10171 */ 0250,0201,053,0303,01,0160,0110,022,0,
+    /* 10180 */ 0240,0201,01,0301,01,0162,0216,022,0,
+    /* 10189 */ 0240,0201,01,0301,01,0162,0206,021,0,
+    /* 10198 */ 0240,0201,05,0301,01,0162,0216,022,0,
+    /* 10207 */ 0240,0201,05,0301,01,0162,0206,021,0,
+    /* 10216 */ 0240,0201,011,0301,01,0162,0216,022,0,
+    /* 10225 */ 0240,0201,011,0301,01,0162,0206,021,0,
+    /* 10234 */ 0240,0201,041,0303,01,0163,0217,022,0,
+    /* 10243 */ 0240,0201,041,0303,01,0163,0207,021,0,
+    /* 10252 */ 0240,0201,045,0303,01,0163,0217,022,0,
+    /* 10261 */ 0240,0201,045,0303,01,0163,0207,021,0,
+    /* 10270 */ 0240,0201,051,0303,01,0163,0217,022,0,
+    /* 10279 */ 0240,0201,051,0303,01,0163,0207,021,0,
+    /* 10288 */ 0240,0201,021,0301,01,0163,0216,022,0,
+    /* 10297 */ 0240,0201,021,0301,01,0163,0206,021,0,
+    /* 10306 */ 0240,0201,025,0301,01,0163,0216,022,0,
+    /* 10315 */ 0240,0201,025,0301,01,0163,0206,021,0,
+    /* 10324 */ 0240,0201,031,0301,01,0163,0216,022,0,
+    /* 10333 */ 0240,0201,031,0301,01,0163,0206,021,0,
+    /* 10342 */ 0240,0201,041,0303,01,0161,0216,022,0,
+    /* 10351 */ 0240,0201,041,0303,01,0161,0206,021,0,
+    /* 10360 */ 0240,0201,045,0303,01,0161,0216,022,0,
+    /* 10369 */ 0240,0201,045,0303,01,0161,0206,021,0,
+    /* 10378 */ 0240,0201,051,0303,01,0161,0216,022,0,
+    /* 10387 */ 0240,0201,051,0303,01,0161,0206,021,0,
+    /* 10396 */ 0240,0201,01,0301,01,0162,0214,022,0,
+    /* 10405 */ 0240,0201,01,0301,01,0162,0204,021,0,
+    /* 10414 */ 0240,0201,05,0301,01,0162,0214,022,0,
+    /* 10423 */ 0240,0201,05,0301,01,0162,0204,021,0,
+    /* 10432 */ 0240,0201,011,0301,01,0162,0214,022,0,
+    /* 10441 */ 0240,0201,011,0301,01,0162,0204,021,0,
+    /* 10450 */ 0240,0201,021,0301,01,0162,0214,022,0,
+    /* 10459 */ 0240,0201,021,0301,01,0162,0204,021,0,
+    /* 10468 */ 0240,0201,025,0301,01,0162,0214,022,0,
+    /* 10477 */ 0240,0201,025,0301,01,0162,0204,021,0,
+    /* 10486 */ 0240,0201,031,0301,01,0162,0214,022,0,
+    /* 10495 */ 0240,0201,031,0301,01,0162,0204,021,0,
+    /* 10504 */ 0240,0201,041,0303,01,0161,0214,022,0,
+    /* 10513 */ 0240,0201,041,0303,01,0161,0204,021,0,
+    /* 10522 */ 0240,0201,045,0303,01,0161,0214,022,0,
+    /* 10531 */ 0240,0201,045,0303,01,0161,0204,021,0,
+    /* 10540 */ 0240,0201,051,0303,01,0161,0214,022,0,
+    /* 10549 */ 0240,0201,051,0303,01,0161,0204,021,0,
+    /* 10558 */ 0240,0201,01,0301,01,0162,0212,022,0,
+    /* 10567 */ 0240,0201,01,0301,01,0162,0202,021,0,
+    /* 10576 */ 0240,0201,05,0301,01,0162,0212,022,0,
+    /* 10585 */ 0240,0201,05,0301,01,0162,0202,021,0,
+    /* 10594 */ 0240,0201,011,0301,01,0162,0212,022,0,
+    /* 10603 */ 0240,0201,011,0301,01,0162,0202,021,0,
+    /* 10612 */ 0240,0201,041,0303,01,0163,0213,022,0,
+    /* 10621 */ 0240,0201,041,0303,01,0163,0203,021,0,
+    /* 10630 */ 0240,0201,045,0303,01,0163,0213,022,0,
+    /* 10639 */ 0240,0201,045,0303,01,0163,0203,021,0,
+    /* 10648 */ 0240,0201,051,0303,01,0163,0213,022,0,
+    /* 10657 */ 0240,0201,051,0303,01,0163,0203,021,0,
+    /* 10666 */ 0240,0201,021,0301,01,0163,0212,022,0,
+    /* 10675 */ 0240,0201,021,0301,01,0163,0202,021,0,
+    /* 10684 */ 0240,0201,025,0301,01,0163,0212,022,0,
+    /* 10693 */ 0240,0201,025,0301,01,0163,0202,021,0,
+    /* 10702 */ 0240,0201,031,0301,01,0163,0212,022,0,
+    /* 10711 */ 0240,0201,031,0301,01,0163,0202,021,0,
+    /* 10720 */ 0240,0201,041,0303,01,0161,0212,022,0,
+    /* 10729 */ 0240,0201,041,0303,01,0161,0202,021,0,
+    /* 10738 */ 0240,0201,045,0303,01,0161,0212,022,0,
+    /* 10747 */ 0240,0201,045,0303,01,0161,0202,021,0,
+    /* 10756 */ 0240,0201,051,0303,01,0161,0212,022,0,
+    /* 10765 */ 0240,0201,051,0303,01,0161,0202,021,0,
+    /* 10774 */ 0241,0203,01,0301,01,045,0120,023,0,
+    /* 10783 */ 0241,0203,05,0301,01,045,0120,023,0,
+    /* 10792 */ 0241,0203,011,0301,01,045,0120,023,0,
+    /* 10801 */ 0241,0203,021,0301,01,045,0120,023,0,
+    /* 10810 */ 0241,0203,025,0301,01,045,0120,023,0,
+    /* 10819 */ 0241,0203,031,0301,01,045,0120,023,0,
+    /* 10828 */ 0241,0203,021,0301,01,0120,0120,023,0,
+    /* 10837 */ 0240,0203,021,0301,01,0120,0110,022,0,
+    /* 10846 */ 0241,0203,025,0301,01,0120,0120,023,0,
+    /* 10855 */ 0240,0203,025,0301,01,0120,0110,022,0,
+    /* 10864 */ 0241,0203,031,0301,01,0120,0120,023,0,
+    /* 10873 */ 0240,0203,031,0301,01,0120,0110,022,0,
+    /* 10882 */ 0241,0203,01,0301,01,0120,0120,023,0,
+    /* 10891 */ 0240,0203,01,0301,01,0120,0110,022,0,
+    /* 10900 */ 0241,0203,05,0301,01,0120,0120,023,0,
+    /* 10909 */ 0240,0203,05,0301,01,0120,0110,022,0,
+    /* 10918 */ 0241,0203,011,0301,01,0120,0120,023,0,
+    /* 10927 */ 0240,0203,011,0301,01,0120,0110,022,0,
+    /* 10936 */ 0241,0203,021,0306,01,0121,0120,023,0,
+    /* 10945 */ 0240,0203,021,0306,01,0121,0110,022,0,
+    /* 10954 */ 0241,0203,01,0306,01,0121,0120,023,0,
+    /* 10963 */ 0240,0203,01,0306,01,0121,0110,022,0,
+    /* 10972 */ 0250,0203,021,0301,01,0126,0110,022,0,
+    /* 10981 */ 0250,0203,025,0301,01,0126,0110,022,0,
+    /* 10990 */ 0250,0203,031,0301,01,0126,0110,022,0,
+    /* 10999 */ 0250,0203,01,0301,01,0126,0110,022,0,
+    /* 11008 */ 0250,0203,05,0301,01,0126,0110,022,0,
+    /* 11017 */ 0250,0203,011,0301,01,0126,0110,022,0,
+    /* 11026 */ 0241,0203,021,0306,01,0127,0120,023,0,
+    /* 11035 */ 0240,0203,021,0306,01,0127,0110,022,0,
+    /* 11044 */ 0241,0203,01,0306,01,0127,0120,023,0,
+    /* 11053 */ 0240,0203,01,0306,01,0127,0110,022,0,
+    /* 11062 */ 0250,0203,021,0301,01,011,0110,022,0,
+    /* 11071 */ 0250,0203,025,0301,01,011,0110,022,0,
+    /* 11080 */ 0250,0203,031,0301,01,011,0110,022,0,
+    /* 11089 */ 0250,0203,01,0301,01,010,0110,022,0,
+    /* 11098 */ 0250,0203,05,0301,01,010,0110,022,0,
+    /* 11107 */ 0250,0203,011,0301,01,010,0110,022,0,
+    /* 11116 */ 0241,0203,021,0306,01,013,0120,023,0,
+    /* 11125 */ 0240,0203,021,0306,01,013,0110,022,0,
+    /* 11134 */ 0241,0203,01,0306,01,012,0120,023,0,
+    /* 11143 */ 0240,0203,01,0306,01,012,0110,022,0,
+    /* 11152 */ 0374,0250,0202,021,0306,01,0242,0101,0,
+    /* 11161 */ 0374,0250,0202,025,0306,01,0242,0101,0,
+    /* 11170 */ 0375,0250,0202,031,0306,01,0242,0101,0,
+    /* 11179 */ 0374,0250,0202,01,0306,01,0242,0101,0,
+    /* 11188 */ 0375,0250,0202,05,0306,01,0242,0101,0,
+    /* 11197 */ 0376,0250,0202,011,0306,01,0242,0101,0,
+    /* 11206 */ 0375,0250,0202,031,0306,01,0306,0205,0,
+    /* 11215 */ 0376,0250,0202,011,0306,01,0306,0205,0,
+    /* 11224 */ 0376,0250,0202,031,0306,01,0307,0205,0,
+    /* 11233 */ 0376,0250,0202,011,0306,01,0307,0205,0,
+    /* 11242 */ 0375,0250,0202,031,0306,01,0306,0206,0,
+    /* 11251 */ 0376,0250,0202,011,0306,01,0306,0206,0,
+    /* 11260 */ 0376,0250,0202,031,0306,01,0307,0206,0,
+    /* 11269 */ 0376,0250,0202,011,0306,01,0307,0206,0,
+    /* 11278 */ 0374,0250,0202,021,0306,01,0243,0101,0,
+    /* 11287 */ 0375,0250,0202,025,0306,01,0243,0101,0,
+    /* 11296 */ 0376,0250,0202,031,0306,01,0243,0101,0,
+    /* 11305 */ 0374,0250,0202,01,0306,01,0243,0101,0,
+    /* 11314 */ 0375,0250,0202,05,0306,01,0243,0101,0,
+    /* 11323 */ 0376,0250,0202,011,0306,01,0243,0101,0,
+    /* 11332 */ 0241,0203,05,0301,01,043,0120,023,0,
+    /* 11341 */ 0240,0203,05,0301,01,043,0110,022,0,
+    /* 11350 */ 0241,0203,011,0301,01,043,0120,023,0,
+    /* 11359 */ 0240,0203,011,0301,01,043,0110,022,0,
+    /* 11368 */ 0241,0203,025,0301,01,043,0120,023,0,
+    /* 11377 */ 0240,0203,025,0301,01,043,0110,022,0,
+    /* 11386 */ 0241,0203,031,0301,01,043,0120,023,0,
+    /* 11395 */ 0240,0203,031,0301,01,043,0110,022,0,
+    /* 11404 */ 0241,0203,05,0301,01,0103,0120,023,0,
+    /* 11413 */ 0240,0203,05,0301,01,0103,0110,022,0,
+    /* 11422 */ 0241,0203,011,0301,01,0103,0120,023,0,
+    /* 11431 */ 0240,0203,011,0301,01,0103,0110,022,0,
+    /* 11440 */ 0241,0203,025,0301,01,0103,0120,023,0,
+    /* 11449 */ 0240,0203,025,0301,01,0103,0110,022,0,
+    /* 11458 */ 0241,0203,031,0301,01,0103,0120,023,0,
+    /* 11467 */ 0240,0203,031,0301,01,0103,0110,022,0,
+    /* 11476 */ 0241,0201,021,0301,01,0306,0120,023,0,
+    /* 11485 */ 0240,0201,021,0301,01,0306,0110,022,0,
+    /* 11494 */ 0241,0201,025,0301,01,0306,0120,023,0,
+    /* 11503 */ 0240,0201,025,0301,01,0306,0110,022,0,
+    /* 11512 */ 0241,0201,031,0301,01,0306,0120,023,0,
+    /* 11521 */ 0240,0201,031,0301,01,0306,0110,022,0,
+    /* 11530 */ 0241,0201,0,0301,01,0306,0120,023,0,
+    /* 11539 */ 0240,0201,0,0301,01,0306,0110,022,0,
+    /* 11548 */ 0241,0201,04,0301,01,0306,0120,023,0,
+    /* 11557 */ 0240,0201,04,0301,01,0306,0110,022,0,
+    /* 11566 */ 0241,0201,010,0301,01,0306,0120,023,0,
+    /* 11575 */ 0240,0201,010,0301,01,0306,0110,022,0,
+    /* 11584 */ 0323,0313,0361,03,017,070,0370,0110,0,
+    /* 11593 */ 0241,0203,021,0301,01,0317,0120,023,0,
+    /* 11602 */ 0240,0203,021,0301,01,0317,0110,022,0,
+    /* 11611 */ 0241,0203,025,0301,01,0317,0120,023,0,
+    /* 11620 */ 0240,0203,025,0301,01,0317,0110,022,0,
+    /* 11629 */ 0241,0203,031,0301,01,0317,0120,023,0,
+    /* 11638 */ 0240,0203,031,0301,01,0317,0110,022,0,
+    /* 11647 */ 0241,0203,021,0301,01,0316,0120,023,0,
+    /* 11656 */ 0240,0203,021,0301,01,0316,0110,022,0,
+    /* 11665 */ 0241,0203,025,0301,01,0316,0120,023,0,
+    /* 11674 */ 0240,0203,025,0301,01,0316,0110,022,0,
+    /* 11683 */ 0241,0203,031,0301,01,0316,0120,023,0,
+    /* 11692 */ 0240,0203,031,0301,01,0316,0110,022,0,
+    /* 11701 */ 0241,0203,021,0303,01,0160,0120,023,0,
+    /* 11710 */ 0240,0203,021,0303,01,0160,0110,022,0,
+    /* 11719 */ 0241,0203,025,0303,01,0160,0120,023,0,
+    /* 11728 */ 0240,0203,025,0303,01,0160,0110,022,0,
+    /* 11737 */ 0241,0203,031,0303,01,0160,0120,023,0,
+    /* 11746 */ 0240,0203,031,0303,01,0160,0110,022,0,
+    /* 11755 */ 0241,0203,01,0301,01,0161,0120,023,0,
+    /* 11764 */ 0240,0203,01,0301,01,0161,0110,022,0,
+    /* 11773 */ 0241,0203,05,0301,01,0161,0120,023,0,
+    /* 11782 */ 0240,0203,05,0301,01,0161,0110,022,0,
+    /* 11791 */ 0241,0203,011,0301,01,0161,0120,023,0,
+    /* 11800 */ 0240,0203,011,0301,01,0161,0110,022,0,
+    /* 11809 */ 0241,0203,021,0301,01,0161,0120,023,0,
+    /* 11818 */ 0240,0203,021,0301,01,0161,0110,022,0,
+    /* 11827 */ 0241,0203,025,0301,01,0161,0120,023,0,
+    /* 11836 */ 0240,0203,025,0301,01,0161,0110,022,0,
+    /* 11845 */ 0241,0203,031,0301,01,0161,0120,023,0,
+    /* 11854 */ 0240,0203,031,0301,01,0161,0110,022,0,
+    /* 11863 */ 0241,0203,021,0303,01,0162,0120,023,0,
+    /* 11872 */ 0240,0203,021,0303,01,0162,0110,022,0,
+    /* 11881 */ 0241,0203,025,0303,01,0162,0120,023,0,
+    /* 11890 */ 0240,0203,025,0303,01,0162,0110,022,0,
+    /* 11899 */ 0241,0203,031,0303,01,0162,0120,023,0,
+    /* 11908 */ 0240,0203,031,0303,01,0162,0110,022,0,
+    /* 11917 */ 0241,0203,01,0301,01,0163,0120,023,0,
+    /* 11926 */ 0240,0203,01,0301,01,0163,0110,022,0,
+    /* 11935 */ 0241,0203,05,0301,01,0163,0120,023,0,
+    /* 11944 */ 0240,0203,05,0301,01,0163,0110,022,0,
+    /* 11953 */ 0241,0203,011,0301,01,0163,0120,023,0,
+    /* 11962 */ 0240,0203,011,0301,01,0163,0110,022,0,
+    /* 11971 */ 0241,0203,021,0301,01,0163,0120,023,0,
+    /* 11980 */ 0240,0203,021,0301,01,0163,0110,022,0,
+    /* 11989 */ 0241,0203,025,0301,01,0163,0120,023,0,
+    /* 11998 */ 0240,0203,025,0301,01,0163,0110,022,0,
+    /* 12007 */ 0241,0203,031,0301,01,0163,0120,023,0,
+    /* 12016 */ 0240,0203,031,0301,01,0163,0110,022,0,
+    /* 12025 */ 0241,0203,0,0301,01,0302,0120,023,0,
+    /* 12034 */ 0240,0203,0,0301,01,0302,0110,022,0,
+    /* 12043 */ 0241,0203,04,0301,01,0302,0120,023,0,
+    /* 12052 */ 0240,0203,04,0301,01,0302,0110,022,0,
+    /* 12061 */ 0241,0203,010,0301,01,0302,0120,023,0,
+    /* 12070 */ 0240,0203,010,0301,01,0302,0110,022,0,
+    /* 12079 */ 0241,0203,02,0306,01,0302,0120,023,0,
+    /* 12088 */ 0240,0203,02,0306,01,0302,0110,022,0,
+    /* 12097 */ 0250,0203,0,0301,01,0146,0110,022,0,
+    /* 12106 */ 0250,0203,04,0301,01,0146,0110,022,0,
+    /* 12115 */ 0250,0203,010,0301,01,0146,0110,022,0,
+    /* 12124 */ 0250,0203,0,0306,01,0147,0110,022,0,
+    /* 12133 */ 0250,0203,0,0301,01,045,0110,022,0,
+    /* 12142 */ 0250,0203,04,0301,01,045,0110,022,0,
+    /* 12151 */ 0250,0203,010,0301,01,045,0110,022,0,
+    /* 12160 */ 0250,0203,0,0306,01,047,0110,022,0,
+    /* 12169 */ 0250,0203,0,0301,01,0126,0110,022,0,
+    /* 12178 */ 0250,0203,04,0301,01,0126,0110,022,0,
+    /* 12187 */ 0250,0203,010,0301,01,0126,0110,022,0,
+    /* 12196 */ 0242,0203,0,0306,01,0127,0110,023,0,
+    /* 12205 */ 0241,0203,0,0306,01,0127,0100,022,0,
+    /* 12214 */ 0250,0203,0,0301,01,010,0110,022,0,
+    /* 12223 */ 0250,0203,04,0301,01,010,0110,022,0,
+    /* 12232 */ 0250,0203,010,0301,01,010,0110,022,0,
+    /* 12241 */ 0241,0203,0,0306,01,012,0120,023,0,
+    /* 12250 */ 0240,0203,0,0306,01,012,0110,022,0,
+    /* 12259 */ 0250,0206,01,0301,01,0116,0110,022,0,
+    /* 12268 */ 0250,0206,05,0301,01,0116,0110,022,0,
+    /* 12277 */ 0250,0206,011,0301,01,0116,0110,022,0,
+    /* 12286 */ 0241,0206,01,0306,01,0117,0120,023,0,
+    /* 12295 */ 0240,0206,01,0306,01,0117,0110,022,0,
+    /* 12304 */ 0273,0320,02,017,0272,0207,025,0,
+    /* 12312 */ 0273,0321,02,017,0272,0207,025,0,
+    /* 12320 */ 0273,0324,02,017,0272,0207,025,0,
+    /* 12328 */ 0273,0320,02,017,0272,0206,025,0,
+    /* 12336 */ 0273,0321,02,017,0272,0206,025,0,
+    /* 12344 */ 0273,0324,02,017,0272,0206,025,0,
+    /* 12352 */ 0273,0320,02,017,0272,0205,025,0,
+    /* 12360 */ 0273,0321,02,017,0272,0205,025,0,
+    /* 12368 */ 0273,0324,02,017,0272,0205,025,0,
+    /* 12376 */ 0323,02,017,017,0110,01,0277,0,
+    /* 12384 */ 0323,02,017,017,0110,01,035,0,
+    /* 12392 */ 0323,02,017,017,0110,01,0256,0,
+    /* 12400 */ 0323,02,017,017,0110,01,0236,0,
+    /* 12408 */ 0323,02,017,017,0110,01,0260,0,
+    /* 12416 */ 0323,02,017,017,0110,01,0220,0,
+    /* 12424 */ 0323,02,017,017,0110,01,0240,0,
+    /* 12432 */ 0323,02,017,017,0110,01,0244,0,
+    /* 12440 */ 0323,02,017,017,0110,01,0224,0,
+    /* 12448 */ 0323,02,017,017,0110,01,0264,0,
+    /* 12456 */ 0323,02,017,017,0110,01,0226,0,
+    /* 12464 */ 0323,02,017,017,0110,01,0246,0,
+    /* 12472 */ 0323,02,017,017,0110,01,0266,0,
+    /* 12480 */ 0323,02,017,017,0110,01,0247,0,
+    /* 12488 */ 0323,02,017,017,0110,01,0227,0,
+    /* 12496 */ 0323,02,017,017,0110,01,0232,0,
+    /* 12504 */ 0323,02,017,017,0110,01,0252,0,
+    /* 12512 */ 0323,02,017,017,0110,01,015,0,
+    /* 12520 */ 0323,02,017,017,0110,01,0267,0,
+    /* 12528 */ 0360,02,017,0302,0110,01,0,0,
+    /* 12536 */ 0333,02,017,0302,0110,01,0,0,
+    /* 12544 */ 0360,02,017,0302,0110,01,02,0,
+    /* 12552 */ 0333,02,017,0302,0110,01,02,0,
+    /* 12560 */ 0360,02,017,0302,0110,01,01,0,
+    /* 12568 */ 0333,02,017,0302,0110,01,01,0,
+    /* 12576 */ 0360,02,017,0302,0110,01,04,0,
+    /* 12584 */ 0333,02,017,0302,0110,01,04,0,
+    /* 12592 */ 0360,02,017,0302,0110,01,06,0,
+    /* 12600 */ 0333,02,017,0302,0110,01,06,0,
+    /* 12608 */ 0360,02,017,0302,0110,01,05,0,
+    /* 12616 */ 0333,02,017,0302,0110,01,05,0,
+    /* 12624 */ 0360,02,017,0302,0110,01,07,0,
+    /* 12632 */ 0333,02,017,0302,0110,01,07,0,
+    /* 12640 */ 0360,02,017,0302,0110,01,03,0,
+    /* 12648 */ 0333,02,017,0302,0110,01,03,0,
+    /* 12656 */ 0360,0323,02,017,0160,0110,022,0,
+    /* 12664 */ 0323,02,017,017,0110,01,034,0,
+    /* 12672 */ 0323,02,017,017,0110,01,0212,0,
+    /* 12680 */ 0323,02,017,017,0110,01,0216,0,
+    /* 12688 */ 0323,02,017,017,0110,01,014,0,
+    /* 12696 */ 0323,02,017,017,0110,01,0273,0,
+    /* 12704 */ 0361,02,017,0302,0110,01,0,0,
+    /* 12712 */ 0332,02,017,0302,0110,01,0,0,
+    /* 12720 */ 0361,02,017,0302,0110,01,02,0,
+    /* 12728 */ 0332,02,017,0302,0110,01,02,0,
+    /* 12736 */ 0361,02,017,0302,0110,01,01,0,
+    /* 12744 */ 0332,02,017,0302,0110,01,01,0,
+    /* 12752 */ 0361,02,017,0302,0110,01,04,0,
+    /* 12760 */ 0332,02,017,0302,0110,01,04,0,
+    /* 12768 */ 0361,02,017,0302,0110,01,06,0,
+    /* 12776 */ 0332,02,017,0302,0110,01,06,0,
+    /* 12784 */ 0361,02,017,0302,0110,01,05,0,
+    /* 12792 */ 0332,02,017,0302,0110,01,05,0,
+    /* 12800 */ 0361,02,017,0302,0110,01,07,0,
+    /* 12808 */ 0332,02,017,0302,0110,01,07,0,
+    /* 12816 */ 0361,02,017,0302,0110,01,03,0,
+    /* 12824 */ 0332,02,017,0302,0110,01,03,0,
+    /* 12832 */ 0323,0361,03,017,070,0200,0110,0,
+    /* 12840 */ 0323,0361,03,017,070,0201,0110,0,
+    /* 12848 */ 0360,03,017,072,017,0110,026,0,
+    /* 12856 */ 0361,03,017,072,017,0110,026,0,
+    /* 12864 */ 0361,02,017,0170,0200,025,026,0,
+    /* 12872 */ 0332,02,017,0170,0110,026,027,0,
+    /* 12880 */ 0361,03,017,072,015,0110,026,0,
+    /* 12888 */ 0361,03,017,072,014,0110,026,0,
+    /* 12896 */ 0361,03,017,072,0101,0110,026,0,
+    /* 12904 */ 0361,03,017,072,0100,0110,026,0,
+    /* 12912 */ 0361,03,017,072,041,0110,026,0,
+    /* 12920 */ 0361,03,017,072,0102,0110,026,0,
+    /* 12928 */ 0361,03,017,072,016,0110,026,0,
+    /* 12936 */ 0361,03,017,072,011,0110,026,0,
+    /* 12944 */ 0361,03,017,072,010,0110,026,0,
+    /* 12952 */ 0361,03,017,072,013,0110,026,0,
+    /* 12960 */ 0361,03,017,072,012,0110,026,0,
+    /* 12968 */ 0320,0332,03,017,070,0361,0110,0,
+    /* 12976 */ 0321,0332,03,017,070,0361,0110,0,
+    /* 12984 */ 0324,0332,03,017,070,0360,0110,0,
+    /* 12992 */ 0324,0332,03,017,070,0361,0110,0,
+    /* 13000 */ 0361,03,017,072,0141,0110,026,0,
+    /* 13008 */ 0361,03,017,072,0140,0110,026,0,
+    /* 13016 */ 0361,03,017,072,0143,0110,026,0,
+    /* 13024 */ 0361,03,017,072,0142,0110,026,0,
+    /* 13032 */ 0323,02,017,017,0110,01,0206,0,
+    /* 13040 */ 0323,02,017,017,0110,01,0207,0,
+    /* 13048 */ 0320,0331,03,017,070,0360,0110,0,
+    /* 13056 */ 0321,0331,03,017,070,0360,0110,0,
+    /* 13064 */ 0324,0331,03,017,070,0360,0110,0,
+    /* 13072 */ 0320,0331,03,017,070,0361,0101,0,
+    /* 13080 */ 0321,0331,03,017,070,0361,0101,0,
+    /* 13088 */ 0324,0331,03,017,070,0361,0101,0,
+    /* 13096 */ 0361,03,017,072,0337,0110,022,0,
+    /* 13104 */ 0270,03,041,01,0337,0110,022,0,
+    /* 13112 */ 0241,0202,041,0301,01,0334,0120,0,
+    /* 13120 */ 0240,0202,041,0301,01,0334,0110,0,
+    /* 13128 */ 0241,0202,045,0301,01,0334,0120,0,
+    /* 13136 */ 0240,0202,045,0301,01,0334,0110,0,
+    /* 13144 */ 0241,0202,041,0301,01,0335,0120,0,
+    /* 13152 */ 0240,0202,041,0301,01,0335,0110,0,
+    /* 13160 */ 0241,0202,045,0301,01,0335,0120,0,
+    /* 13168 */ 0240,0202,045,0301,01,0335,0110,0,
+    /* 13176 */ 0241,0202,041,0301,01,0336,0120,0,
+    /* 13184 */ 0240,0202,041,0301,01,0336,0110,0,
+    /* 13192 */ 0241,0202,045,0301,01,0336,0120,0,
+    /* 13200 */ 0240,0202,045,0301,01,0336,0110,0,
+    /* 13208 */ 0241,0202,041,0301,01,0337,0120,0,
+    /* 13216 */ 0240,0202,041,0301,01,0337,0110,0,
+    /* 13224 */ 0241,0202,045,0301,01,0337,0120,0,
+    /* 13232 */ 0240,0202,045,0301,01,0337,0110,0,
+    /* 13240 */ 0241,0202,051,0301,01,0334,0120,0,
+    /* 13248 */ 0240,0202,051,0301,01,0334,0110,0,
+    /* 13256 */ 0241,0202,051,0301,01,0335,0120,0,
+    /* 13264 */ 0240,0202,051,0301,01,0335,0110,0,
+    /* 13272 */ 0241,0202,051,0301,01,0336,0120,0,
+    /* 13280 */ 0240,0202,051,0301,01,0336,0110,0,
+    /* 13288 */ 0241,0202,051,0301,01,0337,0120,0,
+    /* 13296 */ 0240,0202,051,0301,01,0337,0110,0,
+    /* 13304 */ 0261,03,041,01,015,0120,023,0,
+    /* 13312 */ 0260,03,041,01,015,0110,022,0,
+    /* 13320 */ 0261,03,045,01,015,0120,023,0,
+    /* 13328 */ 0260,03,045,01,015,0110,022,0,
+    /* 13336 */ 0261,03,041,01,014,0120,023,0,
+    /* 13344 */ 0260,03,041,01,014,0110,022,0,
+    /* 13352 */ 0261,03,045,01,014,0120,023,0,
+    /* 13360 */ 0260,03,045,01,014,0110,022,0,
+    /* 13368 */ 0261,03,01,01,0113,0120,0177,0,
+    /* 13376 */ 0260,03,01,01,0113,0110,0176,0,
+    /* 13384 */ 0261,03,05,01,0113,0120,0177,0,
+    /* 13392 */ 0260,03,05,01,0113,0110,0176,0,
+    /* 13400 */ 0261,03,01,01,0112,0120,0177,0,
+    /* 13408 */ 0260,03,01,01,0112,0110,0176,0,
+    /* 13416 */ 0261,03,05,01,0112,0120,0177,0,
+    /* 13424 */ 0260,03,05,01,0112,0110,0176,0,
+    /* 13432 */ 0261,01,041,01,0302,0120,023,0,
+    /* 13440 */ 0260,01,041,01,0302,0110,022,0,
+    /* 13448 */ 0261,01,045,01,0302,0120,023,0,
+    /* 13456 */ 0260,01,045,01,0302,0110,022,0,
+    /* 13464 */ 0261,01,040,01,0302,0120,023,0,
+    /* 13472 */ 0260,01,040,01,0302,0110,022,0,
+    /* 13480 */ 0261,01,044,01,0302,0120,023,0,
+    /* 13488 */ 0260,01,044,01,0302,0110,022,0,
+    /* 13496 */ 0261,01,053,01,0302,0120,023,0,
+    /* 13504 */ 0260,01,053,01,0302,0110,022,0,
+    /* 13512 */ 0261,01,052,01,0302,0120,023,0,
+    /* 13520 */ 0260,01,052,01,0302,0110,022,0,
+    /* 13528 */ 0261,03,041,01,0101,0120,023,0,
+    /* 13536 */ 0260,03,041,01,0101,0110,022,0,
+    /* 13544 */ 0261,03,041,01,0100,0120,023,0,
+    /* 13552 */ 0260,03,041,01,0100,0110,022,0,
+    /* 13560 */ 0261,03,045,01,0100,0120,023,0,
+    /* 13568 */ 0260,03,045,01,0100,0110,022,0,
+    /* 13576 */ 0270,03,05,01,031,0101,022,0,
+    /* 13584 */ 0270,03,041,01,027,0101,022,0,
+    /* 13592 */ 0261,03,05,01,030,0120,023,0,
+    /* 13600 */ 0260,03,05,01,030,0110,022,0,
+    /* 13608 */ 0261,03,041,01,041,0120,023,0,
+    /* 13616 */ 0260,03,041,01,041,0110,022,0,
+    /* 13624 */ 0261,03,041,01,0102,0120,023,0,
+    /* 13632 */ 0260,03,041,01,0102,0110,022,0,
+    /* 13640 */ 0261,03,041,01,017,0120,023,0,
+    /* 13648 */ 0260,03,041,01,017,0110,022,0,
+    /* 13656 */ 0261,03,01,01,0114,0120,0177,0,
+    /* 13664 */ 0260,03,01,01,0114,0110,0176,0,
+    /* 13672 */ 0261,03,041,01,016,0120,023,0,
+    /* 13680 */ 0260,03,041,01,016,0110,022,0,
+    /* 13688 */ 0270,03,041,01,0141,0110,022,0,
+    /* 13696 */ 0270,03,041,01,0140,0110,022,0,
+    /* 13704 */ 0270,03,041,01,0143,0110,022,0,
+    /* 13712 */ 0270,03,041,01,0142,0110,022,0,
+    /* 13720 */ 0270,03,01,01,05,0110,022,0,
+    /* 13728 */ 0270,03,05,01,05,0110,022,0,
+    /* 13736 */ 0270,03,01,01,04,0110,022,0,
+    /* 13744 */ 0270,03,05,01,04,0110,022,0,
+    /* 13752 */ 0261,03,05,01,06,0120,023,0,
+    /* 13760 */ 0260,03,05,01,06,0110,022,0,
+    /* 13768 */ 0270,03,01,01,024,0101,022,0,
+    /* 13776 */ 0270,01,01,01,0305,0110,022,0,
+    /* 13784 */ 0270,03,01,01,025,0101,022,0,
+    /* 13792 */ 0270,03,01,01,026,0101,022,0,
+    /* 13800 */ 0270,03,021,01,026,0101,022,0,
+    /* 13808 */ 0261,03,041,01,040,0120,023,0,
+    /* 13816 */ 0260,03,041,01,040,0110,022,0,
+    /* 13824 */ 0261,01,041,01,0304,0120,023,0,
+    /* 13832 */ 0260,01,041,01,0304,0110,022,0,
+    /* 13840 */ 0261,03,01,01,042,0120,023,0,
+    /* 13848 */ 0260,03,01,01,042,0110,022,0,
+    /* 13856 */ 0261,03,021,01,042,0120,023,0,
+    /* 13864 */ 0260,03,021,01,042,0110,022,0,
+    /* 13872 */ 0270,01,041,01,0160,0110,022,0,
+    /* 13880 */ 0270,01,042,01,0160,0110,022,0,
+    /* 13888 */ 0270,01,043,01,0160,0110,022,0,
+    /* 13896 */ 0260,01,041,01,0163,0217,022,0,
+    /* 13904 */ 0260,01,041,01,0163,0207,021,0,
+    /* 13912 */ 0260,01,041,01,0163,0213,022,0,
+    /* 13920 */ 0260,01,041,01,0163,0203,021,0,
+    /* 13928 */ 0260,01,041,01,0161,0216,022,0,
+    /* 13936 */ 0260,01,041,01,0161,0206,021,0,
+    /* 13944 */ 0260,01,041,01,0162,0216,022,0,
+    /* 13952 */ 0260,01,041,01,0162,0206,021,0,
+    /* 13960 */ 0260,01,041,01,0163,0216,022,0,
+    /* 13968 */ 0260,01,041,01,0163,0206,021,0,
+    /* 13976 */ 0260,01,041,01,0161,0214,022,0,
+    /* 13984 */ 0260,01,041,01,0161,0204,021,0,
+    /* 13992 */ 0260,01,041,01,0162,0214,022,0,
+    /* 14000 */ 0260,01,041,01,0162,0204,021,0,
+    /* 14008 */ 0260,01,041,01,0161,0212,022,0,
+    /* 14016 */ 0260,01,041,01,0161,0202,021,0,
+    /* 14024 */ 0260,01,041,01,0162,0212,022,0,
+    /* 14032 */ 0260,01,041,01,0162,0202,021,0,
+    /* 14040 */ 0260,01,041,01,0163,0212,022,0,
+    /* 14048 */ 0260,01,041,01,0163,0202,021,0,
+    /* 14056 */ 0270,03,041,01,011,0110,022,0,
+    /* 14064 */ 0270,03,045,01,011,0110,022,0,
+    /* 14072 */ 0270,03,041,01,010,0110,022,0,
+    /* 14080 */ 0270,03,045,01,010,0110,022,0,
+    /* 14088 */ 0261,03,041,01,013,0120,023,0,
+    /* 14096 */ 0260,03,041,01,013,0110,022,0,
+    /* 14104 */ 0261,03,041,01,012,0120,023,0,
+    /* 14112 */ 0260,03,041,01,012,0110,022,0,
+    /* 14120 */ 0261,01,041,01,0306,0120,023,0,
+    /* 14128 */ 0260,01,041,01,0306,0110,022,0,
+    /* 14136 */ 0261,01,045,01,0306,0120,023,0,
+    /* 14144 */ 0260,01,045,01,0306,0110,022,0,
+    /* 14152 */ 0261,01,040,01,0306,0120,023,0,
+    /* 14160 */ 0260,01,040,01,0306,0110,022,0,
+    /* 14168 */ 0261,01,044,01,0306,0120,023,0,
+    /* 14176 */ 0260,01,044,01,0306,0110,022,0,
+    /* 14184 */ 0361,03,017,072,0104,0110,022,0,
+    /* 14192 */ 0261,03,041,01,0104,0120,023,0,
+    /* 14200 */ 0260,03,041,01,0104,0110,022,0,
+    /* 14208 */ 0261,03,045,01,0104,0120,023,0,
+    /* 14216 */ 0260,03,045,01,0104,0110,022,0,
+    /* 14224 */ 0270,03,05,01,035,0101,022,0,
+    /* 14232 */ 0270,03,01,01,035,0101,022,0,
+    /* 14240 */ 0317,0361,03,017,070,0366,0110,0,
+    /* 14248 */ 0324,0361,03,017,070,0366,0110,0,
+    /* 14256 */ 0317,0333,03,017,070,0366,0110,0,
+    /* 14264 */ 0324,0333,03,017,070,0366,0110,0,
+    /* 14272 */ 0260,0112,0,01,022,0211,042,0,
+    /* 14280 */ 0260,0112,020,01,022,0211,042,0,
+    /* 14288 */ 0260,0112,0,01,022,0210,042,0,
+    /* 14296 */ 0260,0112,020,01,022,0210,042,0,
+    /* 14304 */ 0261,03,01,01,0151,0120,0177,0,
+    /* 14312 */ 0260,03,01,01,0151,0110,0176,0,
+    /* 14320 */ 0261,03,05,01,0151,0120,0177,0,
+    /* 14328 */ 0260,03,05,01,0151,0110,0176,0,
+    /* 14336 */ 0261,03,021,01,0151,0130,0176,0,
+    /* 14344 */ 0260,03,021,01,0151,0120,0175,0,
+    /* 14352 */ 0261,03,025,01,0151,0130,0176,0,
+    /* 14360 */ 0260,03,025,01,0151,0120,0175,0,
+    /* 14368 */ 0261,03,01,01,0150,0120,0177,0,
+    /* 14376 */ 0260,03,01,01,0150,0110,0176,0,
+    /* 14384 */ 0261,03,05,01,0150,0120,0177,0,
+    /* 14392 */ 0260,03,05,01,0150,0110,0176,0,
+    /* 14400 */ 0261,03,021,01,0150,0130,0176,0,
+    /* 14408 */ 0260,03,021,01,0150,0120,0175,0,
+    /* 14416 */ 0261,03,025,01,0150,0130,0176,0,
+    /* 14424 */ 0260,03,025,01,0150,0120,0175,0,
+    /* 14432 */ 0261,03,01,01,0153,0120,0177,0,
+    /* 14440 */ 0260,03,01,01,0153,0110,0176,0,
+    /* 14448 */ 0261,03,021,01,0153,0130,0176,0,
+    /* 14456 */ 0260,03,021,01,0153,0120,0175,0,
+    /* 14464 */ 0261,03,01,01,0152,0120,0177,0,
+    /* 14472 */ 0260,03,01,01,0152,0110,0176,0,
+    /* 14480 */ 0261,03,021,01,0152,0130,0176,0,
+    /* 14488 */ 0260,03,021,01,0152,0120,0175,0,
+    /* 14496 */ 0261,03,01,01,0135,0120,0177,0,
+    /* 14504 */ 0260,03,01,01,0135,0110,0176,0,
+    /* 14512 */ 0261,03,05,01,0135,0120,0177,0,
+    /* 14520 */ 0260,03,05,01,0135,0110,0176,0,
+    /* 14528 */ 0261,03,021,01,0135,0130,0176,0,
+    /* 14536 */ 0260,03,021,01,0135,0120,0175,0,
+    /* 14544 */ 0261,03,025,01,0135,0130,0176,0,
+    /* 14552 */ 0260,03,025,01,0135,0120,0175,0,
+    /* 14560 */ 0261,03,01,01,0134,0120,0177,0,
+    /* 14568 */ 0260,03,01,01,0134,0110,0176,0,
+    /* 14576 */ 0261,03,05,01,0134,0120,0177,0,
+    /* 14584 */ 0260,03,05,01,0134,0110,0176,0,
+    /* 14592 */ 0261,03,021,01,0134,0130,0176,0,
+    /* 14600 */ 0260,03,021,01,0134,0120,0175,0,
+    /* 14608 */ 0261,03,025,01,0134,0130,0176,0,
+    /* 14616 */ 0260,03,025,01,0134,0120,0175,0,
+    /* 14624 */ 0261,03,01,01,0137,0120,0177,0,
+    /* 14632 */ 0260,03,01,01,0137,0110,0176,0,
+    /* 14640 */ 0261,03,05,01,0137,0120,0177,0,
+    /* 14648 */ 0260,03,05,01,0137,0110,0176,0,
+    /* 14656 */ 0261,03,021,01,0137,0130,0176,0,
+    /* 14664 */ 0260,03,021,01,0137,0120,0175,0,
+    /* 14672 */ 0261,03,025,01,0137,0130,0176,0,
+    /* 14680 */ 0260,03,025,01,0137,0120,0175,0,
+    /* 14688 */ 0261,03,01,01,0136,0120,0177,0,
+    /* 14696 */ 0260,03,01,01,0136,0110,0176,0,
+    /* 14704 */ 0261,03,05,01,0136,0120,0177,0,
+    /* 14712 */ 0260,03,05,01,0136,0110,0176,0,
+    /* 14720 */ 0261,03,021,01,0136,0130,0176,0,
+    /* 14728 */ 0260,03,021,01,0136,0120,0175,0,
+    /* 14736 */ 0261,03,025,01,0136,0130,0176,0,
+    /* 14744 */ 0260,03,025,01,0136,0120,0175,0,
+    /* 14752 */ 0261,03,01,01,0155,0120,0177,0,
+    /* 14760 */ 0260,03,01,01,0155,0110,0176,0,
+    /* 14768 */ 0261,03,05,01,0155,0120,0177,0,
+    /* 14776 */ 0260,03,05,01,0155,0110,0176,0,
+    /* 14784 */ 0261,03,021,01,0155,0130,0176,0,
+    /* 14792 */ 0260,03,021,01,0155,0120,0175,0,
+    /* 14800 */ 0261,03,025,01,0155,0130,0176,0,
+    /* 14808 */ 0260,03,025,01,0155,0120,0175,0,
+    /* 14816 */ 0261,03,01,01,0154,0120,0177,0,
+    /* 14824 */ 0260,03,01,01,0154,0110,0176,0,
+    /* 14832 */ 0261,03,05,01,0154,0120,0177,0,
+    /* 14840 */ 0260,03,05,01,0154,0110,0176,0,
+    /* 14848 */ 0261,03,021,01,0154,0130,0176,0,
+    /* 14856 */ 0260,03,021,01,0154,0120,0175,0,
+    /* 14864 */ 0261,03,025,01,0154,0130,0176,0,
+    /* 14872 */ 0260,03,025,01,0154,0120,0175,0,
+    /* 14880 */ 0261,03,01,01,0157,0120,0177,0,
+    /* 14888 */ 0260,03,01,01,0157,0110,0176,0,
+    /* 14896 */ 0261,03,021,01,0157,0130,0176,0,
+    /* 14904 */ 0260,03,021,01,0157,0120,0175,0,
+    /* 14912 */ 0261,03,01,01,0156,0120,0177,0,
+    /* 14920 */ 0260,03,01,01,0156,0110,0176,0,
+    /* 14928 */ 0261,03,021,01,0156,0130,0176,0,
+    /* 14936 */ 0260,03,021,01,0156,0120,0175,0,
+    /* 14944 */ 0261,03,01,01,0171,0120,0177,0,
+    /* 14952 */ 0260,03,01,01,0171,0110,0176,0,
+    /* 14960 */ 0261,03,05,01,0171,0120,0177,0,
+    /* 14968 */ 0260,03,05,01,0171,0110,0176,0,
+    /* 14976 */ 0261,03,021,01,0171,0130,0176,0,
+    /* 14984 */ 0260,03,021,01,0171,0120,0175,0,
+    /* 14992 */ 0261,03,025,01,0171,0130,0176,0,
+    /* 15000 */ 0260,03,025,01,0171,0120,0175,0,
+    /* 15008 */ 0261,03,01,01,0170,0120,0177,0,
+    /* 15016 */ 0260,03,01,01,0170,0110,0176,0,
+    /* 15024 */ 0261,03,05,01,0170,0120,0177,0,
+    /* 15032 */ 0260,03,05,01,0170,0110,0176,0,
+    /* 15040 */ 0261,03,021,01,0170,0130,0176,0,
+    /* 15048 */ 0260,03,021,01,0170,0120,0175,0,
+    /* 15056 */ 0261,03,025,01,0170,0130,0176,0,
+    /* 15064 */ 0260,03,025,01,0170,0120,0175,0,
+    /* 15072 */ 0261,03,01,01,0173,0120,0177,0,
+    /* 15080 */ 0260,03,01,01,0173,0110,0176,0,
+    /* 15088 */ 0261,03,021,01,0173,0130,0176,0,
+    /* 15096 */ 0260,03,021,01,0173,0120,0175,0,
+    /* 15104 */ 0261,03,01,01,0172,0120,0177,0,
+    /* 15112 */ 0260,03,01,01,0172,0110,0176,0,
+    /* 15120 */ 0261,03,021,01,0172,0130,0176,0,
+    /* 15128 */ 0260,03,021,01,0172,0120,0175,0,
+    /* 15136 */ 0261,03,01,01,0175,0120,0177,0,
+    /* 15144 */ 0260,03,01,01,0175,0110,0176,0,
+    /* 15152 */ 0261,03,05,01,0175,0120,0177,0,
+    /* 15160 */ 0260,03,05,01,0175,0110,0176,0,
+    /* 15168 */ 0261,03,021,01,0175,0130,0176,0,
+    /* 15176 */ 0260,03,021,01,0175,0120,0175,0,
+    /* 15184 */ 0261,03,025,01,0175,0130,0176,0,
+    /* 15192 */ 0260,03,025,01,0175,0120,0175,0,
+    /* 15200 */ 0261,03,01,01,0174,0120,0177,0,
+    /* 15208 */ 0260,03,01,01,0174,0110,0176,0,
+    /* 15216 */ 0261,03,05,01,0174,0120,0177,0,
+    /* 15224 */ 0260,03,05,01,0174,0110,0176,0,
+    /* 15232 */ 0261,03,021,01,0174,0130,0176,0,
+    /* 15240 */ 0260,03,021,01,0174,0120,0175,0,
+    /* 15248 */ 0261,03,025,01,0174,0130,0176,0,
+    /* 15256 */ 0260,03,025,01,0174,0120,0175,0,
+    /* 15264 */ 0261,03,01,01,0177,0120,0177,0,
+    /* 15272 */ 0260,03,01,01,0177,0110,0176,0,
+    /* 15280 */ 0261,03,021,01,0177,0130,0176,0,
+    /* 15288 */ 0260,03,021,01,0177,0120,0175,0,
+    /* 15296 */ 0261,03,01,01,0176,0120,0177,0,
+    /* 15304 */ 0260,03,01,01,0176,0110,0176,0,
+    /* 15312 */ 0261,03,021,01,0176,0130,0176,0,
+    /* 15320 */ 0260,03,021,01,0176,0120,0175,0,
+    /* 15328 */ 0261,0110,0,01,0242,0120,0177,0,
+    /* 15336 */ 0260,0110,0,01,0242,0110,0176,0,
+    /* 15344 */ 0261,0110,04,01,0242,0120,0177,0,
+    /* 15352 */ 0260,0110,04,01,0242,0110,0176,0,
+    /* 15360 */ 0261,0110,020,01,0242,0130,0176,0,
+    /* 15368 */ 0260,0110,020,01,0242,0120,0175,0,
+    /* 15376 */ 0261,0110,024,01,0242,0130,0176,0,
+    /* 15384 */ 0260,0110,024,01,0242,0120,0175,0,
+    /* 15392 */ 0261,0110,0,01,0314,0120,023,0,
+    /* 15400 */ 0260,0110,0,01,0314,0110,022,0,
+    /* 15408 */ 0261,0110,0,01,0316,0120,023,0,
+    /* 15416 */ 0260,0110,0,01,0316,0110,022,0,
+    /* 15424 */ 0261,0110,0,01,0317,0120,023,0,
+    /* 15432 */ 0260,0110,0,01,0317,0110,022,0,
+    /* 15440 */ 0261,0110,0,01,0354,0120,023,0,
+    /* 15448 */ 0260,0110,0,01,0354,0110,022,0,
+    /* 15456 */ 0261,0110,0,01,0356,0120,023,0,
+    /* 15464 */ 0260,0110,0,01,0356,0110,022,0,
+    /* 15472 */ 0261,0110,0,01,0357,0120,023,0,
+    /* 15480 */ 0260,0110,0,01,0357,0110,022,0,
+    /* 15488 */ 0261,0110,0,01,0355,0120,023,0,
+    /* 15496 */ 0260,0110,0,01,0355,0110,022,0,
+    /* 15504 */ 0261,0110,0,01,0315,0120,023,0,
+    /* 15512 */ 0260,0110,0,01,0315,0110,022,0,
+    /* 15520 */ 0261,0110,0,01,0236,0120,0177,0,
+    /* 15528 */ 0260,0110,0,01,0236,0110,0176,0,
+    /* 15536 */ 0261,0110,0,01,0237,0120,0177,0,
+    /* 15544 */ 0260,0110,0,01,0237,0110,0176,0,
+    /* 15552 */ 0261,0110,0,01,0227,0120,0177,0,
+    /* 15560 */ 0260,0110,0,01,0227,0110,0176,0,
+    /* 15568 */ 0261,0110,0,01,0216,0120,0177,0,
+    /* 15576 */ 0260,0110,0,01,0216,0110,0176,0,
+    /* 15584 */ 0261,0110,0,01,0217,0120,0177,0,
+    /* 15592 */ 0260,0110,0,01,0217,0110,0176,0,
+    /* 15600 */ 0261,0110,0,01,0207,0120,0177,0,
+    /* 15608 */ 0260,0110,0,01,0207,0110,0176,0,
+    /* 15616 */ 0261,0110,0,01,0206,0120,0177,0,
+    /* 15624 */ 0260,0110,0,01,0206,0110,0176,0,
+    /* 15632 */ 0261,0110,0,01,0205,0120,0177,0,
+    /* 15640 */ 0260,0110,0,01,0205,0110,0176,0,
+    /* 15648 */ 0261,0110,0,01,0226,0120,0177,0,
+    /* 15656 */ 0260,0110,0,01,0226,0110,0176,0,
+    /* 15664 */ 0261,0110,0,01,0225,0120,0177,0,
+    /* 15672 */ 0260,0110,0,01,0225,0110,0176,0,
+    /* 15680 */ 0261,0110,0,01,0246,0120,0177,0,
+    /* 15688 */ 0260,0110,0,01,0246,0110,0176,0,
+    /* 15696 */ 0261,0110,0,01,0266,0120,0177,0,
+    /* 15704 */ 0260,0110,0,01,0266,0110,0176,0,
+    /* 15712 */ 0261,0110,020,01,0243,0130,0176,0,
+    /* 15720 */ 0260,0110,020,01,0243,0120,0175,0,
+    /* 15728 */ 0261,0110,0,01,0243,0120,0177,0,
+    /* 15736 */ 0260,0110,0,01,0243,0110,0176,0,
+    /* 15744 */ 0270,0110,0,01,0300,0110,022,0,
+    /* 15752 */ 0270,0110,0,01,0300,0100,021,0,
+    /* 15760 */ 0270,0110,0,01,0302,0110,022,0,
+    /* 15768 */ 0270,0110,0,01,0302,0100,021,0,
+    /* 15776 */ 0270,0110,0,01,0303,0110,022,0,
+    /* 15784 */ 0270,0110,0,01,0303,0100,021,0,
+    /* 15792 */ 0270,0110,0,01,0301,0110,022,0,
+    /* 15800 */ 0270,0110,0,01,0301,0100,021,0,
+    /* 15808 */ 0261,03,045,01,0102,0120,023,0,
+    /* 15816 */ 0260,03,045,01,0102,0110,022,0,
+    /* 15824 */ 0261,03,045,01,017,0120,023,0,
+    /* 15832 */ 0260,03,045,01,017,0110,022,0,
+    /* 15840 */ 0261,03,045,01,0114,0120,0177,0,
+    /* 15848 */ 0260,03,045,01,0114,0110,0176,0,
+    /* 15856 */ 0261,03,045,01,016,0120,023,0,
+    /* 15864 */ 0260,03,045,01,016,0110,022,0,
+    /* 15872 */ 0270,01,045,01,0160,0110,022,0,
+    /* 15880 */ 0270,01,046,01,0160,0110,022,0,
+    /* 15888 */ 0270,01,047,01,0160,0110,022,0,
+    /* 15896 */ 0260,01,045,01,0163,0217,022,0,
+    /* 15904 */ 0260,01,045,01,0163,0207,021,0,
+    /* 15912 */ 0260,01,045,01,0161,0216,022,0,
+    /* 15920 */ 0260,01,045,01,0161,0206,021,0,
+    /* 15928 */ 0260,01,045,01,0162,0216,022,0,
+    /* 15936 */ 0260,01,045,01,0162,0206,021,0,
+    /* 15944 */ 0260,01,045,01,0163,0216,022,0,
+    /* 15952 */ 0260,01,045,01,0163,0206,021,0,
+    /* 15960 */ 0260,01,045,01,0161,0214,022,0,
+    /* 15968 */ 0260,01,045,01,0161,0204,021,0,
+    /* 15976 */ 0260,01,045,01,0162,0214,022,0,
+    /* 15984 */ 0260,01,045,01,0162,0204,021,0,
+    /* 15992 */ 0260,01,045,01,0163,0213,022,0,
+    /* 16000 */ 0260,01,045,01,0163,0203,021,0,
+    /* 16008 */ 0260,01,045,01,0161,0212,022,0,
+    /* 16016 */ 0260,01,045,01,0161,0202,021,0,
+    /* 16024 */ 0260,01,045,01,0162,0212,022,0,
+    /* 16032 */ 0260,01,045,01,0162,0202,021,0,
+    /* 16040 */ 0260,01,045,01,0163,0212,022,0,
+    /* 16048 */ 0260,01,045,01,0163,0202,021,0,
+    /* 16056 */ 0261,03,01,01,02,0120,023,0,
+    /* 16064 */ 0260,03,01,01,02,0110,022,0,
+    /* 16072 */ 0261,03,05,01,02,0120,023,0,
+    /* 16080 */ 0260,03,05,01,02,0110,022,0,
+    /* 16088 */ 0270,03,025,01,01,0110,022,0,
+    /* 16096 */ 0270,03,025,01,0,0110,022,0,
+    /* 16104 */ 0261,03,05,01,0106,0120,023,0,
+    /* 16112 */ 0260,03,05,01,0106,0110,022,0,
+    /* 16120 */ 0270,03,05,01,071,0101,022,0,
+    /* 16128 */ 0261,03,05,01,070,0120,023,0,
+    /* 16136 */ 0260,03,05,01,070,0110,022,0,
+    /* 16144 */ 0374,0262,02,021,01,0222,0110,0,
+    /* 16152 */ 0374,0262,02,021,01,0223,0110,0,
+    /* 16160 */ 0374,0262,02,025,01,0222,0110,0,
+    /* 16168 */ 0375,0262,02,025,01,0223,0110,0,
+    /* 16176 */ 0374,0262,02,01,01,0222,0110,0,
+    /* 16184 */ 0374,0262,02,01,01,0223,0110,0,
+    /* 16192 */ 0375,0262,02,05,01,0222,0110,0,
+    /* 16200 */ 0375,0262,02,05,01,0223,0110,0,
+    /* 16208 */ 0374,0262,02,01,01,0220,0110,0,
+    /* 16216 */ 0374,0262,02,01,01,0221,0110,0,
+    /* 16224 */ 0375,0262,02,05,01,0220,0110,0,
+    /* 16232 */ 0375,0262,02,05,01,0221,0110,0,
+    /* 16240 */ 0374,0262,02,021,01,0220,0110,0,
+    /* 16248 */ 0374,0262,02,021,01,0221,0110,0,
+    /* 16256 */ 0374,0262,02,025,01,0220,0110,0,
+    /* 16264 */ 0375,0262,02,025,01,0221,0110,0,
+    /* 16272 */ 0270,0112,0,01,020,0110,042,0,
+    /* 16280 */ 0270,0112,020,01,020,0110,042,0,
+    /* 16288 */ 0270,03,03,01,0360,0110,022,0,
+    /* 16296 */ 0270,03,023,01,0360,0110,022,0,
+    /* 16304 */ 0270,01,01,01,0222,0325,0110,0,
+    /* 16312 */ 0270,03,01,01,062,0110,022,0,
+    /* 16320 */ 0270,03,01,01,063,0110,022,0,
+    /* 16328 */ 0270,03,021,01,063,0110,022,0,
+    /* 16336 */ 0270,03,021,01,062,0110,022,0,
+    /* 16344 */ 0270,03,01,01,060,0110,022,0,
+    /* 16352 */ 0270,03,01,01,061,0110,022,0,
+    /* 16360 */ 0270,03,021,01,061,0110,022,0,
+    /* 16368 */ 0270,03,021,01,060,0110,022,0,
+    /* 16376 */ 0241,0201,021,0301,01,0130,0120,0,
+    /* 16384 */ 0240,0201,021,0301,01,0130,0110,0,
+    /* 16392 */ 0241,0201,025,0301,01,0130,0120,0,
+    /* 16400 */ 0240,0201,025,0301,01,0130,0110,0,
+    /* 16408 */ 0241,0201,031,0301,01,0130,0120,0,
+    /* 16416 */ 0240,0201,031,0301,01,0130,0110,0,
+    /* 16424 */ 0241,0201,0,0301,01,0130,0120,0,
+    /* 16432 */ 0240,0201,0,0301,01,0130,0110,0,
+    /* 16440 */ 0241,0201,04,0301,01,0130,0120,0,
+    /* 16448 */ 0240,0201,04,0301,01,0130,0110,0,
+    /* 16456 */ 0241,0201,010,0301,01,0130,0120,0,
+    /* 16464 */ 0240,0201,010,0301,01,0130,0110,0,
+    /* 16472 */ 0241,0201,023,0306,01,0130,0120,0,
+    /* 16480 */ 0240,0201,023,0306,01,0130,0110,0,
+    /* 16488 */ 0241,0201,02,0306,01,0130,0120,0,
+    /* 16496 */ 0240,0201,02,0306,01,0130,0110,0,
+    /* 16504 */ 0241,0201,021,0301,01,0125,0120,0,
+    /* 16512 */ 0240,0201,021,0301,01,0125,0110,0,
+    /* 16520 */ 0241,0201,025,0301,01,0125,0120,0,
+    /* 16528 */ 0240,0201,025,0301,01,0125,0110,0,
+    /* 16536 */ 0241,0201,031,0301,01,0125,0120,0,
+    /* 16544 */ 0240,0201,031,0301,01,0125,0110,0,
+    /* 16552 */ 0241,0201,0,0301,01,0125,0120,0,
+    /* 16560 */ 0240,0201,0,0301,01,0125,0110,0,
+    /* 16568 */ 0241,0201,04,0301,01,0125,0120,0,
+    /* 16576 */ 0240,0201,04,0301,01,0125,0110,0,
+    /* 16584 */ 0241,0201,010,0301,01,0125,0120,0,
+    /* 16592 */ 0240,0201,010,0301,01,0125,0110,0,
+    /* 16600 */ 0241,0201,021,0301,01,0124,0120,0,
+    /* 16608 */ 0240,0201,021,0301,01,0124,0110,0,
+    /* 16616 */ 0241,0201,025,0301,01,0124,0120,0,
+    /* 16624 */ 0240,0201,025,0301,01,0124,0110,0,
+    /* 16632 */ 0241,0201,031,0301,01,0124,0120,0,
+    /* 16640 */ 0240,0201,031,0301,01,0124,0110,0,
+    /* 16648 */ 0241,0201,0,0301,01,0124,0120,0,
+    /* 16656 */ 0240,0201,0,0301,01,0124,0110,0,
+    /* 16664 */ 0241,0201,04,0301,01,0124,0120,0,
+    /* 16672 */ 0240,0201,04,0301,01,0124,0110,0,
+    /* 16680 */ 0241,0201,010,0301,01,0124,0120,0,
+    /* 16688 */ 0240,0201,010,0301,01,0124,0110,0,
+    /* 16696 */ 0241,0202,021,0301,01,0145,0120,0,
+    /* 16704 */ 0241,0202,025,0301,01,0145,0120,0,
+    /* 16712 */ 0241,0202,031,0301,01,0145,0120,0,
+    /* 16720 */ 0241,0202,01,0301,01,0145,0120,0,
+    /* 16728 */ 0241,0202,05,0301,01,0145,0120,0,
+    /* 16736 */ 0241,0202,011,0301,01,0145,0120,0,
+    /* 16744 */ 0250,0202,05,0311,01,031,0110,0,
+    /* 16752 */ 0250,0202,011,0311,01,031,0110,0,
+    /* 16760 */ 0250,0202,05,0312,01,032,0110,0,
+    /* 16768 */ 0250,0202,011,0312,01,032,0110,0,
+    /* 16776 */ 0250,0202,011,0313,01,033,0110,0,
+    /* 16784 */ 0250,0202,025,0311,01,032,0110,0,
+    /* 16792 */ 0250,0202,031,0311,01,032,0110,0,
+    /* 16800 */ 0250,0202,031,0312,01,033,0110,0,
+    /* 16808 */ 0250,0202,01,0311,01,0131,0110,0,
+    /* 16816 */ 0250,0202,05,0311,01,0131,0110,0,
+    /* 16824 */ 0250,0202,011,0311,01,0131,0110,0,
+    /* 16832 */ 0250,0202,05,0312,01,0132,0110,0,
+    /* 16840 */ 0250,0202,011,0312,01,0132,0110,0,
+    /* 16848 */ 0250,0202,011,0313,01,0133,0110,0,
+    /* 16856 */ 0250,0202,025,0311,01,0132,0110,0,
+    /* 16864 */ 0250,0202,031,0311,01,0132,0110,0,
+    /* 16872 */ 0250,0202,031,0312,01,0133,0110,0,
+    /* 16880 */ 0250,0202,025,0306,01,031,0110,0,
+    /* 16888 */ 0250,0202,031,0306,01,031,0110,0,
+    /* 16896 */ 0250,0202,025,0300,01,031,0110,0,
+    /* 16904 */ 0250,0202,031,0300,01,031,0110,0,
+    /* 16912 */ 0250,0202,01,0306,01,030,0110,0,
+    /* 16920 */ 0250,0202,05,0306,01,030,0110,0,
+    /* 16928 */ 0250,0202,011,0306,01,030,0110,0,
+    /* 16936 */ 0250,0202,01,0300,01,030,0110,0,
+    /* 16944 */ 0250,0202,05,0300,01,030,0110,0,
+    /* 16952 */ 0250,0202,011,0300,01,030,0110,0,
+    /* 16960 */ 0250,0201,021,0306,01,057,0110,0,
+    /* 16968 */ 0250,0201,0,0306,01,057,0110,0,
+    /* 16976 */ 0250,0202,021,0306,01,0212,0101,0,
+    /* 16984 */ 0250,0202,025,0306,01,0212,0101,0,
+    /* 16992 */ 0250,0202,031,0306,01,0212,0101,0,
+    /* 17000 */ 0250,0202,021,0300,01,0212,0101,0,
+    /* 17008 */ 0250,0202,025,0300,01,0212,0101,0,
+    /* 17016 */ 0250,0202,031,0300,01,0212,0101,0,
+    /* 17024 */ 0250,0202,01,0306,01,0212,0101,0,
+    /* 17032 */ 0250,0202,05,0306,01,0212,0101,0,
+    /* 17040 */ 0250,0202,011,0306,01,0212,0101,0,
+    /* 17048 */ 0250,0202,01,0300,01,0212,0101,0,
+    /* 17056 */ 0250,0202,05,0300,01,0212,0101,0,
+    /* 17064 */ 0250,0202,011,0300,01,0212,0101,0,
+    /* 17072 */ 0250,0201,02,0302,01,0346,0110,0,
+    /* 17080 */ 0250,0201,06,0302,01,0346,0110,0,
+    /* 17088 */ 0250,0201,012,0302,01,0346,0110,0,
+    /* 17096 */ 0250,0201,0,0301,01,0133,0110,0,
+    /* 17104 */ 0250,0201,04,0301,01,0133,0110,0,
+    /* 17112 */ 0250,0201,010,0301,01,0133,0110,0,
+    /* 17120 */ 0250,0201,023,0301,01,0346,0110,0,
+    /* 17128 */ 0250,0201,027,0301,01,0346,0110,0,
+    /* 17136 */ 0250,0201,033,0301,01,0346,0110,0,
+    /* 17144 */ 0250,0201,021,0301,01,0132,0110,0,
+    /* 17152 */ 0250,0201,025,0301,01,0132,0110,0,
+    /* 17160 */ 0250,0201,031,0301,01,0132,0110,0,
+    /* 17168 */ 0250,0201,021,0301,01,0173,0110,0,
+    /* 17176 */ 0250,0201,025,0301,01,0173,0110,0,
+    /* 17184 */ 0250,0201,031,0301,01,0173,0110,0,
+    /* 17192 */ 0250,0201,020,0301,01,0171,0110,0,
+    /* 17200 */ 0250,0201,024,0301,01,0171,0110,0,
+    /* 17208 */ 0250,0201,030,0301,01,0171,0110,0,
+    /* 17216 */ 0250,0201,021,0301,01,0171,0110,0,
+    /* 17224 */ 0250,0201,025,0301,01,0171,0110,0,
+    /* 17232 */ 0250,0201,031,0301,01,0171,0110,0,
+    /* 17240 */ 0250,0202,01,0314,01,023,0110,0,
+    /* 17248 */ 0250,0202,05,0314,01,023,0110,0,
+    /* 17256 */ 0250,0202,011,0314,01,023,0110,0,
+    /* 17264 */ 0250,0201,01,0301,01,0133,0110,0,
+    /* 17272 */ 0250,0201,05,0301,01,0133,0110,0,
+    /* 17280 */ 0250,0201,011,0301,01,0133,0110,0,
+    /* 17288 */ 0250,0201,0,0302,01,0132,0110,0,
+    /* 17296 */ 0250,0201,04,0302,01,0132,0110,0,
+    /* 17304 */ 0250,0201,010,0302,01,0132,0110,0,
+    /* 17312 */ 0250,0201,01,0302,01,0173,0110,0,
+    /* 17320 */ 0250,0201,05,0302,01,0173,0110,0,
+    /* 17328 */ 0250,0201,011,0302,01,0173,0110,0,
+    /* 17336 */ 0250,0201,0,0301,01,0171,0110,0,
+    /* 17344 */ 0250,0201,04,0301,01,0171,0110,0,
+    /* 17352 */ 0250,0201,010,0301,01,0171,0110,0,
+    /* 17360 */ 0250,0201,01,0302,01,0171,0110,0,
+    /* 17368 */ 0250,0201,05,0302,01,0171,0110,0,
+    /* 17376 */ 0250,0201,011,0302,01,0171,0110,0,
+    /* 17384 */ 0250,0201,022,0301,01,0346,0110,0,
+    /* 17392 */ 0250,0201,026,0301,01,0346,0110,0,
+    /* 17400 */ 0250,0201,032,0301,01,0346,0110,0,
+    /* 17408 */ 0250,0201,020,0301,01,0133,0110,0,
+    /* 17416 */ 0250,0201,024,0301,01,0133,0110,0,
+    /* 17424 */ 0250,0201,030,0301,01,0133,0110,0,
+    /* 17432 */ 0250,0201,03,0310,01,055,0110,0,
+    /* 17440 */ 0250,0201,023,0310,01,055,0110,0,
+    /* 17448 */ 0241,0201,023,0306,01,0132,0120,0,
+    /* 17456 */ 0250,0201,03,0310,01,0171,0110,0,
+    /* 17464 */ 0250,0201,023,0310,01,0171,0110,0,
+    /* 17472 */ 0241,0201,03,0306,01,052,0120,0,
+    /* 17480 */ 0241,0201,023,0306,01,052,0120,0,
+    /* 17488 */ 0241,0201,02,0306,01,052,0120,0,
+    /* 17496 */ 0241,0201,022,0306,01,052,0120,0,
+    /* 17504 */ 0241,0201,02,0306,01,0132,0120,0,
+    /* 17512 */ 0250,0201,02,0307,01,055,0110,0,
+    /* 17520 */ 0250,0201,022,0307,01,055,0110,0,
+    /* 17528 */ 0250,0201,02,0307,01,0171,0110,0,
+    /* 17536 */ 0250,0201,022,0307,01,0171,0110,0,
+    /* 17544 */ 0250,0201,021,0301,01,0346,0110,0,
+    /* 17552 */ 0250,0201,025,0301,01,0346,0110,0,
+    /* 17560 */ 0250,0201,031,0301,01,0346,0110,0,
+    /* 17568 */ 0250,0201,021,0301,01,0172,0110,0,
+    /* 17576 */ 0250,0201,025,0301,01,0172,0110,0,
+    /* 17584 */ 0250,0201,031,0301,01,0172,0110,0,
+    /* 17592 */ 0250,0201,020,0301,01,0170,0110,0,
+    /* 17600 */ 0250,0201,024,0301,01,0170,0110,0,
+    /* 17608 */ 0250,0201,030,0301,01,0170,0110,0,
+    /* 17616 */ 0250,0201,021,0301,01,0170,0110,0,
+    /* 17624 */ 0250,0201,025,0301,01,0170,0110,0,
+    /* 17632 */ 0250,0201,031,0301,01,0170,0110,0,
+    /* 17640 */ 0250,0201,02,0301,01,0133,0110,0,
+    /* 17648 */ 0250,0201,06,0301,01,0133,0110,0,
+    /* 17656 */ 0250,0201,012,0301,01,0133,0110,0,
+    /* 17664 */ 0250,0201,01,0302,01,0172,0110,0,
+    /* 17672 */ 0250,0201,05,0302,01,0172,0110,0,
+    /* 17680 */ 0250,0201,011,0302,01,0172,0110,0,
+    /* 17688 */ 0250,0201,0,0301,01,0170,0110,0,
+    /* 17696 */ 0250,0201,04,0301,01,0170,0110,0,
+    /* 17704 */ 0250,0201,010,0301,01,0170,0110,0,
+    /* 17712 */ 0250,0201,01,0302,01,0170,0110,0,
+    /* 17720 */ 0250,0201,05,0302,01,0170,0110,0,
+    /* 17728 */ 0250,0201,011,0302,01,0170,0110,0,
+    /* 17736 */ 0250,0201,03,0310,01,054,0110,0,
+    /* 17744 */ 0250,0201,023,0310,01,054,0110,0,
+    /* 17752 */ 0250,0201,03,0310,01,0170,0110,0,
+    /* 17760 */ 0250,0201,023,0310,01,0170,0110,0,
+    /* 17768 */ 0250,0201,02,0307,01,054,0110,0,
+    /* 17776 */ 0250,0201,022,0307,01,054,0110,0,
+    /* 17784 */ 0250,0201,02,0307,01,0170,0110,0,
+    /* 17792 */ 0250,0201,022,0307,01,0170,0110,0,
+    /* 17800 */ 0250,0201,02,0302,01,0172,0110,0,
+    /* 17808 */ 0250,0201,06,0302,01,0172,0110,0,
+    /* 17816 */ 0250,0201,012,0302,01,0172,0110,0,
+    /* 17824 */ 0250,0201,03,0301,01,0172,0110,0,
+    /* 17832 */ 0250,0201,07,0301,01,0172,0110,0,
+    /* 17840 */ 0250,0201,013,0301,01,0172,0110,0,
+    /* 17848 */ 0250,0201,022,0301,01,0172,0110,0,
+    /* 17856 */ 0250,0201,026,0301,01,0172,0110,0,
+    /* 17864 */ 0250,0201,032,0301,01,0172,0110,0,
+    /* 17872 */ 0250,0201,023,0301,01,0172,0110,0,
+    /* 17880 */ 0250,0201,027,0301,01,0172,0110,0,
+    /* 17888 */ 0250,0201,033,0301,01,0172,0110,0,
+    /* 17896 */ 0241,0201,03,0306,01,0173,0120,0,
+    /* 17904 */ 0241,0201,023,0306,01,0173,0120,0,
+    /* 17912 */ 0241,0201,02,0306,01,0173,0120,0,
+    /* 17920 */ 0241,0201,022,0306,01,0173,0120,0,
+    /* 17928 */ 0241,0201,021,0301,01,0136,0120,0,
+    /* 17936 */ 0240,0201,021,0301,01,0136,0110,0,
+    /* 17944 */ 0241,0201,025,0301,01,0136,0120,0,
+    /* 17952 */ 0240,0201,025,0301,01,0136,0110,0,
+    /* 17960 */ 0241,0201,031,0301,01,0136,0120,0,
+    /* 17968 */ 0240,0201,031,0301,01,0136,0110,0,
+    /* 17976 */ 0241,0201,0,0301,01,0136,0120,0,
+    /* 17984 */ 0240,0201,0,0301,01,0136,0110,0,
+    /* 17992 */ 0241,0201,04,0301,01,0136,0120,0,
+    /* 18000 */ 0240,0201,04,0301,01,0136,0110,0,
+    /* 18008 */ 0241,0201,010,0301,01,0136,0120,0,
+    /* 18016 */ 0240,0201,010,0301,01,0136,0110,0,
+    /* 18024 */ 0241,0201,023,0306,01,0136,0120,0,
+    /* 18032 */ 0240,0201,023,0306,01,0136,0110,0,
+    /* 18040 */ 0241,0201,02,0306,01,0136,0120,0,
+    /* 18048 */ 0240,0201,02,0306,01,0136,0110,0,
+    /* 18056 */ 0250,0202,031,0301,01,0310,0110,0,
+    /* 18064 */ 0250,0202,011,0301,01,0310,0110,0,
+    /* 18072 */ 0250,0202,021,0306,01,0210,0110,0,
+    /* 18080 */ 0250,0202,025,0306,01,0210,0110,0,
+    /* 18088 */ 0250,0202,031,0306,01,0210,0110,0,
+    /* 18096 */ 0250,0202,01,0306,01,0210,0110,0,
+    /* 18104 */ 0250,0202,05,0306,01,0210,0110,0,
+    /* 18112 */ 0250,0202,011,0306,01,0210,0110,0,
+    /* 18120 */ 0241,0202,021,0301,01,0230,0120,0,
+    /* 18128 */ 0241,0202,025,0301,01,0230,0120,0,
+    /* 18136 */ 0241,0202,031,0301,01,0230,0120,0,
+    /* 18144 */ 0241,0202,01,0301,01,0230,0120,0,
+    /* 18152 */ 0241,0202,05,0301,01,0230,0120,0,
+    /* 18160 */ 0241,0202,011,0301,01,0230,0120,0,
+    /* 18168 */ 0241,0202,021,0306,01,0231,0120,0,
+    /* 18176 */ 0241,0202,01,0306,01,0231,0120,0,
+    /* 18184 */ 0241,0202,021,0301,01,0250,0120,0,
+    /* 18192 */ 0241,0202,025,0301,01,0250,0120,0,
+    /* 18200 */ 0241,0202,031,0301,01,0250,0120,0,
+    /* 18208 */ 0241,0202,01,0301,01,0250,0120,0,
+    /* 18216 */ 0241,0202,05,0301,01,0250,0120,0,
+    /* 18224 */ 0241,0202,011,0301,01,0250,0120,0,
+    /* 18232 */ 0241,0202,021,0306,01,0251,0120,0,
+    /* 18240 */ 0241,0202,01,0306,01,0251,0120,0,
+    /* 18248 */ 0241,0202,021,0301,01,0270,0120,0,
+    /* 18256 */ 0241,0202,025,0301,01,0270,0120,0,
+    /* 18264 */ 0241,0202,031,0301,01,0270,0120,0,
+    /* 18272 */ 0241,0202,01,0301,01,0270,0120,0,
+    /* 18280 */ 0241,0202,05,0301,01,0270,0120,0,
+    /* 18288 */ 0241,0202,011,0301,01,0270,0120,0,
+    /* 18296 */ 0241,0202,021,0306,01,0271,0120,0,
+    /* 18304 */ 0241,0202,01,0306,01,0271,0120,0,
+    /* 18312 */ 0241,0202,021,0301,01,0226,0120,0,
+    /* 18320 */ 0241,0202,025,0301,01,0226,0120,0,
+    /* 18328 */ 0241,0202,031,0301,01,0226,0120,0,
+    /* 18336 */ 0241,0202,01,0301,01,0226,0120,0,
+    /* 18344 */ 0241,0202,05,0301,01,0226,0120,0,
+    /* 18352 */ 0241,0202,011,0301,01,0226,0120,0,
+    /* 18360 */ 0241,0202,021,0301,01,0246,0120,0,
+    /* 18368 */ 0241,0202,025,0301,01,0246,0120,0,
+    /* 18376 */ 0241,0202,031,0301,01,0246,0120,0,
+    /* 18384 */ 0241,0202,01,0301,01,0246,0120,0,
+    /* 18392 */ 0241,0202,05,0301,01,0246,0120,0,
+    /* 18400 */ 0241,0202,011,0301,01,0246,0120,0,
+    /* 18408 */ 0241,0202,021,0301,01,0266,0120,0,
+    /* 18416 */ 0241,0202,025,0301,01,0266,0120,0,
+    /* 18424 */ 0241,0202,031,0301,01,0266,0120,0,
+    /* 18432 */ 0241,0202,01,0301,01,0266,0120,0,
+    /* 18440 */ 0241,0202,05,0301,01,0266,0120,0,
+    /* 18448 */ 0241,0202,011,0301,01,0266,0120,0,
+    /* 18456 */ 0241,0202,021,0301,01,0232,0120,0,
+    /* 18464 */ 0241,0202,025,0301,01,0232,0120,0,
+    /* 18472 */ 0241,0202,031,0301,01,0232,0120,0,
+    /* 18480 */ 0241,0202,01,0301,01,0232,0120,0,
+    /* 18488 */ 0241,0202,05,0301,01,0232,0120,0,
+    /* 18496 */ 0241,0202,011,0301,01,0232,0120,0,
+    /* 18504 */ 0241,0202,021,0306,01,0233,0120,0,
+    /* 18512 */ 0241,0202,01,0306,01,0233,0120,0,
+    /* 18520 */ 0241,0202,021,0301,01,0252,0120,0,
+    /* 18528 */ 0241,0202,025,0301,01,0252,0120,0,
+    /* 18536 */ 0241,0202,031,0301,01,0252,0120,0,
+    /* 18544 */ 0241,0202,01,0301,01,0252,0120,0,
+    /* 18552 */ 0241,0202,05,0301,01,0252,0120,0,
+    /* 18560 */ 0241,0202,011,0301,01,0252,0120,0,
+    /* 18568 */ 0241,0202,021,0306,01,0253,0120,0,
+    /* 18576 */ 0241,0202,01,0306,01,0253,0120,0,
+    /* 18584 */ 0241,0202,021,0301,01,0272,0120,0,
+    /* 18592 */ 0241,0202,025,0301,01,0272,0120,0,
+    /* 18600 */ 0241,0202,031,0301,01,0272,0120,0,
+    /* 18608 */ 0241,0202,01,0301,01,0272,0120,0,
+    /* 18616 */ 0241,0202,05,0301,01,0272,0120,0,
+    /* 18624 */ 0241,0202,011,0301,01,0272,0120,0,
+    /* 18632 */ 0241,0202,021,0306,01,0273,0120,0,
+    /* 18640 */ 0241,0202,01,0306,01,0273,0120,0,
+    /* 18648 */ 0241,0202,021,0301,01,0227,0120,0,
+    /* 18656 */ 0241,0202,025,0301,01,0227,0120,0,
+    /* 18664 */ 0241,0202,031,0301,01,0227,0120,0,
+    /* 18672 */ 0241,0202,01,0301,01,0227,0120,0,
+    /* 18680 */ 0241,0202,05,0301,01,0227,0120,0,
+    /* 18688 */ 0241,0202,011,0301,01,0227,0120,0,
+    /* 18696 */ 0241,0202,021,0301,01,0247,0120,0,
+    /* 18704 */ 0241,0202,025,0301,01,0247,0120,0,
+    /* 18712 */ 0241,0202,031,0301,01,0247,0120,0,
+    /* 18720 */ 0241,0202,01,0301,01,0247,0120,0,
+    /* 18728 */ 0241,0202,05,0301,01,0247,0120,0,
+    /* 18736 */ 0241,0202,011,0301,01,0247,0120,0,
+    /* 18744 */ 0241,0202,021,0301,01,0267,0120,0,
+    /* 18752 */ 0241,0202,025,0301,01,0267,0120,0,
+    /* 18760 */ 0241,0202,031,0301,01,0267,0120,0,
+    /* 18768 */ 0241,0202,01,0301,01,0267,0120,0,
+    /* 18776 */ 0241,0202,05,0301,01,0267,0120,0,
+    /* 18784 */ 0241,0202,011,0301,01,0267,0120,0,
+    /* 18792 */ 0241,0202,021,0301,01,0234,0120,0,
+    /* 18800 */ 0241,0202,025,0301,01,0234,0120,0,
+    /* 18808 */ 0241,0202,031,0301,01,0234,0120,0,
+    /* 18816 */ 0241,0202,01,0301,01,0234,0120,0,
+    /* 18824 */ 0241,0202,05,0301,01,0234,0120,0,
+    /* 18832 */ 0241,0202,011,0301,01,0234,0120,0,
+    /* 18840 */ 0241,0202,021,0306,01,0235,0120,0,
+    /* 18848 */ 0241,0202,01,0306,01,0235,0120,0,
+    /* 18856 */ 0241,0202,021,0301,01,0254,0120,0,
+    /* 18864 */ 0241,0202,025,0301,01,0254,0120,0,
+    /* 18872 */ 0241,0202,031,0301,01,0254,0120,0,
+    /* 18880 */ 0241,0202,01,0301,01,0254,0120,0,
+    /* 18888 */ 0241,0202,05,0301,01,0254,0120,0,
+    /* 18896 */ 0241,0202,011,0301,01,0254,0120,0,
+    /* 18904 */ 0241,0202,021,0306,01,0255,0120,0,
+    /* 18912 */ 0241,0202,01,0306,01,0255,0120,0,
+    /* 18920 */ 0241,0202,021,0301,01,0274,0120,0,
+    /* 18928 */ 0241,0202,025,0301,01,0274,0120,0,
+    /* 18936 */ 0241,0202,031,0301,01,0274,0120,0,
+    /* 18944 */ 0241,0202,01,0301,01,0274,0120,0,
+    /* 18952 */ 0241,0202,05,0301,01,0274,0120,0,
+    /* 18960 */ 0241,0202,011,0301,01,0274,0120,0,
+    /* 18968 */ 0241,0202,021,0306,01,0275,0120,0,
+    /* 18976 */ 0241,0202,01,0306,01,0275,0120,0,
+    /* 18984 */ 0241,0202,021,0301,01,0236,0120,0,
+    /* 18992 */ 0241,0202,025,0301,01,0236,0120,0,
+    /* 19000 */ 0241,0202,031,0301,01,0236,0120,0,
+    /* 19008 */ 0241,0202,01,0301,01,0236,0120,0,
+    /* 19016 */ 0241,0202,05,0301,01,0236,0120,0,
+    /* 19024 */ 0241,0202,011,0301,01,0236,0120,0,
+    /* 19032 */ 0241,0202,021,0306,01,0237,0120,0,
+    /* 19040 */ 0241,0202,01,0306,01,0237,0120,0,
+    /* 19048 */ 0241,0202,021,0301,01,0256,0120,0,
+    /* 19056 */ 0241,0202,025,0301,01,0256,0120,0,
+    /* 19064 */ 0241,0202,031,0301,01,0256,0120,0,
+    /* 19072 */ 0241,0202,01,0301,01,0256,0120,0,
+    /* 19080 */ 0241,0202,05,0301,01,0256,0120,0,
+    /* 19088 */ 0241,0202,011,0301,01,0256,0120,0,
+    /* 19096 */ 0241,0202,021,0306,01,0257,0120,0,
+    /* 19104 */ 0241,0202,01,0306,01,0257,0120,0,
+    /* 19112 */ 0241,0202,021,0301,01,0276,0120,0,
+    /* 19120 */ 0241,0202,025,0301,01,0276,0120,0,
+    /* 19128 */ 0241,0202,031,0301,01,0276,0120,0,
+    /* 19136 */ 0241,0202,01,0301,01,0276,0120,0,
+    /* 19144 */ 0241,0202,05,0301,01,0276,0120,0,
+    /* 19152 */ 0241,0202,011,0301,01,0276,0120,0,
+    /* 19160 */ 0241,0202,021,0306,01,0277,0120,0,
+    /* 19168 */ 0241,0202,01,0306,01,0277,0120,0,
+    /* 19176 */ 0250,0202,021,0301,01,0102,0110,0,
+    /* 19184 */ 0250,0202,025,0301,01,0102,0110,0,
+    /* 19192 */ 0250,0202,031,0301,01,0102,0110,0,
+    /* 19200 */ 0250,0202,01,0301,01,0102,0110,0,
+    /* 19208 */ 0250,0202,05,0301,01,0102,0110,0,
+    /* 19216 */ 0250,0202,011,0301,01,0102,0110,0,
+    /* 19224 */ 0241,0202,021,0306,01,0103,0120,0,
+    /* 19232 */ 0241,0202,01,0306,01,0103,0120,0,
+    /* 19240 */ 0241,0201,021,0301,01,0137,0120,0,
+    /* 19248 */ 0240,0201,021,0301,01,0137,0110,0,
+    /* 19256 */ 0241,0201,025,0301,01,0137,0120,0,
+    /* 19264 */ 0240,0201,025,0301,01,0137,0110,0,
+    /* 19272 */ 0241,0201,031,0301,01,0137,0120,0,
+    /* 19280 */ 0240,0201,031,0301,01,0137,0110,0,
+    /* 19288 */ 0241,0201,0,0301,01,0137,0120,0,
+    /* 19296 */ 0240,0201,0,0301,01,0137,0110,0,
+    /* 19304 */ 0241,0201,04,0301,01,0137,0120,0,
+    /* 19312 */ 0240,0201,04,0301,01,0137,0110,0,
+    /* 19320 */ 0241,0201,010,0301,01,0137,0120,0,
+    /* 19328 */ 0240,0201,010,0301,01,0137,0110,0,
+    /* 19336 */ 0241,0201,023,0306,01,0137,0120,0,
+    /* 19344 */ 0240,0201,023,0306,01,0137,0110,0,
+    /* 19352 */ 0241,0201,02,0306,01,0137,0120,0,
+    /* 19360 */ 0240,0201,02,0306,01,0137,0110,0,
+    /* 19368 */ 0241,0201,021,0301,01,0135,0120,0,
+    /* 19376 */ 0240,0201,021,0301,01,0135,0110,0,
+    /* 19384 */ 0241,0201,025,0301,01,0135,0120,0,
+    /* 19392 */ 0240,0201,025,0301,01,0135,0110,0,
+    /* 19400 */ 0241,0201,031,0301,01,0135,0120,0,
+    /* 19408 */ 0240,0201,031,0301,01,0135,0110,0,
+    /* 19416 */ 0241,0201,0,0301,01,0135,0120,0,
+    /* 19424 */ 0240,0201,0,0301,01,0135,0110,0,
+    /* 19432 */ 0241,0201,04,0301,01,0135,0120,0,
+    /* 19440 */ 0240,0201,04,0301,01,0135,0110,0,
+    /* 19448 */ 0241,0201,010,0301,01,0135,0120,0,
+    /* 19456 */ 0240,0201,010,0301,01,0135,0110,0,
+    /* 19464 */ 0241,0201,023,0306,01,0135,0120,0,
+    /* 19472 */ 0240,0201,023,0306,01,0135,0110,0,
+    /* 19480 */ 0241,0201,02,0306,01,0135,0120,0,
+    /* 19488 */ 0240,0201,02,0306,01,0135,0110,0,
+    /* 19496 */ 0250,0201,021,0303,01,050,0110,0,
+    /* 19504 */ 0250,0201,025,0303,01,050,0110,0,
+    /* 19512 */ 0250,0201,031,0303,01,050,0110,0,
+    /* 19520 */ 0250,0201,021,0300,01,051,0101,0,
+    /* 19528 */ 0250,0201,025,0300,01,051,0101,0,
+    /* 19536 */ 0250,0201,031,0300,01,051,0101,0,
+    /* 19544 */ 0250,0201,021,0303,01,051,0101,0,
+    /* 19552 */ 0250,0201,025,0303,01,051,0101,0,
+    /* 19560 */ 0250,0201,031,0303,01,051,0101,0,
+    /* 19568 */ 0250,0201,0,0303,01,050,0110,0,
+    /* 19576 */ 0250,0201,04,0303,01,050,0110,0,
+    /* 19584 */ 0250,0201,010,0303,01,050,0110,0,
+    /* 19592 */ 0250,0201,0,0300,01,051,0101,0,
+    /* 19600 */ 0250,0201,04,0300,01,051,0101,0,
+    /* 19608 */ 0250,0201,010,0300,01,051,0101,0,
+    /* 19616 */ 0250,0201,0,0303,01,051,0101,0,
+    /* 19624 */ 0250,0201,04,0303,01,051,0101,0,
+    /* 19632 */ 0250,0201,010,0303,01,051,0101,0,
+    /* 19640 */ 0250,0201,01,0306,01,0156,0110,0,
+    /* 19648 */ 0250,0201,01,0306,01,0176,0101,0,
+    /* 19656 */ 0250,0201,023,0320,01,022,0110,0,
+    /* 19664 */ 0250,0201,027,0320,01,022,0110,0,
+    /* 19672 */ 0250,0201,033,0320,01,022,0110,0,
+    /* 19680 */ 0250,0201,01,0303,01,0157,0110,0,
+    /* 19688 */ 0250,0201,05,0303,01,0157,0110,0,
+    /* 19696 */ 0250,0201,011,0303,01,0157,0110,0,
+    /* 19704 */ 0250,0201,01,0303,01,0177,0101,0,
+    /* 19712 */ 0250,0201,05,0303,01,0177,0101,0,
+    /* 19720 */ 0250,0201,011,0303,01,0177,0101,0,
+    /* 19728 */ 0250,0201,021,0303,01,0157,0110,0,
+    /* 19736 */ 0250,0201,025,0303,01,0157,0110,0,
+    /* 19744 */ 0250,0201,031,0303,01,0157,0110,0,
+    /* 19752 */ 0250,0201,021,0303,01,0177,0101,0,
+    /* 19760 */ 0250,0201,025,0303,01,0177,0101,0,
+    /* 19768 */ 0250,0201,031,0303,01,0177,0101,0,
+    /* 19776 */ 0250,0201,023,0303,01,0157,0110,0,
+    /* 19784 */ 0250,0201,027,0303,01,0157,0110,0,
+    /* 19792 */ 0250,0201,033,0303,01,0157,0110,0,
+    /* 19800 */ 0250,0201,023,0303,01,0177,0101,0,
+    /* 19808 */ 0250,0201,027,0303,01,0177,0101,0,
+    /* 19816 */ 0250,0201,033,0303,01,0177,0101,0,
+    /* 19824 */ 0250,0201,02,0303,01,0157,0110,0,
+    /* 19832 */ 0250,0201,06,0303,01,0157,0110,0,
+    /* 19840 */ 0250,0201,012,0303,01,0157,0110,0,
+    /* 19848 */ 0250,0201,02,0303,01,0177,0101,0,
+    /* 19856 */ 0250,0201,06,0303,01,0177,0101,0,
+    /* 19864 */ 0250,0201,012,0303,01,0177,0101,0,
+    /* 19872 */ 0250,0201,022,0303,01,0157,0110,0,
+    /* 19880 */ 0250,0201,026,0303,01,0157,0110,0,
+    /* 19888 */ 0250,0201,032,0303,01,0157,0110,0,
+    /* 19896 */ 0250,0201,022,0303,01,0177,0101,0,
+    /* 19904 */ 0250,0201,026,0303,01,0177,0101,0,
+    /* 19912 */ 0250,0201,032,0303,01,0177,0101,0,
+    /* 19920 */ 0250,0201,03,0303,01,0157,0110,0,
+    /* 19928 */ 0250,0201,07,0303,01,0157,0110,0,
+    /* 19936 */ 0250,0201,013,0303,01,0157,0110,0,
+    /* 19944 */ 0250,0201,03,0303,01,0177,0101,0,
+    /* 19952 */ 0250,0201,07,0303,01,0177,0101,0,
+    /* 19960 */ 0250,0201,013,0303,01,0177,0101,0,
+    /* 19968 */ 0241,0201,0,0300,01,022,0120,0,
+    /* 19976 */ 0240,0201,0,0300,01,022,0110,0,
+    /* 19984 */ 0241,0201,021,0306,01,026,0120,0,
+    /* 19992 */ 0240,0201,021,0306,01,026,0110,0,
+    /* 20000 */ 0250,0201,021,0306,01,027,0101,0,
+    /* 20008 */ 0241,0201,0,0311,01,026,0120,0,
+    /* 20016 */ 0240,0201,0,0311,01,026,0110,0,
+    /* 20024 */ 0250,0201,0,0311,01,027,0101,0,
+    /* 20032 */ 0241,0201,0,0300,01,026,0120,0,
+    /* 20040 */ 0240,0201,0,0300,01,026,0110,0,
+    /* 20048 */ 0241,0201,021,0306,01,022,0120,0,
+    /* 20056 */ 0240,0201,021,0306,01,022,0110,0,
+    /* 20064 */ 0250,0201,021,0306,01,023,0101,0,
+    /* 20072 */ 0241,0201,0,0311,01,022,0120,0,
+    /* 20080 */ 0240,0201,0,0311,01,022,0110,0,
+    /* 20088 */ 0250,0201,0,0311,01,023,0101,0,
+    /* 20096 */ 0250,0201,01,0303,01,0347,0101,0,
+    /* 20104 */ 0250,0201,05,0303,01,0347,0101,0,
+    /* 20112 */ 0250,0201,011,0303,01,0347,0101,0,
+    /* 20120 */ 0250,0202,01,0303,01,052,0110,0,
+    /* 20128 */ 0250,0202,05,0303,01,052,0110,0,
+    /* 20136 */ 0250,0202,011,0303,01,052,0110,0,
+    /* 20144 */ 0250,0201,021,0303,01,053,0101,0,
+    /* 20152 */ 0250,0201,025,0303,01,053,0101,0,
+    /* 20160 */ 0250,0201,031,0303,01,053,0101,0,
+    /* 20168 */ 0250,0201,0,0303,01,053,0101,0,
+    /* 20176 */ 0250,0201,04,0303,01,053,0101,0,
+    /* 20184 */ 0250,0201,010,0303,01,053,0101,0,
+    /* 20192 */ 0250,0201,021,0306,01,0156,0110,0,
+    /* 20200 */ 0250,0201,021,0306,01,0176,0101,0,
+    /* 20208 */ 0250,0201,022,0306,01,0176,0110,0,
+    /* 20216 */ 0250,0201,021,0306,01,0326,0101,0,
+    /* 20224 */ 0250,0201,023,0306,01,020,0110,0,
+    /* 20232 */ 0250,0201,023,0306,01,021,0101,0,
+    /* 20240 */ 0241,0201,023,0300,01,020,0120,0,
+    /* 20248 */ 0240,0201,023,0300,01,020,0110,0,
+    /* 20256 */ 0241,0201,023,0300,01,021,0102,0,
+    /* 20264 */ 0240,0201,023,0300,01,021,0101,0,
+    /* 20272 */ 0250,0201,02,0303,01,026,0110,0,
+    /* 20280 */ 0250,0201,06,0303,01,026,0110,0,
+    /* 20288 */ 0250,0201,012,0303,01,026,0110,0,
+    /* 20296 */ 0250,0201,02,0303,01,022,0110,0,
+    /* 20304 */ 0250,0201,06,0303,01,022,0110,0,
+    /* 20312 */ 0250,0201,012,0303,01,022,0110,0,
+    /* 20320 */ 0250,0201,02,0306,01,020,0110,0,
+    /* 20328 */ 0250,0201,02,0306,01,021,0101,0,
+    /* 20336 */ 0241,0201,02,0300,01,020,0120,0,
+    /* 20344 */ 0240,0201,02,0300,01,020,0110,0,
+    /* 20352 */ 0241,0201,02,0300,01,021,0102,0,
+    /* 20360 */ 0240,0201,02,0300,01,021,0101,0,
+    /* 20368 */ 0250,0201,021,0303,01,020,0110,0,
+    /* 20376 */ 0250,0201,025,0303,01,020,0110,0,
+    /* 20384 */ 0250,0201,031,0303,01,020,0110,0,
+    /* 20392 */ 0250,0201,021,0300,01,021,0101,0,
+    /* 20400 */ 0250,0201,025,0300,01,021,0101,0,
+    /* 20408 */ 0250,0201,031,0300,01,021,0101,0,
+    /* 20416 */ 0250,0201,021,0303,01,021,0101,0,
+    /* 20424 */ 0250,0201,025,0303,01,021,0101,0,
+    /* 20432 */ 0250,0201,031,0303,01,021,0101,0,
+    /* 20440 */ 0250,0201,0,0303,01,020,0110,0,
+    /* 20448 */ 0250,0201,04,0303,01,020,0110,0,
+    /* 20456 */ 0250,0201,010,0303,01,020,0110,0,
+    /* 20464 */ 0250,0201,0,0300,01,021,0101,0,
+    /* 20472 */ 0250,0201,04,0300,01,021,0101,0,
+    /* 20480 */ 0250,0201,010,0300,01,021,0101,0,
+    /* 20488 */ 0250,0201,0,0303,01,021,0101,0,
+    /* 20496 */ 0250,0201,04,0303,01,021,0101,0,
+    /* 20504 */ 0250,0201,010,0303,01,021,0101,0,
+    /* 20512 */ 0241,0201,021,0301,01,0131,0120,0,
+    /* 20520 */ 0240,0201,021,0301,01,0131,0110,0,
+    /* 20528 */ 0241,0201,025,0301,01,0131,0120,0,
+    /* 20536 */ 0240,0201,025,0301,01,0131,0110,0,
+    /* 20544 */ 0241,0201,031,0301,01,0131,0120,0,
+    /* 20552 */ 0240,0201,031,0301,01,0131,0110,0,
+    /* 20560 */ 0241,0201,0,0301,01,0131,0120,0,
+    /* 20568 */ 0240,0201,0,0301,01,0131,0110,0,
+    /* 20576 */ 0241,0201,04,0301,01,0131,0120,0,
+    /* 20584 */ 0240,0201,04,0301,01,0131,0110,0,
+    /* 20592 */ 0241,0201,010,0301,01,0131,0120,0,
+    /* 20600 */ 0240,0201,010,0301,01,0131,0110,0,
+    /* 20608 */ 0241,0201,023,0306,01,0131,0120,0,
+    /* 20616 */ 0240,0201,023,0306,01,0131,0110,0,
+    /* 20624 */ 0241,0201,02,0306,01,0131,0120,0,
+    /* 20632 */ 0240,0201,02,0306,01,0131,0110,0,
+    /* 20640 */ 0241,0201,021,0301,01,0126,0120,0,
+    /* 20648 */ 0240,0201,021,0301,01,0126,0110,0,
+    /* 20656 */ 0241,0201,025,0301,01,0126,0120,0,
+    /* 20664 */ 0240,0201,025,0301,01,0126,0110,0,
+    /* 20672 */ 0241,0201,031,0301,01,0126,0120,0,
+    /* 20680 */ 0240,0201,031,0301,01,0126,0110,0,
+    /* 20688 */ 0241,0201,0,0301,01,0126,0120,0,
+    /* 20696 */ 0240,0201,0,0301,01,0126,0110,0,
+    /* 20704 */ 0241,0201,04,0301,01,0126,0120,0,
+    /* 20712 */ 0240,0201,04,0301,01,0126,0110,0,
+    /* 20720 */ 0241,0201,010,0301,01,0126,0120,0,
+    /* 20728 */ 0240,0201,010,0301,01,0126,0110,0,
+    /* 20736 */ 0250,0202,041,0303,01,034,0110,0,
+    /* 20744 */ 0250,0202,045,0303,01,034,0110,0,
+    /* 20752 */ 0250,0202,051,0303,01,034,0110,0,
+    /* 20760 */ 0250,0202,01,0301,01,036,0110,0,
+    /* 20768 */ 0250,0202,05,0301,01,036,0110,0,
+    /* 20776 */ 0250,0202,011,0301,01,036,0110,0,
+    /* 20784 */ 0250,0202,021,0301,01,037,0110,0,
+    /* 20792 */ 0250,0202,025,0301,01,037,0110,0,
+    /* 20800 */ 0250,0202,031,0301,01,037,0110,0,
+    /* 20808 */ 0250,0202,041,0303,01,035,0110,0,
+    /* 20816 */ 0250,0202,045,0303,01,035,0110,0,
+    /* 20824 */ 0250,0202,051,0303,01,035,0110,0,
+    /* 20832 */ 0241,0201,01,0301,01,0153,0120,0,
+    /* 20840 */ 0240,0201,01,0301,01,0153,0110,0,
+    /* 20848 */ 0241,0201,05,0301,01,0153,0120,0,
+    /* 20856 */ 0240,0201,05,0301,01,0153,0110,0,
+    /* 20864 */ 0241,0201,011,0301,01,0153,0120,0,
+    /* 20872 */ 0240,0201,011,0301,01,0153,0110,0,
+    /* 20880 */ 0241,0201,041,0303,01,0143,0120,0,
+    /* 20888 */ 0240,0201,041,0303,01,0143,0110,0,
+    /* 20896 */ 0241,0201,045,0303,01,0143,0120,0,
+    /* 20904 */ 0240,0201,045,0303,01,0143,0110,0,
+    /* 20912 */ 0241,0201,051,0303,01,0143,0120,0,
+    /* 20920 */ 0240,0201,051,0303,01,0143,0110,0,
+    /* 20928 */ 0241,0202,01,0301,01,053,0120,0,
+    /* 20936 */ 0240,0202,01,0301,01,053,0110,0,
+    /* 20944 */ 0241,0202,05,0301,01,053,0120,0,
+    /* 20952 */ 0240,0202,05,0301,01,053,0110,0,
+    /* 20960 */ 0241,0202,011,0301,01,053,0120,0,
+    /* 20968 */ 0240,0202,011,0301,01,053,0110,0,
+    /* 20976 */ 0241,0201,041,0303,01,0147,0120,0,
+    /* 20984 */ 0240,0201,041,0303,01,0147,0110,0,
+    /* 20992 */ 0241,0201,045,0303,01,0147,0120,0,
+    /* 21000 */ 0240,0201,045,0303,01,0147,0110,0,
+    /* 21008 */ 0241,0201,051,0303,01,0147,0120,0,
+    /* 21016 */ 0240,0201,051,0303,01,0147,0110,0,
+    /* 21024 */ 0241,0201,041,0303,01,0374,0120,0,
+    /* 21032 */ 0240,0201,041,0303,01,0374,0110,0,
+    /* 21040 */ 0241,0201,045,0303,01,0374,0120,0,
+    /* 21048 */ 0240,0201,045,0303,01,0374,0110,0,
+    /* 21056 */ 0241,0201,051,0303,01,0374,0120,0,
+    /* 21064 */ 0240,0201,051,0303,01,0374,0110,0,
+    /* 21072 */ 0241,0201,01,0301,01,0376,0120,0,
+    /* 21080 */ 0240,0201,01,0301,01,0376,0110,0,
+    /* 21088 */ 0241,0201,05,0301,01,0376,0120,0,
+    /* 21096 */ 0240,0201,05,0301,01,0376,0110,0,
+    /* 21104 */ 0241,0201,011,0301,01,0376,0120,0,
+    /* 21112 */ 0240,0201,011,0301,01,0376,0110,0,
+    /* 21120 */ 0241,0201,021,0301,01,0324,0120,0,
+    /* 21128 */ 0240,0201,021,0301,01,0324,0110,0,
+    /* 21136 */ 0241,0201,025,0301,01,0324,0120,0,
+    /* 21144 */ 0240,0201,025,0301,01,0324,0110,0,
+    /* 21152 */ 0241,0201,031,0301,01,0324,0120,0,
+    /* 21160 */ 0240,0201,031,0301,01,0324,0110,0,
+    /* 21168 */ 0241,0201,041,0303,01,0354,0120,0,
+    /* 21176 */ 0240,0201,041,0303,01,0354,0110,0,
+    /* 21184 */ 0241,0201,045,0303,01,0354,0120,0,
+    /* 21192 */ 0240,0201,045,0303,01,0354,0110,0,
+    /* 21200 */ 0241,0201,051,0303,01,0354,0120,0,
+    /* 21208 */ 0240,0201,051,0303,01,0354,0110,0,
+    /* 21216 */ 0241,0201,041,0303,01,0355,0120,0,
+    /* 21224 */ 0240,0201,041,0303,01,0355,0110,0,
+    /* 21232 */ 0241,0201,045,0303,01,0355,0120,0,
+    /* 21240 */ 0240,0201,045,0303,01,0355,0110,0,
+    /* 21248 */ 0241,0201,051,0303,01,0355,0120,0,
+    /* 21256 */ 0240,0201,051,0303,01,0355,0110,0,
+    /* 21264 */ 0241,0201,041,0303,01,0334,0120,0,
+    /* 21272 */ 0240,0201,041,0303,01,0334,0110,0,
+    /* 21280 */ 0241,0201,045,0303,01,0334,0120,0,
+    /* 21288 */ 0240,0201,045,0303,01,0334,0110,0,
+    /* 21296 */ 0241,0201,051,0303,01,0334,0120,0,
+    /* 21304 */ 0240,0201,051,0303,01,0334,0110,0,
+    /* 21312 */ 0241,0201,041,0303,01,0335,0120,0,
+    /* 21320 */ 0240,0201,041,0303,01,0335,0110,0,
+    /* 21328 */ 0241,0201,045,0303,01,0335,0120,0,
+    /* 21336 */ 0240,0201,045,0303,01,0335,0110,0,
+    /* 21344 */ 0241,0201,051,0303,01,0335,0120,0,
+    /* 21352 */ 0240,0201,051,0303,01,0335,0110,0,
+    /* 21360 */ 0241,0201,041,0303,01,0375,0120,0,
+    /* 21368 */ 0240,0201,041,0303,01,0375,0110,0,
+    /* 21376 */ 0241,0201,045,0303,01,0375,0120,0,
+    /* 21384 */ 0240,0201,045,0303,01,0375,0110,0,
+    /* 21392 */ 0241,0201,051,0303,01,0375,0120,0,
+    /* 21400 */ 0240,0201,051,0303,01,0375,0110,0,
+    /* 21408 */ 0241,0201,01,0301,01,0333,0120,0,
+    /* 21416 */ 0240,0201,01,0301,01,0333,0110,0,
+    /* 21424 */ 0241,0201,05,0301,01,0333,0120,0,
+    /* 21432 */ 0240,0201,05,0301,01,0333,0110,0,
+    /* 21440 */ 0241,0201,011,0301,01,0333,0120,0,
+    /* 21448 */ 0240,0201,011,0301,01,0333,0110,0,
+    /* 21456 */ 0241,0201,01,0301,01,0337,0120,0,
+    /* 21464 */ 0240,0201,01,0301,01,0337,0110,0,
+    /* 21472 */ 0241,0201,05,0301,01,0337,0120,0,
+    /* 21480 */ 0240,0201,05,0301,01,0337,0110,0,
+    /* 21488 */ 0241,0201,011,0301,01,0337,0120,0,
+    /* 21496 */ 0240,0201,011,0301,01,0337,0110,0,
+    /* 21504 */ 0241,0201,021,0301,01,0337,0120,0,
+    /* 21512 */ 0240,0201,021,0301,01,0337,0110,0,
+    /* 21520 */ 0241,0201,025,0301,01,0337,0120,0,
+    /* 21528 */ 0240,0201,025,0301,01,0337,0110,0,
+    /* 21536 */ 0241,0201,031,0301,01,0337,0120,0,
+    /* 21544 */ 0240,0201,031,0301,01,0337,0110,0,
+    /* 21552 */ 0241,0201,021,0301,01,0333,0120,0,
+    /* 21560 */ 0240,0201,021,0301,01,0333,0110,0,
+    /* 21568 */ 0241,0201,025,0301,01,0333,0120,0,
+    /* 21576 */ 0240,0201,025,0301,01,0333,0110,0,
+    /* 21584 */ 0241,0201,031,0301,01,0333,0120,0,
+    /* 21592 */ 0240,0201,031,0301,01,0333,0110,0,
+    /* 21600 */ 0241,0201,041,0303,01,0340,0120,0,
+    /* 21608 */ 0240,0201,041,0303,01,0340,0110,0,
+    /* 21616 */ 0241,0201,045,0303,01,0340,0120,0,
+    /* 21624 */ 0240,0201,045,0303,01,0340,0110,0,
+    /* 21632 */ 0241,0201,051,0303,01,0340,0120,0,
+    /* 21640 */ 0240,0201,051,0303,01,0340,0110,0,
+    /* 21648 */ 0241,0201,041,0303,01,0343,0120,0,
+    /* 21656 */ 0240,0201,041,0303,01,0343,0110,0,
+    /* 21664 */ 0241,0201,045,0303,01,0343,0120,0,
+    /* 21672 */ 0240,0201,045,0303,01,0343,0110,0,
+    /* 21680 */ 0241,0201,051,0303,01,0343,0120,0,
+    /* 21688 */ 0240,0201,051,0303,01,0343,0110,0,
+    /* 21696 */ 0241,0202,01,0303,01,0146,0120,0,
+    /* 21704 */ 0241,0202,05,0303,01,0146,0120,0,
+    /* 21712 */ 0241,0202,011,0303,01,0146,0120,0,
+    /* 21720 */ 0241,0202,01,0301,01,0144,0120,0,
+    /* 21728 */ 0241,0202,05,0301,01,0144,0120,0,
+    /* 21736 */ 0241,0202,011,0301,01,0144,0120,0,
+    /* 21744 */ 0241,0202,021,0301,01,0144,0120,0,
+    /* 21752 */ 0241,0202,025,0301,01,0144,0120,0,
+    /* 21760 */ 0241,0202,031,0301,01,0144,0120,0,
+    /* 21768 */ 0241,0202,021,0303,01,0146,0120,0,
+    /* 21776 */ 0241,0202,025,0303,01,0146,0120,0,
+    /* 21784 */ 0241,0202,031,0303,01,0146,0120,0,
+    /* 21792 */ 0250,0202,01,0304,01,0170,0110,0,
+    /* 21800 */ 0250,0202,05,0304,01,0170,0110,0,
+    /* 21808 */ 0250,0202,011,0304,01,0170,0110,0,
+    /* 21816 */ 0250,0202,01,0300,01,0172,0110,0,
+    /* 21824 */ 0250,0202,05,0300,01,0172,0110,0,
+    /* 21832 */ 0250,0202,011,0300,01,0172,0110,0,
+    /* 21840 */ 0250,0202,01,0306,01,0130,0110,0,
+    /* 21848 */ 0250,0202,05,0306,01,0130,0110,0,
+    /* 21856 */ 0250,0202,011,0306,01,0130,0110,0,
+    /* 21864 */ 0250,0202,01,0300,01,0130,0110,0,
+    /* 21872 */ 0250,0202,05,0300,01,0130,0110,0,
+    /* 21880 */ 0250,0202,011,0300,01,0130,0110,0,
+    /* 21888 */ 0250,0202,01,0300,01,0174,0110,0,
+    /* 21896 */ 0250,0202,05,0300,01,0174,0110,0,
+    /* 21904 */ 0250,0202,011,0300,01,0174,0110,0,
+    /* 21912 */ 0250,0202,022,0300,01,052,0110,0,
+    /* 21920 */ 0250,0202,026,0300,01,052,0110,0,
+    /* 21928 */ 0250,0202,032,0300,01,052,0110,0,
+    /* 21936 */ 0250,0202,02,0300,01,072,0110,0,
+    /* 21944 */ 0250,0202,06,0300,01,072,0110,0,
+    /* 21952 */ 0250,0202,012,0300,01,072,0110,0,
+    /* 21960 */ 0250,0202,021,0306,01,0131,0110,0,
+    /* 21968 */ 0250,0202,025,0306,01,0131,0110,0,
+    /* 21976 */ 0250,0202,031,0306,01,0131,0110,0,
+    /* 21984 */ 0250,0202,021,0300,01,0131,0110,0,
+    /* 21992 */ 0250,0202,025,0300,01,0131,0110,0,
+    /* 22000 */ 0250,0202,031,0300,01,0131,0110,0,
+    /* 22008 */ 0250,0202,021,0300,01,0174,0110,0,
+    /* 22016 */ 0250,0202,025,0300,01,0174,0110,0,
+    /* 22024 */ 0250,0202,031,0300,01,0174,0110,0,
+    /* 22032 */ 0250,0202,01,0305,01,0171,0110,0,
+    /* 22040 */ 0250,0202,05,0305,01,0171,0110,0,
+    /* 22048 */ 0250,0202,011,0305,01,0171,0110,0,
+    /* 22056 */ 0250,0202,01,0300,01,0173,0110,0,
+    /* 22064 */ 0250,0202,05,0300,01,0173,0110,0,
+    /* 22072 */ 0250,0202,011,0300,01,0173,0110,0,
+    /* 22080 */ 0241,0201,041,0303,01,0164,0120,0,
+    /* 22088 */ 0241,0201,045,0303,01,0164,0120,0,
+    /* 22096 */ 0241,0201,051,0303,01,0164,0120,0,
+    /* 22104 */ 0241,0201,01,0301,01,0166,0120,0,
+    /* 22112 */ 0241,0201,05,0301,01,0166,0120,0,
+    /* 22120 */ 0241,0201,011,0301,01,0166,0120,0,
+    /* 22128 */ 0241,0202,021,0301,01,051,0120,0,
+    /* 22136 */ 0241,0202,025,0301,01,051,0120,0,
+    /* 22144 */ 0241,0202,031,0301,01,051,0120,0,
+    /* 22152 */ 0241,0201,041,0303,01,0165,0120,0,
+    /* 22160 */ 0241,0201,045,0303,01,0165,0120,0,
+    /* 22168 */ 0241,0201,051,0303,01,0165,0120,0,
+    /* 22176 */ 0241,0201,041,0303,01,0144,0120,0,
+    /* 22184 */ 0241,0201,045,0303,01,0144,0120,0,
+    /* 22192 */ 0241,0201,051,0303,01,0144,0120,0,
+    /* 22200 */ 0241,0201,01,0301,01,0146,0120,0,
+    /* 22208 */ 0241,0201,05,0301,01,0146,0120,0,
+    /* 22216 */ 0241,0201,011,0301,01,0146,0120,0,
+    /* 22224 */ 0241,0202,021,0301,01,067,0120,0,
+    /* 22232 */ 0241,0202,025,0301,01,067,0120,0,
+    /* 22240 */ 0241,0202,031,0301,01,067,0120,0,
+    /* 22248 */ 0241,0201,041,0303,01,0145,0120,0,
+    /* 22256 */ 0241,0201,045,0303,01,0145,0120,0,
+    /* 22264 */ 0241,0201,051,0303,01,0145,0120,0,
+    /* 22272 */ 0250,0202,01,0306,01,0213,0101,0,
+    /* 22280 */ 0250,0202,05,0306,01,0213,0101,0,
+    /* 22288 */ 0250,0202,011,0306,01,0213,0101,0,
+    /* 22296 */ 0250,0202,01,0300,01,0213,0101,0,
+    /* 22304 */ 0250,0202,05,0300,01,0213,0101,0,
+    /* 22312 */ 0250,0202,011,0300,01,0213,0101,0,
+    /* 22320 */ 0250,0202,021,0306,01,0213,0101,0,
+    /* 22328 */ 0250,0202,025,0306,01,0213,0101,0,
+    /* 22336 */ 0250,0202,031,0306,01,0213,0101,0,
+    /* 22344 */ 0250,0202,021,0300,01,0213,0101,0,
+    /* 22352 */ 0250,0202,025,0300,01,0213,0101,0,
+    /* 22360 */ 0250,0202,031,0300,01,0213,0101,0,
+    /* 22368 */ 0250,0202,01,0301,01,0304,0110,0,
+    /* 22376 */ 0250,0202,05,0301,01,0304,0110,0,
+    /* 22384 */ 0250,0202,011,0301,01,0304,0110,0,
+    /* 22392 */ 0250,0202,021,0301,01,0304,0110,0,
+    /* 22400 */ 0250,0202,025,0301,01,0304,0110,0,
+    /* 22408 */ 0250,0202,031,0301,01,0304,0110,0,
+    /* 22416 */ 0241,0202,01,0303,01,0215,0120,0,
+    /* 22424 */ 0240,0202,01,0303,01,0215,0110,0,
+    /* 22432 */ 0241,0202,05,0303,01,0215,0120,0,
+    /* 22440 */ 0240,0202,05,0303,01,0215,0110,0,
+    /* 22448 */ 0241,0202,011,0303,01,0215,0120,0,
+    /* 22456 */ 0240,0202,011,0303,01,0215,0110,0,
+    /* 22464 */ 0241,0202,05,0301,01,066,0120,0,
+    /* 22472 */ 0240,0202,05,0301,01,066,0110,0,
+    /* 22480 */ 0241,0202,011,0301,01,066,0120,0,
+    /* 22488 */ 0240,0202,011,0301,01,066,0110,0,
+    /* 22496 */ 0241,0202,01,0303,01,0165,0120,0,
+    /* 22504 */ 0241,0202,05,0303,01,0165,0120,0,
+    /* 22512 */ 0241,0202,011,0303,01,0165,0120,0,
+    /* 22520 */ 0241,0202,01,0301,01,0166,0120,0,
+    /* 22528 */ 0241,0202,05,0301,01,0166,0120,0,
+    /* 22536 */ 0241,0202,011,0301,01,0166,0120,0,
+    /* 22544 */ 0241,0202,021,0301,01,0167,0120,0,
+    /* 22552 */ 0241,0202,025,0301,01,0167,0120,0,
+    /* 22560 */ 0241,0202,031,0301,01,0167,0120,0,
+    /* 22568 */ 0241,0202,01,0301,01,0167,0120,0,
+    /* 22576 */ 0241,0202,05,0301,01,0167,0120,0,
+    /* 22584 */ 0241,0202,011,0301,01,0167,0120,0,
+    /* 22592 */ 0241,0202,021,0301,01,0166,0120,0,
+    /* 22600 */ 0241,0202,025,0301,01,0166,0120,0,
+    /* 22608 */ 0241,0202,031,0301,01,0166,0120,0,
+    /* 22616 */ 0241,0202,021,0303,01,0165,0120,0,
+    /* 22624 */ 0241,0202,025,0303,01,0165,0120,0,
+    /* 22632 */ 0241,0202,031,0303,01,0165,0120,0,
+    /* 22640 */ 0241,0202,021,0301,01,015,0120,0,
+    /* 22648 */ 0240,0202,021,0301,01,015,0110,0,
+    /* 22656 */ 0241,0202,025,0301,01,015,0120,0,
+    /* 22664 */ 0240,0202,025,0301,01,015,0110,0,
+    /* 22672 */ 0241,0202,031,0301,01,015,0120,0,
+    /* 22680 */ 0240,0202,031,0301,01,015,0110,0,
+    /* 22688 */ 0241,0202,01,0301,01,014,0120,0,
+    /* 22696 */ 0240,0202,01,0301,01,014,0110,0,
+    /* 22704 */ 0241,0202,05,0301,01,014,0120,0,
+    /* 22712 */ 0240,0202,05,0301,01,014,0110,0,
+    /* 22720 */ 0241,0202,011,0301,01,014,0120,0,
+    /* 22728 */ 0240,0202,011,0301,01,014,0110,0,
+    /* 22736 */ 0241,0202,025,0301,01,026,0120,0,
+    /* 22744 */ 0240,0202,025,0301,01,026,0110,0,
+    /* 22752 */ 0241,0202,031,0301,01,026,0120,0,
+    /* 22760 */ 0240,0202,031,0301,01,026,0110,0,
+    /* 22768 */ 0241,0202,05,0301,01,026,0120,0,
+    /* 22776 */ 0240,0202,05,0301,01,026,0110,0,
+    /* 22784 */ 0241,0202,011,0301,01,026,0120,0,
+    /* 22792 */ 0240,0202,011,0301,01,026,0110,0,
+    /* 22800 */ 0241,0202,025,0301,01,066,0120,0,
+    /* 22808 */ 0240,0202,025,0301,01,066,0110,0,
+    /* 22816 */ 0241,0202,031,0301,01,066,0120,0,
+    /* 22824 */ 0240,0202,031,0301,01,066,0110,0,
+    /* 22832 */ 0241,0202,01,0303,01,0175,0120,0,
+    /* 22840 */ 0241,0202,05,0303,01,0175,0120,0,
+    /* 22848 */ 0241,0202,011,0303,01,0175,0120,0,
+    /* 22856 */ 0241,0202,01,0301,01,0176,0120,0,
+    /* 22864 */ 0241,0202,05,0301,01,0176,0120,0,
+    /* 22872 */ 0241,0202,011,0301,01,0176,0120,0,
+    /* 22880 */ 0241,0202,021,0301,01,0177,0120,0,
+    /* 22888 */ 0241,0202,025,0301,01,0177,0120,0,
+    /* 22896 */ 0241,0202,031,0301,01,0177,0120,0,
+    /* 22904 */ 0241,0202,01,0301,01,0177,0120,0,
+    /* 22912 */ 0241,0202,05,0301,01,0177,0120,0,
+    /* 22920 */ 0241,0202,011,0301,01,0177,0120,0,
+    /* 22928 */ 0241,0202,021,0301,01,0176,0120,0,
+    /* 22936 */ 0241,0202,025,0301,01,0176,0120,0,
+    /* 22944 */ 0241,0202,031,0301,01,0176,0120,0,
+    /* 22952 */ 0241,0202,021,0303,01,0175,0120,0,
+    /* 22960 */ 0241,0202,025,0303,01,0175,0120,0,
+    /* 22968 */ 0241,0202,031,0303,01,0175,0120,0,
+    /* 22976 */ 0241,0202,021,0303,01,0215,0120,0,
+    /* 22984 */ 0240,0202,021,0303,01,0215,0110,0,
+    /* 22992 */ 0241,0202,025,0303,01,0215,0120,0,
+    /* 23000 */ 0240,0202,025,0303,01,0215,0110,0,
+    /* 23008 */ 0241,0202,031,0303,01,0215,0120,0,
+    /* 23016 */ 0240,0202,031,0303,01,0215,0110,0,
+    /* 23024 */ 0250,0202,01,0306,01,0211,0110,0,
+    /* 23032 */ 0250,0202,05,0306,01,0211,0110,0,
+    /* 23040 */ 0250,0202,011,0306,01,0211,0110,0,
+    /* 23048 */ 0250,0202,021,0306,01,0211,0110,0,
+    /* 23056 */ 0250,0202,025,0306,01,0211,0110,0,
+    /* 23064 */ 0250,0202,031,0306,01,0211,0110,0,
+    /* 23072 */ 0250,0202,01,0301,01,0104,0110,0,
+    /* 23080 */ 0250,0202,05,0301,01,0104,0110,0,
+    /* 23088 */ 0250,0202,011,0301,01,0104,0110,0,
+    /* 23096 */ 0250,0202,021,0301,01,0104,0110,0,
+    /* 23104 */ 0250,0202,025,0301,01,0104,0110,0,
+    /* 23112 */ 0250,0202,031,0301,01,0104,0110,0,
+    /* 23120 */ 0241,0202,021,0301,01,0265,0120,0,
+    /* 23128 */ 0241,0202,025,0301,01,0265,0120,0,
+    /* 23136 */ 0241,0202,031,0301,01,0265,0120,0,
+    /* 23144 */ 0241,0202,021,0301,01,0264,0120,0,
+    /* 23152 */ 0241,0202,025,0301,01,0264,0120,0,
+    /* 23160 */ 0241,0202,031,0301,01,0264,0120,0,
+    /* 23168 */ 0241,0202,041,0303,01,04,0120,0,
+    /* 23176 */ 0240,0202,041,0303,01,04,0110,0,
+    /* 23184 */ 0241,0202,045,0303,01,04,0120,0,
+    /* 23192 */ 0240,0202,045,0303,01,04,0110,0,
+    /* 23200 */ 0241,0202,051,0303,01,04,0120,0,
+    /* 23208 */ 0240,0202,051,0303,01,04,0110,0,
+    /* 23216 */ 0241,0201,041,0303,01,0365,0120,0,
+    /* 23224 */ 0240,0201,041,0303,01,0365,0110,0,
+    /* 23232 */ 0241,0201,045,0303,01,0365,0120,0,
+    /* 23240 */ 0240,0201,045,0303,01,0365,0110,0,
+    /* 23248 */ 0241,0201,051,0303,01,0365,0120,0,
+    /* 23256 */ 0240,0201,051,0303,01,0365,0110,0,
+    /* 23264 */ 0241,0202,041,0303,01,074,0120,0,
+    /* 23272 */ 0240,0202,041,0303,01,074,0110,0,
+    /* 23280 */ 0241,0202,045,0303,01,074,0120,0,
+    /* 23288 */ 0240,0202,045,0303,01,074,0110,0,
+    /* 23296 */ 0241,0202,051,0303,01,074,0120,0,
+    /* 23304 */ 0240,0202,051,0303,01,074,0110,0,
+    /* 23312 */ 0241,0202,01,0301,01,075,0120,0,
+    /* 23320 */ 0240,0202,01,0301,01,075,0110,0,
+    /* 23328 */ 0241,0202,05,0301,01,075,0120,0,
+    /* 23336 */ 0240,0202,05,0301,01,075,0110,0,
+    /* 23344 */ 0241,0202,011,0301,01,075,0120,0,
+    /* 23352 */ 0240,0202,011,0301,01,075,0110,0,
+    /* 23360 */ 0241,0202,021,0301,01,075,0120,0,
+    /* 23368 */ 0240,0202,021,0301,01,075,0110,0,
+    /* 23376 */ 0241,0202,025,0301,01,075,0120,0,
+    /* 23384 */ 0240,0202,025,0301,01,075,0110,0,
+    /* 23392 */ 0241,0202,031,0301,01,075,0120,0,
+    /* 23400 */ 0240,0202,031,0301,01,075,0110,0,
+    /* 23408 */ 0241,0201,041,0303,01,0356,0120,0,
+    /* 23416 */ 0240,0201,041,0303,01,0356,0110,0,
+    /* 23424 */ 0241,0201,045,0303,01,0356,0120,0,
+    /* 23432 */ 0240,0201,045,0303,01,0356,0110,0,
+    /* 23440 */ 0241,0201,051,0303,01,0356,0120,0,
+    /* 23448 */ 0240,0201,051,0303,01,0356,0110,0,
+    /* 23456 */ 0241,0201,041,0303,01,0336,0120,0,
+    /* 23464 */ 0240,0201,041,0303,01,0336,0110,0,
+    /* 23472 */ 0241,0201,045,0303,01,0336,0120,0,
+    /* 23480 */ 0240,0201,045,0303,01,0336,0110,0,
+    /* 23488 */ 0241,0201,051,0303,01,0336,0120,0,
+    /* 23496 */ 0240,0201,051,0303,01,0336,0110,0,
+    /* 23504 */ 0241,0202,01,0301,01,077,0120,0,
+    /* 23512 */ 0240,0202,01,0301,01,077,0110,0,
+    /* 23520 */ 0241,0202,05,0301,01,077,0120,0,
+    /* 23528 */ 0240,0202,05,0301,01,077,0110,0,
+    /* 23536 */ 0241,0202,011,0301,01,077,0120,0,
+    /* 23544 */ 0240,0202,011,0301,01,077,0110,0,
+    /* 23552 */ 0241,0202,021,0301,01,077,0120,0,
+    /* 23560 */ 0240,0202,021,0301,01,077,0110,0,
+    /* 23568 */ 0241,0202,025,0301,01,077,0120,0,
+    /* 23576 */ 0240,0202,025,0301,01,077,0110,0,
+    /* 23584 */ 0241,0202,031,0301,01,077,0120,0,
+    /* 23592 */ 0240,0202,031,0301,01,077,0110,0,
+    /* 23600 */ 0241,0202,041,0303,01,076,0120,0,
+    /* 23608 */ 0240,0202,041,0303,01,076,0110,0,
+    /* 23616 */ 0241,0202,045,0303,01,076,0120,0,
+    /* 23624 */ 0240,0202,045,0303,01,076,0110,0,
+    /* 23632 */ 0241,0202,051,0303,01,076,0120,0,
+    /* 23640 */ 0240,0202,051,0303,01,076,0110,0,
+    /* 23648 */ 0241,0202,041,0303,01,070,0120,0,
+    /* 23656 */ 0240,0202,041,0303,01,070,0110,0,
+    /* 23664 */ 0241,0202,045,0303,01,070,0120,0,
+    /* 23672 */ 0240,0202,045,0303,01,070,0110,0,
+    /* 23680 */ 0241,0202,051,0303,01,070,0120,0,
+    /* 23688 */ 0240,0202,051,0303,01,070,0110,0,
+    /* 23696 */ 0241,0202,01,0301,01,071,0120,0,
+    /* 23704 */ 0240,0202,01,0301,01,071,0110,0,
+    /* 23712 */ 0241,0202,05,0301,01,071,0120,0,
+    /* 23720 */ 0240,0202,05,0301,01,071,0110,0,
+    /* 23728 */ 0241,0202,011,0301,01,071,0120,0,
+    /* 23736 */ 0240,0202,011,0301,01,071,0110,0,
+    /* 23744 */ 0241,0202,021,0301,01,071,0120,0,
+    /* 23752 */ 0240,0202,021,0301,01,071,0110,0,
+    /* 23760 */ 0241,0202,025,0301,01,071,0120,0,
+    /* 23768 */ 0240,0202,025,0301,01,071,0110,0,
+    /* 23776 */ 0241,0202,031,0301,01,071,0120,0,
+    /* 23784 */ 0240,0202,031,0301,01,071,0110,0,
+    /* 23792 */ 0241,0201,041,0303,01,0352,0120,0,
+    /* 23800 */ 0240,0201,041,0303,01,0352,0110,0,
+    /* 23808 */ 0241,0201,045,0303,01,0352,0120,0,
+    /* 23816 */ 0240,0201,045,0303,01,0352,0110,0,
+    /* 23824 */ 0241,0201,051,0303,01,0352,0120,0,
+    /* 23832 */ 0240,0201,051,0303,01,0352,0110,0,
+    /* 23840 */ 0241,0201,041,0303,01,0332,0120,0,
+    /* 23848 */ 0240,0201,041,0303,01,0332,0110,0,
+    /* 23856 */ 0241,0201,045,0303,01,0332,0120,0,
+    /* 23864 */ 0240,0201,045,0303,01,0332,0110,0,
+    /* 23872 */ 0241,0201,051,0303,01,0332,0120,0,
+    /* 23880 */ 0240,0201,051,0303,01,0332,0110,0,
+    /* 23888 */ 0241,0202,01,0301,01,073,0120,0,
+    /* 23896 */ 0240,0202,01,0301,01,073,0110,0,
+    /* 23904 */ 0241,0202,05,0301,01,073,0120,0,
+    /* 23912 */ 0240,0202,05,0301,01,073,0110,0,
+    /* 23920 */ 0241,0202,011,0301,01,073,0120,0,
+    /* 23928 */ 0240,0202,011,0301,01,073,0110,0,
+    /* 23936 */ 0241,0202,021,0301,01,073,0120,0,
+    /* 23944 */ 0240,0202,021,0301,01,073,0110,0,
+    /* 23952 */ 0241,0202,025,0301,01,073,0120,0,
+    /* 23960 */ 0240,0202,025,0301,01,073,0110,0,
+    /* 23968 */ 0241,0202,031,0301,01,073,0120,0,
+    /* 23976 */ 0240,0202,031,0301,01,073,0110,0,
+    /* 23984 */ 0241,0202,041,0303,01,072,0120,0,
+    /* 23992 */ 0240,0202,041,0303,01,072,0110,0,
+    /* 24000 */ 0241,0202,045,0303,01,072,0120,0,
+    /* 24008 */ 0240,0202,045,0303,01,072,0110,0,
+    /* 24016 */ 0241,0202,051,0303,01,072,0120,0,
+    /* 24024 */ 0240,0202,051,0303,01,072,0110,0,
+    /* 24032 */ 0250,0202,02,0300,01,051,0110,0,
+    /* 24040 */ 0250,0202,06,0300,01,051,0110,0,
+    /* 24048 */ 0250,0202,012,0300,01,051,0110,0,
+    /* 24056 */ 0250,0202,02,0300,01,071,0110,0,
+    /* 24064 */ 0250,0202,06,0300,01,071,0110,0,
+    /* 24072 */ 0250,0202,012,0300,01,071,0110,0,
+    /* 24080 */ 0250,0202,02,0300,01,061,0101,0,
+    /* 24088 */ 0250,0202,06,0300,01,061,0101,0,
+    /* 24096 */ 0250,0202,012,0300,01,061,0101,0,
+    /* 24104 */ 0250,0202,02,0315,01,061,0101,0,
+    /* 24112 */ 0250,0202,06,0315,01,061,0101,0,
+    /* 24120 */ 0250,0202,012,0315,01,061,0101,0,
+    /* 24128 */ 0250,0202,02,0300,01,063,0101,0,
+    /* 24136 */ 0250,0202,06,0300,01,063,0101,0,
+    /* 24144 */ 0250,0202,012,0300,01,063,0101,0,
+    /* 24152 */ 0250,0202,02,0314,01,063,0101,0,
+    /* 24160 */ 0250,0202,06,0314,01,063,0101,0,
+    /* 24168 */ 0250,0202,012,0314,01,063,0101,0,
+    /* 24176 */ 0250,0202,02,0300,01,050,0110,0,
+    /* 24184 */ 0250,0202,06,0300,01,050,0110,0,
+    /* 24192 */ 0250,0202,012,0300,01,050,0110,0,
+    /* 24200 */ 0250,0202,02,0300,01,070,0110,0,
+    /* 24208 */ 0250,0202,06,0300,01,070,0110,0,
+    /* 24216 */ 0250,0202,012,0300,01,070,0110,0,
+    /* 24224 */ 0250,0202,022,0300,01,070,0110,0,
+    /* 24232 */ 0250,0202,026,0300,01,070,0110,0,
+    /* 24240 */ 0250,0202,032,0300,01,070,0110,0,
+    /* 24248 */ 0250,0202,022,0300,01,050,0110,0,
+    /* 24256 */ 0250,0202,026,0300,01,050,0110,0,
+    /* 24264 */ 0250,0202,032,0300,01,050,0110,0,
+    /* 24272 */ 0250,0202,022,0300,01,071,0110,0,
+    /* 24280 */ 0250,0202,026,0300,01,071,0110,0,
+    /* 24288 */ 0250,0202,032,0300,01,071,0110,0,
+    /* 24296 */ 0250,0202,02,0300,01,062,0101,0,
+    /* 24304 */ 0250,0202,06,0300,01,062,0101,0,
+    /* 24312 */ 0250,0202,012,0300,01,062,0101,0,
+    /* 24320 */ 0250,0202,02,0316,01,062,0101,0,
+    /* 24328 */ 0250,0202,06,0316,01,062,0101,0,
+    /* 24336 */ 0250,0202,012,0316,01,062,0101,0,
+    /* 24344 */ 0250,0202,02,0300,01,065,0101,0,
+    /* 24352 */ 0250,0202,06,0300,01,065,0101,0,
+    /* 24360 */ 0250,0202,012,0300,01,065,0101,0,
+    /* 24368 */ 0250,0202,02,0314,01,065,0101,0,
+    /* 24376 */ 0250,0202,06,0314,01,065,0101,0,
+    /* 24384 */ 0250,0202,012,0314,01,065,0101,0,
+    /* 24392 */ 0250,0202,02,0300,01,064,0101,0,
+    /* 24400 */ 0250,0202,06,0300,01,064,0101,0,
+    /* 24408 */ 0250,0202,012,0300,01,064,0101,0,
+    /* 24416 */ 0250,0202,02,0315,01,064,0101,0,
+    /* 24424 */ 0250,0202,06,0315,01,064,0101,0,
+    /* 24432 */ 0250,0202,012,0315,01,064,0101,0,
+    /* 24440 */ 0250,0202,02,0300,01,041,0101,0,
+    /* 24448 */ 0250,0202,06,0300,01,041,0101,0,
+    /* 24456 */ 0250,0202,012,0300,01,041,0101,0,
+    /* 24464 */ 0250,0202,02,0315,01,041,0101,0,
+    /* 24472 */ 0250,0202,06,0315,01,041,0101,0,
+    /* 24480 */ 0250,0202,012,0315,01,041,0101,0,
+    /* 24488 */ 0250,0202,02,0300,01,043,0101,0,
+    /* 24496 */ 0250,0202,06,0300,01,043,0101,0,
+    /* 24504 */ 0250,0202,012,0300,01,043,0101,0,
+    /* 24512 */ 0250,0202,02,0314,01,043,0101,0,
+    /* 24520 */ 0250,0202,06,0314,01,043,0101,0,
+    /* 24528 */ 0250,0202,012,0314,01,043,0101,0,
+    /* 24536 */ 0250,0202,02,0300,01,042,0101,0,
+    /* 24544 */ 0250,0202,06,0300,01,042,0101,0,
+    /* 24552 */ 0250,0202,012,0300,01,042,0101,0,
+    /* 24560 */ 0250,0202,02,0316,01,042,0101,0,
+    /* 24568 */ 0250,0202,06,0316,01,042,0101,0,
+    /* 24576 */ 0250,0202,012,0316,01,042,0101,0,
+    /* 24584 */ 0250,0202,02,0300,01,045,0101,0,
+    /* 24592 */ 0250,0202,06,0300,01,045,0101,0,
+    /* 24600 */ 0250,0202,012,0300,01,045,0101,0,
+    /* 24608 */ 0250,0202,02,0314,01,045,0101,0,
+    /* 24616 */ 0250,0202,06,0314,01,045,0101,0,
+    /* 24624 */ 0250,0202,012,0314,01,045,0101,0,
+    /* 24632 */ 0250,0202,02,0300,01,044,0101,0,
+    /* 24640 */ 0250,0202,06,0300,01,044,0101,0,
+    /* 24648 */ 0250,0202,012,0300,01,044,0101,0,
+    /* 24656 */ 0250,0202,02,0315,01,044,0101,0,
+    /* 24664 */ 0250,0202,06,0315,01,044,0101,0,
+    /* 24672 */ 0250,0202,012,0315,01,044,0101,0,
+    /* 24680 */ 0250,0202,02,0300,01,040,0101,0,
+    /* 24688 */ 0250,0202,06,0300,01,040,0101,0,
+    /* 24696 */ 0250,0202,012,0300,01,040,0101,0,
+    /* 24704 */ 0250,0202,02,0314,01,040,0101,0,
+    /* 24712 */ 0250,0202,06,0314,01,040,0101,0,
+    /* 24720 */ 0250,0202,012,0314,01,040,0101,0,
+    /* 24728 */ 0250,0202,041,0315,01,041,0110,0,
+    /* 24736 */ 0250,0202,045,0315,01,041,0110,0,
+    /* 24744 */ 0250,0202,051,0315,01,041,0110,0,
+    /* 24752 */ 0250,0202,041,0316,01,042,0110,0,
+    /* 24760 */ 0250,0202,045,0316,01,042,0110,0,
+    /* 24768 */ 0250,0202,051,0316,01,042,0110,0,
+    /* 24776 */ 0250,0202,041,0314,01,040,0110,0,
+    /* 24784 */ 0250,0202,045,0314,01,040,0110,0,
+    /* 24792 */ 0250,0202,051,0314,01,040,0110,0,
+    /* 24800 */ 0250,0202,01,0314,01,045,0110,0,
+    /* 24808 */ 0250,0202,05,0314,01,045,0110,0,
+    /* 24816 */ 0250,0202,011,0314,01,045,0110,0,
+    /* 24824 */ 0250,0202,041,0314,01,043,0110,0,
+    /* 24832 */ 0250,0202,045,0314,01,043,0110,0,
+    /* 24840 */ 0250,0202,051,0314,01,043,0110,0,
+    /* 24848 */ 0250,0202,041,0315,01,044,0110,0,
+    /* 24856 */ 0250,0202,045,0315,01,044,0110,0,
+    /* 24864 */ 0250,0202,051,0315,01,044,0110,0,
+    /* 24872 */ 0250,0202,02,0300,01,021,0101,0,
+    /* 24880 */ 0250,0202,06,0300,01,021,0101,0,
+    /* 24888 */ 0250,0202,012,0300,01,021,0101,0,
+    /* 24896 */ 0250,0202,02,0315,01,021,0101,0,
+    /* 24904 */ 0250,0202,06,0315,01,021,0101,0,
+    /* 24912 */ 0250,0202,012,0315,01,021,0101,0,
+    /* 24920 */ 0250,0202,02,0300,01,023,0101,0,
+    /* 24928 */ 0250,0202,06,0300,01,023,0101,0,
+    /* 24936 */ 0250,0202,012,0300,01,023,0101,0,
+    /* 24944 */ 0250,0202,02,0314,01,023,0101,0,
+    /* 24952 */ 0250,0202,06,0314,01,023,0101,0,
+    /* 24960 */ 0250,0202,012,0314,01,023,0101,0,
+    /* 24968 */ 0250,0202,02,0300,01,022,0101,0,
+    /* 24976 */ 0250,0202,06,0300,01,022,0101,0,
+    /* 24984 */ 0250,0202,012,0300,01,022,0101,0,
+    /* 24992 */ 0250,0202,02,0316,01,022,0101,0,
+    /* 25000 */ 0250,0202,06,0316,01,022,0101,0,
+    /* 25008 */ 0250,0202,012,0316,01,022,0101,0,
+    /* 25016 */ 0250,0202,02,0300,01,025,0101,0,
+    /* 25024 */ 0250,0202,06,0300,01,025,0101,0,
+    /* 25032 */ 0250,0202,012,0300,01,025,0101,0,
+    /* 25040 */ 0250,0202,02,0314,01,025,0101,0,
+    /* 25048 */ 0250,0202,06,0314,01,025,0101,0,
+    /* 25056 */ 0250,0202,012,0314,01,025,0101,0,
+    /* 25064 */ 0250,0202,02,0300,01,024,0101,0,
+    /* 25072 */ 0250,0202,06,0300,01,024,0101,0,
+    /* 25080 */ 0250,0202,012,0300,01,024,0101,0,
+    /* 25088 */ 0250,0202,02,0315,01,024,0101,0,
+    /* 25096 */ 0250,0202,06,0315,01,024,0101,0,
+    /* 25104 */ 0250,0202,012,0315,01,024,0101,0,
+    /* 25112 */ 0250,0202,02,0300,01,020,0101,0,
+    /* 25120 */ 0250,0202,06,0300,01,020,0101,0,
+    /* 25128 */ 0250,0202,012,0300,01,020,0101,0,
+    /* 25136 */ 0250,0202,02,0314,01,020,0101,0,
+    /* 25144 */ 0250,0202,06,0314,01,020,0101,0,
+    /* 25152 */ 0250,0202,012,0314,01,020,0101,0,
+    /* 25160 */ 0250,0202,022,0300,01,051,0110,0,
+    /* 25168 */ 0250,0202,026,0300,01,051,0110,0,
+    /* 25176 */ 0250,0202,032,0300,01,051,0110,0,
+    /* 25184 */ 0250,0202,02,0300,01,060,0101,0,
+    /* 25192 */ 0250,0202,06,0300,01,060,0101,0,
+    /* 25200 */ 0250,0202,012,0300,01,060,0101,0,
+    /* 25208 */ 0250,0202,02,0314,01,060,0101,0,
+    /* 25216 */ 0250,0202,06,0314,01,060,0101,0,
+    /* 25224 */ 0250,0202,012,0314,01,060,0101,0,
+    /* 25232 */ 0250,0202,041,0315,01,061,0110,0,
+    /* 25240 */ 0250,0202,045,0315,01,061,0110,0,
+    /* 25248 */ 0250,0202,051,0315,01,061,0110,0,
+    /* 25256 */ 0250,0202,041,0316,01,062,0110,0,
+    /* 25264 */ 0250,0202,045,0316,01,062,0110,0,
+    /* 25272 */ 0250,0202,051,0316,01,062,0110,0,
+    /* 25280 */ 0250,0202,041,0314,01,060,0110,0,
+    /* 25288 */ 0250,0202,045,0314,01,060,0110,0,
+    /* 25296 */ 0250,0202,051,0314,01,060,0110,0,
+    /* 25304 */ 0250,0202,01,0314,01,065,0110,0,
+    /* 25312 */ 0250,0202,05,0314,01,065,0110,0,
+    /* 25320 */ 0250,0202,011,0314,01,065,0110,0,
+    /* 25328 */ 0250,0202,041,0314,01,063,0110,0,
+    /* 25336 */ 0250,0202,045,0314,01,063,0110,0,
+    /* 25344 */ 0250,0202,051,0314,01,063,0110,0,
+    /* 25352 */ 0250,0202,041,0315,01,064,0110,0,
+    /* 25360 */ 0250,0202,045,0315,01,064,0110,0,
+    /* 25368 */ 0250,0202,051,0315,01,064,0110,0,
+    /* 25376 */ 0241,0202,021,0301,01,050,0120,0,
+    /* 25384 */ 0240,0202,021,0301,01,050,0110,0,
+    /* 25392 */ 0241,0202,025,0301,01,050,0120,0,
+    /* 25400 */ 0240,0202,025,0301,01,050,0110,0,
+    /* 25408 */ 0241,0202,031,0301,01,050,0120,0,
+    /* 25416 */ 0240,0202,031,0301,01,050,0110,0,
+    /* 25424 */ 0241,0202,041,0303,01,013,0120,0,
+    /* 25432 */ 0240,0202,041,0303,01,013,0110,0,
+    /* 25440 */ 0241,0202,045,0303,01,013,0120,0,
+    /* 25448 */ 0240,0202,045,0303,01,013,0110,0,
+    /* 25456 */ 0241,0202,051,0303,01,013,0120,0,
+    /* 25464 */ 0240,0202,051,0303,01,013,0110,0,
+    /* 25472 */ 0241,0201,041,0303,01,0344,0120,0,
+    /* 25480 */ 0240,0201,041,0303,01,0344,0110,0,
+    /* 25488 */ 0241,0201,045,0303,01,0344,0120,0,
+    /* 25496 */ 0240,0201,045,0303,01,0344,0110,0,
+    /* 25504 */ 0241,0201,051,0303,01,0344,0120,0,
+    /* 25512 */ 0240,0201,051,0303,01,0344,0110,0,
+    /* 25520 */ 0241,0201,041,0303,01,0345,0120,0,
+    /* 25528 */ 0240,0201,041,0303,01,0345,0110,0,
+    /* 25536 */ 0241,0201,045,0303,01,0345,0120,0,
+    /* 25544 */ 0240,0201,045,0303,01,0345,0110,0,
+    /* 25552 */ 0241,0201,051,0303,01,0345,0120,0,
+    /* 25560 */ 0240,0201,051,0303,01,0345,0110,0,
+    /* 25568 */ 0241,0202,01,0301,01,0100,0120,0,
+    /* 25576 */ 0240,0202,01,0301,01,0100,0110,0,
+    /* 25584 */ 0241,0202,05,0301,01,0100,0120,0,
+    /* 25592 */ 0240,0202,05,0301,01,0100,0110,0,
+    /* 25600 */ 0241,0202,011,0301,01,0100,0120,0,
+    /* 25608 */ 0240,0202,011,0301,01,0100,0110,0,
+    /* 25616 */ 0241,0202,021,0301,01,0100,0120,0,
+    /* 25624 */ 0240,0202,021,0301,01,0100,0110,0,
+    /* 25632 */ 0241,0202,025,0301,01,0100,0120,0,
+    /* 25640 */ 0240,0202,025,0301,01,0100,0110,0,
+    /* 25648 */ 0241,0202,031,0301,01,0100,0120,0,
+    /* 25656 */ 0240,0202,031,0301,01,0100,0110,0,
+    /* 25664 */ 0241,0201,041,0303,01,0325,0120,0,
+    /* 25672 */ 0240,0201,041,0303,01,0325,0110,0,
+    /* 25680 */ 0241,0201,045,0303,01,0325,0120,0,
+    /* 25688 */ 0240,0201,045,0303,01,0325,0110,0,
+    /* 25696 */ 0241,0201,051,0303,01,0325,0120,0,
+    /* 25704 */ 0240,0201,051,0303,01,0325,0110,0,
+    /* 25712 */ 0241,0202,021,0301,01,0203,0120,0,
+    /* 25720 */ 0240,0202,021,0301,01,0203,0110,0,
+    /* 25728 */ 0241,0202,025,0301,01,0203,0120,0,
+    /* 25736 */ 0240,0202,025,0301,01,0203,0110,0,
+    /* 25744 */ 0241,0202,031,0301,01,0203,0120,0,
+    /* 25752 */ 0240,0202,031,0301,01,0203,0110,0,
+    /* 25760 */ 0241,0201,021,0301,01,0364,0120,0,
+    /* 25768 */ 0240,0201,021,0301,01,0364,0110,0,
+    /* 25776 */ 0241,0201,025,0301,01,0364,0120,0,
+    /* 25784 */ 0240,0201,025,0301,01,0364,0110,0,
+    /* 25792 */ 0241,0201,031,0301,01,0364,0120,0,
+    /* 25800 */ 0240,0201,031,0301,01,0364,0110,0,
+    /* 25808 */ 0241,0201,01,0301,01,0353,0120,0,
+    /* 25816 */ 0240,0201,01,0301,01,0353,0110,0,
+    /* 25824 */ 0241,0201,05,0301,01,0353,0120,0,
+    /* 25832 */ 0240,0201,05,0301,01,0353,0110,0,
+    /* 25840 */ 0241,0201,011,0301,01,0353,0120,0,
+    /* 25848 */ 0240,0201,011,0301,01,0353,0110,0,
+    /* 25856 */ 0241,0201,021,0301,01,0353,0120,0,
+    /* 25864 */ 0240,0201,021,0301,01,0353,0110,0,
+    /* 25872 */ 0241,0201,025,0301,01,0353,0120,0,
+    /* 25880 */ 0240,0201,025,0301,01,0353,0110,0,
+    /* 25888 */ 0241,0201,031,0301,01,0353,0120,0,
+    /* 25896 */ 0240,0201,031,0301,01,0353,0110,0,
+    /* 25904 */ 0241,0202,01,0301,01,025,0120,0,
+    /* 25912 */ 0240,0202,01,0301,01,025,0110,0,
+    /* 25920 */ 0241,0202,05,0301,01,025,0120,0,
+    /* 25928 */ 0240,0202,05,0301,01,025,0110,0,
+    /* 25936 */ 0241,0202,011,0301,01,025,0120,0,
+    /* 25944 */ 0240,0202,011,0301,01,025,0110,0,
+    /* 25952 */ 0241,0202,021,0301,01,025,0120,0,
+    /* 25960 */ 0240,0202,021,0301,01,025,0110,0,
+    /* 25968 */ 0241,0202,025,0301,01,025,0120,0,
+    /* 25976 */ 0240,0202,025,0301,01,025,0110,0,
+    /* 25984 */ 0241,0202,031,0301,01,025,0120,0,
+    /* 25992 */ 0240,0202,031,0301,01,025,0110,0,
+    /* 26000 */ 0241,0202,01,0301,01,024,0120,0,
+    /* 26008 */ 0240,0202,01,0301,01,024,0110,0,
+    /* 26016 */ 0241,0202,05,0301,01,024,0120,0,
+    /* 26024 */ 0240,0202,05,0301,01,024,0110,0,
+    /* 26032 */ 0241,0202,011,0301,01,024,0120,0,
+    /* 26040 */ 0240,0202,011,0301,01,024,0110,0,
+    /* 26048 */ 0241,0202,021,0301,01,024,0120,0,
+    /* 26056 */ 0240,0202,021,0301,01,024,0110,0,
+    /* 26064 */ 0241,0202,025,0301,01,024,0120,0,
+    /* 26072 */ 0240,0202,025,0301,01,024,0110,0,
+    /* 26080 */ 0241,0202,031,0301,01,024,0120,0,
+    /* 26088 */ 0240,0202,031,0301,01,024,0110,0,
+    /* 26096 */ 0241,0201,041,0303,01,0366,0120,0,
+    /* 26104 */ 0240,0201,041,0303,01,0366,0110,0,
+    /* 26112 */ 0241,0201,045,0303,01,0366,0120,0,
+    /* 26120 */ 0240,0201,045,0303,01,0366,0110,0,
+    /* 26128 */ 0241,0201,051,0303,01,0366,0120,0,
+    /* 26136 */ 0240,0201,051,0303,01,0366,0110,0,
+    /* 26144 */ 0241,0202,041,0303,01,0,0120,0,
+    /* 26152 */ 0240,0202,041,0303,01,0,0110,0,
+    /* 26160 */ 0241,0202,045,0303,01,0,0120,0,
+    /* 26168 */ 0240,0202,045,0303,01,0,0110,0,
+    /* 26176 */ 0241,0202,051,0303,01,0,0120,0,
+    /* 26184 */ 0240,0202,051,0303,01,0,0110,0,
+    /* 26192 */ 0241,0201,01,0317,01,0362,0120,0,
+    /* 26200 */ 0240,0201,01,0317,01,0362,0110,0,
+    /* 26208 */ 0241,0201,05,0317,01,0362,0120,0,
+    /* 26216 */ 0240,0201,05,0317,01,0362,0110,0,
+    /* 26224 */ 0241,0201,011,0317,01,0362,0120,0,
+    /* 26232 */ 0240,0201,011,0317,01,0362,0110,0,
+    /* 26240 */ 0241,0201,021,0317,01,0363,0120,0,
+    /* 26248 */ 0240,0201,021,0317,01,0363,0110,0,
+    /* 26256 */ 0241,0201,025,0317,01,0363,0120,0,
+    /* 26264 */ 0240,0201,025,0317,01,0363,0110,0,
+    /* 26272 */ 0241,0201,031,0317,01,0363,0120,0,
+    /* 26280 */ 0240,0201,031,0317,01,0363,0110,0,
+    /* 26288 */ 0241,0202,01,0301,01,0107,0120,0,
+    /* 26296 */ 0240,0202,01,0301,01,0107,0110,0,
+    /* 26304 */ 0241,0202,05,0301,01,0107,0120,0,
+    /* 26312 */ 0240,0202,05,0301,01,0107,0110,0,
+    /* 26320 */ 0241,0202,011,0301,01,0107,0120,0,
+    /* 26328 */ 0240,0202,011,0301,01,0107,0110,0,
+    /* 26336 */ 0241,0202,021,0301,01,0107,0120,0,
+    /* 26344 */ 0240,0202,021,0301,01,0107,0110,0,
+    /* 26352 */ 0241,0202,025,0301,01,0107,0120,0,
+    /* 26360 */ 0240,0202,025,0301,01,0107,0110,0,
+    /* 26368 */ 0241,0202,031,0301,01,0107,0120,0,
+    /* 26376 */ 0240,0202,031,0301,01,0107,0110,0,
+    /* 26384 */ 0241,0202,021,0303,01,022,0120,0,
+    /* 26392 */ 0240,0202,021,0303,01,022,0110,0,
+    /* 26400 */ 0241,0202,025,0303,01,022,0120,0,
+    /* 26408 */ 0240,0202,025,0303,01,022,0110,0,
+    /* 26416 */ 0241,0202,031,0303,01,022,0120,0,
+    /* 26424 */ 0240,0202,031,0303,01,022,0110,0,
+    /* 26432 */ 0241,0201,041,0317,01,0361,0120,0,
+    /* 26440 */ 0240,0201,041,0317,01,0361,0110,0,
+    /* 26448 */ 0241,0201,045,0317,01,0361,0120,0,
+    /* 26456 */ 0240,0201,045,0317,01,0361,0110,0,
+    /* 26464 */ 0241,0201,051,0317,01,0361,0120,0,
+    /* 26472 */ 0240,0201,051,0317,01,0361,0110,0,
+    /* 26480 */ 0241,0201,01,0317,01,0342,0120,0,
+    /* 26488 */ 0240,0201,01,0317,01,0342,0110,0,
+    /* 26496 */ 0241,0201,05,0317,01,0342,0120,0,
+    /* 26504 */ 0240,0201,05,0317,01,0342,0110,0,
+    /* 26512 */ 0241,0201,011,0317,01,0342,0120,0,
+    /* 26520 */ 0240,0201,011,0317,01,0342,0110,0,
+    /* 26528 */ 0241,0201,021,0317,01,0342,0120,0,
+    /* 26536 */ 0240,0201,021,0317,01,0342,0110,0,
+    /* 26544 */ 0241,0201,025,0317,01,0342,0120,0,
+    /* 26552 */ 0240,0201,025,0317,01,0342,0110,0,
+    /* 26560 */ 0241,0201,031,0317,01,0342,0120,0,
+    /* 26568 */ 0240,0201,031,0317,01,0342,0110,0,
+    /* 26576 */ 0241,0202,01,0301,01,0106,0120,0,
+    /* 26584 */ 0240,0202,01,0301,01,0106,0110,0,
+    /* 26592 */ 0241,0202,05,0301,01,0106,0120,0,
+    /* 26600 */ 0240,0202,05,0301,01,0106,0110,0,
+    /* 26608 */ 0241,0202,011,0301,01,0106,0120,0,
+    /* 26616 */ 0240,0202,011,0301,01,0106,0110,0,
+    /* 26624 */ 0241,0202,021,0301,01,0106,0120,0,
+    /* 26632 */ 0240,0202,021,0301,01,0106,0110,0,
+    /* 26640 */ 0241,0202,025,0301,01,0106,0120,0,
+    /* 26648 */ 0240,0202,025,0301,01,0106,0110,0,
+    /* 26656 */ 0241,0202,031,0301,01,0106,0120,0,
+    /* 26664 */ 0240,0202,031,0301,01,0106,0110,0,
+    /* 26672 */ 0241,0202,021,0303,01,021,0120,0,
+    /* 26680 */ 0240,0202,021,0303,01,021,0110,0,
+    /* 26688 */ 0241,0202,025,0303,01,021,0120,0,
+    /* 26696 */ 0240,0202,025,0303,01,021,0110,0,
+    /* 26704 */ 0241,0202,031,0303,01,021,0120,0,
+    /* 26712 */ 0240,0202,031,0303,01,021,0110,0,
+    /* 26720 */ 0241,0201,041,0317,01,0341,0120,0,
+    /* 26728 */ 0240,0201,041,0317,01,0341,0110,0,
+    /* 26736 */ 0241,0201,045,0317,01,0341,0120,0,
+    /* 26744 */ 0240,0201,045,0317,01,0341,0110,0,
+    /* 26752 */ 0241,0201,051,0317,01,0341,0120,0,
+    /* 26760 */ 0240,0201,051,0317,01,0341,0110,0,
+    /* 26768 */ 0241,0201,01,0317,01,0322,0120,0,
+    /* 26776 */ 0240,0201,01,0317,01,0322,0110,0,
+    /* 26784 */ 0241,0201,05,0317,01,0322,0120,0,
+    /* 26792 */ 0240,0201,05,0317,01,0322,0110,0,
+    /* 26800 */ 0241,0201,011,0317,01,0322,0120,0,
+    /* 26808 */ 0240,0201,011,0317,01,0322,0110,0,
+    /* 26816 */ 0241,0201,021,0317,01,0323,0120,0,
+    /* 26824 */ 0240,0201,021,0317,01,0323,0110,0,
+    /* 26832 */ 0241,0201,025,0317,01,0323,0120,0,
+    /* 26840 */ 0240,0201,025,0317,01,0323,0110,0,
+    /* 26848 */ 0241,0201,031,0317,01,0323,0120,0,
+    /* 26856 */ 0240,0201,031,0317,01,0323,0110,0,
+    /* 26864 */ 0241,0202,01,0301,01,0105,0120,0,
+    /* 26872 */ 0240,0202,01,0301,01,0105,0110,0,
+    /* 26880 */ 0241,0202,05,0301,01,0105,0120,0,
+    /* 26888 */ 0240,0202,05,0301,01,0105,0110,0,
+    /* 26896 */ 0241,0202,011,0301,01,0105,0120,0,
+    /* 26904 */ 0240,0202,011,0301,01,0105,0110,0,
+    /* 26912 */ 0241,0202,021,0301,01,0105,0120,0,
+    /* 26920 */ 0240,0202,021,0301,01,0105,0110,0,
+    /* 26928 */ 0241,0202,025,0301,01,0105,0120,0,
+    /* 26936 */ 0240,0202,025,0301,01,0105,0110,0,
+    /* 26944 */ 0241,0202,031,0301,01,0105,0120,0,
+    /* 26952 */ 0240,0202,031,0301,01,0105,0110,0,
+    /* 26960 */ 0241,0202,021,0303,01,020,0120,0,
+    /* 26968 */ 0240,0202,021,0303,01,020,0110,0,
+    /* 26976 */ 0241,0202,025,0303,01,020,0120,0,
+    /* 26984 */ 0240,0202,025,0303,01,020,0110,0,
+    /* 26992 */ 0241,0202,031,0303,01,020,0120,0,
+    /* 27000 */ 0240,0202,031,0303,01,020,0110,0,
+    /* 27008 */ 0241,0201,041,0317,01,0321,0120,0,
+    /* 27016 */ 0240,0201,041,0317,01,0321,0110,0,
+    /* 27024 */ 0241,0201,045,0317,01,0321,0120,0,
+    /* 27032 */ 0240,0201,045,0317,01,0321,0110,0,
+    /* 27040 */ 0241,0201,051,0317,01,0321,0120,0,
+    /* 27048 */ 0240,0201,051,0317,01,0321,0110,0,
+    /* 27056 */ 0241,0201,041,0303,01,0370,0120,0,
+    /* 27064 */ 0240,0201,041,0303,01,0370,0110,0,
+    /* 27072 */ 0241,0201,045,0303,01,0370,0120,0,
+    /* 27080 */ 0240,0201,045,0303,01,0370,0110,0,
+    /* 27088 */ 0241,0201,051,0303,01,0370,0120,0,
+    /* 27096 */ 0240,0201,051,0303,01,0370,0110,0,
+    /* 27104 */ 0241,0201,01,0301,01,0372,0120,0,
+    /* 27112 */ 0240,0201,01,0301,01,0372,0110,0,
+    /* 27120 */ 0241,0201,05,0301,01,0372,0120,0,
+    /* 27128 */ 0240,0201,05,0301,01,0372,0110,0,
+    /* 27136 */ 0241,0201,011,0301,01,0372,0120,0,
+    /* 27144 */ 0240,0201,011,0301,01,0372,0110,0,
+    /* 27152 */ 0241,0201,021,0301,01,0373,0120,0,
+    /* 27160 */ 0240,0201,021,0301,01,0373,0110,0,
+    /* 27168 */ 0241,0201,025,0301,01,0373,0120,0,
+    /* 27176 */ 0240,0201,025,0301,01,0373,0110,0,
+    /* 27184 */ 0241,0201,031,0301,01,0373,0120,0,
+    /* 27192 */ 0240,0201,031,0301,01,0373,0110,0,
+    /* 27200 */ 0241,0201,041,0303,01,0350,0120,0,
+    /* 27208 */ 0240,0201,041,0303,01,0350,0110,0,
+    /* 27216 */ 0241,0201,045,0303,01,0350,0120,0,
+    /* 27224 */ 0240,0201,045,0303,01,0350,0110,0,
+    /* 27232 */ 0241,0201,051,0303,01,0350,0120,0,
+    /* 27240 */ 0240,0201,051,0303,01,0350,0110,0,
+    /* 27248 */ 0241,0201,041,0303,01,0351,0120,0,
+    /* 27256 */ 0240,0201,041,0303,01,0351,0110,0,
+    /* 27264 */ 0241,0201,045,0303,01,0351,0120,0,
+    /* 27272 */ 0240,0201,045,0303,01,0351,0110,0,
+    /* 27280 */ 0241,0201,051,0303,01,0351,0120,0,
+    /* 27288 */ 0240,0201,051,0303,01,0351,0110,0,
+    /* 27296 */ 0241,0201,041,0303,01,0330,0120,0,
+    /* 27304 */ 0240,0201,041,0303,01,0330,0110,0,
+    /* 27312 */ 0241,0201,045,0303,01,0330,0120,0,
+    /* 27320 */ 0240,0201,045,0303,01,0330,0110,0,
+    /* 27328 */ 0241,0201,051,0303,01,0330,0120,0,
+    /* 27336 */ 0240,0201,051,0303,01,0330,0110,0,
+    /* 27344 */ 0241,0201,041,0303,01,0331,0120,0,
+    /* 27352 */ 0240,0201,041,0303,01,0331,0110,0,
+    /* 27360 */ 0241,0201,045,0303,01,0331,0120,0,
+    /* 27368 */ 0240,0201,045,0303,01,0331,0110,0,
+    /* 27376 */ 0241,0201,051,0303,01,0331,0120,0,
+    /* 27384 */ 0240,0201,051,0303,01,0331,0110,0,
+    /* 27392 */ 0241,0201,041,0303,01,0371,0120,0,
+    /* 27400 */ 0240,0201,041,0303,01,0371,0110,0,
+    /* 27408 */ 0241,0201,045,0303,01,0371,0120,0,
+    /* 27416 */ 0240,0201,045,0303,01,0371,0110,0,
+    /* 27424 */ 0241,0201,051,0303,01,0371,0120,0,
+    /* 27432 */ 0240,0201,051,0303,01,0371,0110,0,
+    /* 27440 */ 0241,0202,01,0303,01,046,0120,0,
+    /* 27448 */ 0241,0202,05,0303,01,046,0120,0,
+    /* 27456 */ 0241,0202,011,0303,01,046,0120,0,
+    /* 27464 */ 0241,0202,01,0301,01,047,0120,0,
+    /* 27472 */ 0241,0202,05,0301,01,047,0120,0,
+    /* 27480 */ 0241,0202,011,0301,01,047,0120,0,
+    /* 27488 */ 0241,0202,021,0301,01,047,0120,0,
+    /* 27496 */ 0241,0202,025,0301,01,047,0120,0,
+    /* 27504 */ 0241,0202,031,0301,01,047,0120,0,
+    /* 27512 */ 0241,0202,021,0303,01,046,0120,0,
+    /* 27520 */ 0241,0202,025,0303,01,046,0120,0,
+    /* 27528 */ 0241,0202,031,0303,01,046,0120,0,
+    /* 27536 */ 0241,0202,02,0303,01,046,0120,0,
+    /* 27544 */ 0241,0202,06,0303,01,046,0120,0,
+    /* 27552 */ 0241,0202,012,0303,01,046,0120,0,
+    /* 27560 */ 0241,0202,02,0301,01,047,0120,0,
+    /* 27568 */ 0241,0202,06,0301,01,047,0120,0,
+    /* 27576 */ 0241,0202,012,0301,01,047,0120,0,
+    /* 27584 */ 0241,0202,022,0301,01,047,0120,0,
+    /* 27592 */ 0241,0202,026,0301,01,047,0120,0,
+    /* 27600 */ 0241,0202,032,0301,01,047,0120,0,
+    /* 27608 */ 0241,0202,022,0303,01,046,0120,0,
+    /* 27616 */ 0241,0202,026,0303,01,046,0120,0,
+    /* 27624 */ 0241,0202,032,0303,01,046,0120,0,
+    /* 27632 */ 0241,0201,041,0303,01,0150,0120,0,
+    /* 27640 */ 0240,0201,041,0303,01,0150,0110,0,
+    /* 27648 */ 0241,0201,045,0303,01,0150,0120,0,
+    /* 27656 */ 0240,0201,045,0303,01,0150,0110,0,
+    /* 27664 */ 0241,0201,051,0303,01,0150,0120,0,
+    /* 27672 */ 0240,0201,051,0303,01,0150,0110,0,
+    /* 27680 */ 0241,0201,01,0301,01,0152,0120,0,
+    /* 27688 */ 0240,0201,01,0301,01,0152,0110,0,
+    /* 27696 */ 0241,0201,05,0301,01,0152,0120,0,
+    /* 27704 */ 0240,0201,05,0301,01,0152,0110,0,
+    /* 27712 */ 0241,0201,011,0301,01,0152,0120,0,
+    /* 27720 */ 0240,0201,011,0301,01,0152,0110,0,
+    /* 27728 */ 0241,0201,021,0301,01,0155,0120,0,
+    /* 27736 */ 0240,0201,021,0301,01,0155,0110,0,
+    /* 27744 */ 0241,0201,025,0301,01,0155,0120,0,
+    /* 27752 */ 0240,0201,025,0301,01,0155,0110,0,
+    /* 27760 */ 0241,0201,031,0301,01,0155,0120,0,
+    /* 27768 */ 0240,0201,031,0301,01,0155,0110,0,
+    /* 27776 */ 0241,0201,041,0303,01,0151,0120,0,
+    /* 27784 */ 0240,0201,041,0303,01,0151,0110,0,
+    /* 27792 */ 0241,0201,045,0303,01,0151,0120,0,
+    /* 27800 */ 0240,0201,045,0303,01,0151,0110,0,
+    /* 27808 */ 0241,0201,051,0303,01,0151,0120,0,
+    /* 27816 */ 0240,0201,051,0303,01,0151,0110,0,
+    /* 27824 */ 0241,0201,041,0303,01,0140,0120,0,
+    /* 27832 */ 0240,0201,041,0303,01,0140,0110,0,
+    /* 27840 */ 0241,0201,045,0303,01,0140,0120,0,
+    /* 27848 */ 0240,0201,045,0303,01,0140,0110,0,
+    /* 27856 */ 0241,0201,051,0303,01,0140,0120,0,
+    /* 27864 */ 0240,0201,051,0303,01,0140,0110,0,
+    /* 27872 */ 0241,0201,01,0301,01,0142,0120,0,
+    /* 27880 */ 0240,0201,01,0301,01,0142,0110,0,
+    /* 27888 */ 0241,0201,05,0301,01,0142,0120,0,
+    /* 27896 */ 0240,0201,05,0301,01,0142,0110,0,
+    /* 27904 */ 0241,0201,011,0301,01,0142,0120,0,
+    /* 27912 */ 0240,0201,011,0301,01,0142,0110,0,
+    /* 27920 */ 0241,0201,021,0301,01,0154,0120,0,
+    /* 27928 */ 0240,0201,021,0301,01,0154,0110,0,
+    /* 27936 */ 0241,0201,025,0301,01,0154,0120,0,
+    /* 27944 */ 0240,0201,025,0301,01,0154,0110,0,
+    /* 27952 */ 0241,0201,031,0301,01,0154,0120,0,
+    /* 27960 */ 0240,0201,031,0301,01,0154,0110,0,
+    /* 27968 */ 0241,0201,041,0303,01,0141,0120,0,
+    /* 27976 */ 0240,0201,041,0303,01,0141,0110,0,
+    /* 27984 */ 0241,0201,045,0303,01,0141,0120,0,
+    /* 27992 */ 0240,0201,045,0303,01,0141,0110,0,
+    /* 28000 */ 0241,0201,051,0303,01,0141,0120,0,
+    /* 28008 */ 0240,0201,051,0303,01,0141,0110,0,
+    /* 28016 */ 0241,0201,01,0301,01,0357,0120,0,
+    /* 28024 */ 0240,0201,01,0301,01,0357,0110,0,
+    /* 28032 */ 0241,0201,05,0301,01,0357,0120,0,
+    /* 28040 */ 0240,0201,05,0301,01,0357,0110,0,
+    /* 28048 */ 0241,0201,011,0301,01,0357,0120,0,
+    /* 28056 */ 0240,0201,011,0301,01,0357,0110,0,
+    /* 28064 */ 0241,0201,021,0301,01,0357,0120,0,
+    /* 28072 */ 0240,0201,021,0301,01,0357,0110,0,
+    /* 28080 */ 0241,0201,025,0301,01,0357,0120,0,
+    /* 28088 */ 0240,0201,025,0301,01,0357,0110,0,
+    /* 28096 */ 0241,0201,031,0301,01,0357,0120,0,
+    /* 28104 */ 0240,0201,031,0301,01,0357,0110,0,
+    /* 28112 */ 0250,0202,021,0301,01,0114,0110,0,
+    /* 28120 */ 0250,0202,025,0301,01,0114,0110,0,
+    /* 28128 */ 0250,0202,031,0301,01,0114,0110,0,
+    /* 28136 */ 0250,0202,01,0301,01,0114,0110,0,
+    /* 28144 */ 0250,0202,05,0301,01,0114,0110,0,
+    /* 28152 */ 0250,0202,011,0301,01,0114,0110,0,
+    /* 28160 */ 0241,0202,021,0306,01,0115,0120,0,
+    /* 28168 */ 0240,0202,021,0306,01,0115,0110,0,
+    /* 28176 */ 0241,0202,01,0306,01,0115,0120,0,
+    /* 28184 */ 0240,0202,01,0306,01,0115,0110,0,
+    /* 28192 */ 0250,0202,031,0301,01,0312,0110,0,
+    /* 28200 */ 0250,0202,011,0301,01,0312,0110,0,
+    /* 28208 */ 0241,0202,021,0306,01,0313,0120,0,
+    /* 28216 */ 0240,0202,021,0306,01,0313,0110,0,
+    /* 28224 */ 0241,0202,01,0306,01,0313,0120,0,
+    /* 28232 */ 0240,0202,01,0306,01,0313,0110,0,
+    /* 28240 */ 0250,0202,021,0301,01,0116,0110,0,
+    /* 28248 */ 0250,0202,025,0301,01,0116,0110,0,
+    /* 28256 */ 0250,0202,031,0301,01,0116,0110,0,
+    /* 28264 */ 0250,0202,01,0301,01,0116,0110,0,
+    /* 28272 */ 0250,0202,05,0301,01,0116,0110,0,
+    /* 28280 */ 0250,0202,011,0301,01,0116,0110,0,
+    /* 28288 */ 0241,0202,021,0306,01,0117,0120,0,
+    /* 28296 */ 0240,0202,021,0306,01,0117,0110,0,
+    /* 28304 */ 0241,0202,01,0306,01,0117,0120,0,
+    /* 28312 */ 0240,0202,01,0306,01,0117,0110,0,
+    /* 28320 */ 0250,0202,031,0301,01,0314,0110,0,
+    /* 28328 */ 0250,0202,011,0301,01,0314,0110,0,
+    /* 28336 */ 0241,0202,021,0306,01,0315,0120,0,
+    /* 28344 */ 0240,0202,021,0306,01,0315,0110,0,
+    /* 28352 */ 0241,0202,01,0306,01,0315,0120,0,
+    /* 28360 */ 0240,0202,01,0306,01,0315,0110,0,
+    /* 28368 */ 0241,0202,021,0301,01,054,0120,0,
+    /* 28376 */ 0240,0202,021,0301,01,054,0110,0,
+    /* 28384 */ 0241,0202,025,0301,01,054,0120,0,
+    /* 28392 */ 0240,0202,025,0301,01,054,0110,0,
+    /* 28400 */ 0241,0202,031,0301,01,054,0120,0,
+    /* 28408 */ 0240,0202,031,0301,01,054,0110,0,
+    /* 28416 */ 0241,0202,01,0301,01,054,0120,0,
+    /* 28424 */ 0240,0202,01,0301,01,054,0110,0,
+    /* 28432 */ 0241,0202,05,0301,01,054,0120,0,
+    /* 28440 */ 0240,0202,05,0301,01,054,0110,0,
+    /* 28448 */ 0241,0202,011,0301,01,054,0120,0,
+    /* 28456 */ 0240,0202,011,0301,01,054,0110,0,
+    /* 28464 */ 0241,0202,021,0306,01,055,0120,0,
+    /* 28472 */ 0240,0202,021,0306,01,055,0110,0,
+    /* 28480 */ 0241,0202,01,0306,01,055,0120,0,
+    /* 28488 */ 0240,0202,01,0306,01,055,0110,0,
+    /* 28496 */ 0250,0201,021,0301,01,0121,0110,0,
+    /* 28504 */ 0250,0201,025,0301,01,0121,0110,0,
+    /* 28512 */ 0250,0201,031,0301,01,0121,0110,0,
+    /* 28520 */ 0250,0201,0,0301,01,0121,0110,0,
+    /* 28528 */ 0250,0201,04,0301,01,0121,0110,0,
+    /* 28536 */ 0250,0201,010,0301,01,0121,0110,0,
+    /* 28544 */ 0241,0201,023,0306,01,0121,0120,0,
+    /* 28552 */ 0240,0201,023,0306,01,0121,0110,0,
+    /* 28560 */ 0241,0201,02,0306,01,0121,0120,0,
+    /* 28568 */ 0240,0201,02,0306,01,0121,0110,0,
+    /* 28576 */ 0241,0201,021,0301,01,0134,0120,0,
+    /* 28584 */ 0240,0201,021,0301,01,0134,0110,0,
+    /* 28592 */ 0241,0201,025,0301,01,0134,0120,0,
+    /* 28600 */ 0240,0201,025,0301,01,0134,0110,0,
+    /* 28608 */ 0241,0201,031,0301,01,0134,0120,0,
+    /* 28616 */ 0240,0201,031,0301,01,0134,0110,0,
+    /* 28624 */ 0241,0201,0,0301,01,0134,0120,0,
+    /* 28632 */ 0240,0201,0,0301,01,0134,0110,0,
+    /* 28640 */ 0241,0201,04,0301,01,0134,0120,0,
+    /* 28648 */ 0240,0201,04,0301,01,0134,0110,0,
+    /* 28656 */ 0241,0201,010,0301,01,0134,0120,0,
+    /* 28664 */ 0240,0201,010,0301,01,0134,0110,0,
+    /* 28672 */ 0241,0201,023,0306,01,0134,0120,0,
+    /* 28680 */ 0240,0201,023,0306,01,0134,0110,0,
+    /* 28688 */ 0241,0201,02,0306,01,0134,0120,0,
+    /* 28696 */ 0240,0201,02,0306,01,0134,0110,0,
+    /* 28704 */ 0250,0201,021,0306,01,056,0110,0,
+    /* 28712 */ 0250,0201,0,0306,01,056,0110,0,
+    /* 28720 */ 0241,0201,021,0301,01,025,0120,0,
+    /* 28728 */ 0240,0201,021,0301,01,025,0110,0,
+    /* 28736 */ 0241,0201,025,0301,01,025,0120,0,
+    /* 28744 */ 0240,0201,025,0301,01,025,0110,0,
+    /* 28752 */ 0241,0201,031,0301,01,025,0120,0,
+    /* 28760 */ 0240,0201,031,0301,01,025,0110,0,
+    /* 28768 */ 0241,0201,0,0301,01,025,0120,0,
+    /* 28776 */ 0240,0201,0,0301,01,025,0110,0,
+    /* 28784 */ 0241,0201,04,0301,01,025,0120,0,
+    /* 28792 */ 0240,0201,04,0301,01,025,0110,0,
+    /* 28800 */ 0241,0201,010,0301,01,025,0120,0,
+    /* 28808 */ 0240,0201,010,0301,01,025,0110,0,
+    /* 28816 */ 0241,0201,021,0301,01,024,0120,0,
+    /* 28824 */ 0240,0201,021,0301,01,024,0110,0,
+    /* 28832 */ 0241,0201,025,0301,01,024,0120,0,
+    /* 28840 */ 0240,0201,025,0301,01,024,0110,0,
+    /* 28848 */ 0241,0201,031,0301,01,024,0120,0,
+    /* 28856 */ 0240,0201,031,0301,01,024,0110,0,
+    /* 28864 */ 0241,0201,0,0301,01,024,0120,0,
+    /* 28872 */ 0240,0201,0,0301,01,024,0110,0,
+    /* 28880 */ 0241,0201,04,0301,01,024,0120,0,
+    /* 28888 */ 0240,0201,04,0301,01,024,0110,0,
+    /* 28896 */ 0241,0201,010,0301,01,024,0120,0,
+    /* 28904 */ 0240,0201,010,0301,01,024,0110,0,
+    /* 28912 */ 0241,0201,021,0301,01,0127,0120,0,
+    /* 28920 */ 0240,0201,021,0301,01,0127,0110,0,
+    /* 28928 */ 0241,0201,025,0301,01,0127,0120,0,
+    /* 28936 */ 0240,0201,025,0301,01,0127,0110,0,
+    /* 28944 */ 0241,0201,031,0301,01,0127,0120,0,
+    /* 28952 */ 0240,0201,031,0301,01,0127,0110,0,
+    /* 28960 */ 0241,0201,0,0301,01,0127,0120,0,
+    /* 28968 */ 0240,0201,0,0301,01,0127,0110,0,
+    /* 28976 */ 0241,0201,04,0301,01,0127,0120,0,
+    /* 28984 */ 0240,0201,04,0301,01,0127,0110,0,
+    /* 28992 */ 0241,0201,010,0301,01,0127,0120,0,
+    /* 29000 */ 0240,0201,010,0301,01,0127,0110,0,
+    /* 29008 */ 0310,0361,03,017,070,0370,0110,0,
+    /* 29016 */ 0311,0361,03,017,070,0370,0110,0,
+    /* 29024 */ 0323,0313,0333,02,017,0256,0206,0,
+    /* 29032 */ 0361,03,017,072,0317,0110,022,0,
+    /* 29040 */ 0261,03,021,01,0317,0120,023,0,
+    /* 29048 */ 0260,03,021,01,0317,0110,022,0,
+    /* 29056 */ 0261,03,025,01,0317,0120,023,0,
+    /* 29064 */ 0260,03,025,01,0317,0110,022,0,
+    /* 29072 */ 0361,03,017,072,0316,0110,022,0,
+    /* 29080 */ 0261,03,021,01,0316,0120,023,0,
+    /* 29088 */ 0260,03,021,01,0316,0110,022,0,
+    /* 29096 */ 0261,03,025,01,0316,0120,023,0,
+    /* 29104 */ 0260,03,025,01,0316,0110,022,0,
+    /* 29112 */ 0241,0202,01,0303,01,0317,0120,0,
+    /* 29120 */ 0240,0202,01,0303,01,0317,0110,0,
+    /* 29128 */ 0241,0202,05,0303,01,0317,0120,0,
+    /* 29136 */ 0240,0202,05,0303,01,0317,0110,0,
+    /* 29144 */ 0241,0202,011,0303,01,0317,0120,0,
+    /* 29152 */ 0240,0202,011,0303,01,0317,0110,0,
+    /* 29160 */ 0250,0202,01,0304,01,0143,0101,0,
+    /* 29168 */ 0250,0202,05,0304,01,0143,0101,0,
+    /* 29176 */ 0250,0202,011,0304,01,0143,0101,0,
+    /* 29184 */ 0250,0202,01,0300,01,0143,0101,0,
+    /* 29192 */ 0250,0202,05,0300,01,0143,0101,0,
+    /* 29200 */ 0250,0202,011,0300,01,0143,0101,0,
+    /* 29208 */ 0250,0202,021,0305,01,0143,0101,0,
+    /* 29216 */ 0250,0202,025,0305,01,0143,0101,0,
+    /* 29224 */ 0250,0202,031,0305,01,0143,0101,0,
+    /* 29232 */ 0250,0202,021,0300,01,0143,0101,0,
+    /* 29240 */ 0250,0202,025,0300,01,0143,0101,0,
+    /* 29248 */ 0250,0202,031,0300,01,0143,0101,0,
+    /* 29256 */ 0250,0202,01,0304,01,0142,0110,0,
+    /* 29264 */ 0250,0202,05,0304,01,0142,0110,0,
+    /* 29272 */ 0250,0202,011,0304,01,0142,0110,0,
+    /* 29280 */ 0250,0202,021,0305,01,0142,0110,0,
+    /* 29288 */ 0250,0202,025,0305,01,0142,0110,0,
+    /* 29296 */ 0250,0202,031,0305,01,0142,0110,0,
+    /* 29304 */ 0241,0202,021,0303,01,0160,0120,0,
+    /* 29312 */ 0240,0202,021,0303,01,0160,0110,0,
+    /* 29320 */ 0241,0202,025,0303,01,0160,0120,0,
+    /* 29328 */ 0240,0202,025,0303,01,0160,0110,0,
+    /* 29336 */ 0241,0202,031,0303,01,0160,0120,0,
+    /* 29344 */ 0240,0202,031,0303,01,0160,0110,0,
+    /* 29352 */ 0241,0202,01,0301,01,0161,0120,0,
+    /* 29360 */ 0240,0202,01,0301,01,0161,0110,0,
+    /* 29368 */ 0241,0202,05,0301,01,0161,0120,0,
+    /* 29376 */ 0240,0202,05,0301,01,0161,0110,0,
+    /* 29384 */ 0241,0202,011,0301,01,0161,0120,0,
+    /* 29392 */ 0240,0202,011,0301,01,0161,0110,0,
+    /* 29400 */ 0241,0202,021,0301,01,0161,0120,0,
+    /* 29408 */ 0240,0202,021,0301,01,0161,0110,0,
+    /* 29416 */ 0241,0202,025,0301,01,0161,0120,0,
+    /* 29424 */ 0240,0202,025,0301,01,0161,0110,0,
+    /* 29432 */ 0241,0202,031,0301,01,0161,0120,0,
+    /* 29440 */ 0240,0202,031,0301,01,0161,0110,0,
+    /* 29448 */ 0241,0202,021,0303,01,0162,0120,0,
+    /* 29456 */ 0240,0202,021,0303,01,0162,0110,0,
+    /* 29464 */ 0241,0202,025,0303,01,0162,0120,0,
+    /* 29472 */ 0240,0202,025,0303,01,0162,0110,0,
+    /* 29480 */ 0241,0202,031,0303,01,0162,0120,0,
+    /* 29488 */ 0240,0202,031,0303,01,0162,0110,0,
+    /* 29496 */ 0241,0202,01,0301,01,0163,0120,0,
+    /* 29504 */ 0240,0202,01,0301,01,0163,0110,0,
+    /* 29512 */ 0241,0202,05,0301,01,0163,0120,0,
+    /* 29520 */ 0240,0202,05,0301,01,0163,0110,0,
+    /* 29528 */ 0241,0202,011,0301,01,0163,0120,0,
+    /* 29536 */ 0240,0202,011,0301,01,0163,0110,0,
+    /* 29544 */ 0241,0202,021,0301,01,0163,0120,0,
+    /* 29552 */ 0240,0202,021,0301,01,0163,0110,0,
+    /* 29560 */ 0241,0202,025,0301,01,0163,0120,0,
+    /* 29568 */ 0240,0202,025,0301,01,0163,0110,0,
+    /* 29576 */ 0241,0202,031,0301,01,0163,0120,0,
+    /* 29584 */ 0240,0202,031,0301,01,0163,0110,0,
+    /* 29592 */ 0241,0202,01,0301,01,0120,0120,0,
+    /* 29600 */ 0240,0202,01,0301,01,0120,0110,0,
+    /* 29608 */ 0241,0202,05,0301,01,0120,0120,0,
+    /* 29616 */ 0240,0202,05,0301,01,0120,0110,0,
+    /* 29624 */ 0241,0202,011,0301,01,0120,0120,0,
+    /* 29632 */ 0240,0202,011,0301,01,0120,0110,0,
+    /* 29640 */ 0241,0202,01,0301,01,0121,0120,0,
+    /* 29648 */ 0240,0202,01,0301,01,0121,0110,0,
+    /* 29656 */ 0241,0202,05,0301,01,0121,0120,0,
+    /* 29664 */ 0240,0202,05,0301,01,0121,0110,0,
+    /* 29672 */ 0241,0202,011,0301,01,0121,0120,0,
+    /* 29680 */ 0240,0202,011,0301,01,0121,0110,0,
+    /* 29688 */ 0241,0202,01,0301,01,0122,0120,0,
+    /* 29696 */ 0240,0202,01,0301,01,0122,0110,0,
+    /* 29704 */ 0241,0202,05,0301,01,0122,0120,0,
+    /* 29712 */ 0240,0202,05,0301,01,0122,0110,0,
+    /* 29720 */ 0241,0202,011,0301,01,0122,0120,0,
+    /* 29728 */ 0240,0202,011,0301,01,0122,0110,0,
+    /* 29736 */ 0241,0202,01,0301,01,0123,0120,0,
+    /* 29744 */ 0240,0202,01,0301,01,0123,0110,0,
+    /* 29752 */ 0241,0202,05,0301,01,0123,0120,0,
+    /* 29760 */ 0240,0202,05,0301,01,0123,0110,0,
+    /* 29768 */ 0241,0202,011,0301,01,0123,0120,0,
+    /* 29776 */ 0240,0202,011,0301,01,0123,0110,0,
+    /* 29784 */ 0250,0202,01,0303,01,0124,0110,0,
+    /* 29792 */ 0250,0202,05,0303,01,0124,0110,0,
+    /* 29800 */ 0250,0202,011,0303,01,0124,0110,0,
+    /* 29808 */ 0250,0202,021,0303,01,0124,0110,0,
+    /* 29816 */ 0250,0202,025,0303,01,0124,0110,0,
+    /* 29824 */ 0250,0202,031,0303,01,0124,0110,0,
+    /* 29832 */ 0250,0202,01,0301,01,0125,0110,0,
+    /* 29840 */ 0250,0202,05,0301,01,0125,0110,0,
+    /* 29848 */ 0250,0202,011,0301,01,0125,0110,0,
+    /* 29856 */ 0250,0202,021,0301,01,0125,0110,0,
+    /* 29864 */ 0250,0202,025,0301,01,0125,0110,0,
+    /* 29872 */ 0250,0202,031,0301,01,0125,0110,0,
+    /* 29880 */ 0241,0202,01,0303,01,0217,0120,0,
+    /* 29888 */ 0241,0202,05,0303,01,0217,0120,0,
+    /* 29896 */ 0241,0202,011,0303,01,0217,0120,0,
+    /* 29904 */ 0241,0202,013,0317,01,0232,0120,0,
+    /* 29912 */ 0241,0202,013,0317,01,0252,0120,0,
+    /* 29920 */ 0241,0202,03,0317,01,0233,0120,0,
+    /* 29928 */ 0241,0202,03,0317,01,0253,0120,0,
+    /* 29936 */ 0241,0202,013,0317,01,0123,0120,0,
+    /* 29944 */ 0241,0202,013,0317,01,0122,0120,0,
+    /* 29952 */ 0321,0361,03,017,070,0365,0101,0,
+    /* 29960 */ 0324,0361,03,017,070,0365,0101,0,
+    /* 29968 */ 0310,0332,03,017,070,0370,0110,0,
+    /* 29976 */ 0311,0332,03,017,070,0370,0110,0,
+    /* 29984 */ 0313,0332,03,017,070,0370,0110,0,
+    /* 29992 */ 0310,0333,03,017,070,0370,0110,0,
+    /* 30000 */ 0311,0333,03,017,070,0370,0110,0,
+    /* 30008 */ 0313,0333,03,017,070,0370,0110,0,
+    /* 30016 */ 0241,0202,03,0301,01,0162,0120,0,
+    /* 30024 */ 0240,0202,03,0301,01,0162,0110,0,
+    /* 30032 */ 0241,0202,07,0301,01,0162,0120,0,
+    /* 30040 */ 0240,0202,07,0301,01,0162,0110,0,
+    /* 30048 */ 0241,0202,013,0301,01,0162,0120,0,
+    /* 30056 */ 0240,0202,013,0301,01,0162,0110,0,
+    /* 30064 */ 0241,0202,02,0301,01,0162,0120,0,
+    /* 30072 */ 0240,0202,02,0301,01,0162,0110,0,
+    /* 30080 */ 0241,0202,06,0301,01,0162,0120,0,
+    /* 30088 */ 0240,0202,06,0301,01,0162,0110,0,
+    /* 30096 */ 0241,0202,012,0301,01,0162,0120,0,
+    /* 30104 */ 0240,0202,012,0301,01,0162,0110,0,
+    /* 30112 */ 0241,0202,02,0301,01,0122,0120,0,
+    /* 30120 */ 0240,0202,02,0301,01,0122,0110,0,
+    /* 30128 */ 0241,0202,06,0301,01,0122,0120,0,
+    /* 30136 */ 0240,0202,06,0301,01,0122,0110,0,
+    /* 30144 */ 0241,0202,012,0301,01,0122,0120,0,
+    /* 30152 */ 0240,0202,012,0301,01,0122,0110,0,
+    /* 30160 */ 0241,0202,03,0301,01,0150,0120,0,
+    /* 30168 */ 0241,0202,07,0301,01,0150,0120,0,
+    /* 30176 */ 0241,0202,013,0301,01,0150,0120,0,
+    /* 30184 */ 0270,02,03,01,0111,0171,0300,0,
+    /* 30192 */ 0241,0205,0,0301,01,0130,0120,0,
+    /* 30200 */ 0240,0205,0,0301,01,0130,0110,0,
+    /* 30208 */ 0241,0205,04,0301,01,0130,0120,0,
+    /* 30216 */ 0240,0205,04,0301,01,0130,0110,0,
+    /* 30224 */ 0241,0205,010,0301,01,0130,0120,0,
+    /* 30232 */ 0240,0205,010,0301,01,0130,0110,0,
+    /* 30240 */ 0241,0205,02,0306,01,0130,0120,0,
+    /* 30248 */ 0240,0205,02,0306,01,0130,0110,0,
+    /* 30256 */ 0250,0205,0,0301,01,057,0110,0,
+    /* 30264 */ 0250,0205,0,0301,01,0133,0110,0,
+    /* 30272 */ 0250,0205,04,0301,01,0133,0110,0,
+    /* 30280 */ 0250,0205,010,0301,01,0133,0110,0,
+    /* 30288 */ 0250,0205,021,0301,01,0132,0110,0,
+    /* 30296 */ 0250,0205,025,0301,01,0132,0110,0,
+    /* 30304 */ 0250,0205,031,0301,01,0132,0110,0,
+    /* 30312 */ 0250,0205,01,0302,01,0133,0110,0,
+    /* 30320 */ 0250,0205,05,0302,01,0133,0110,0,
+    /* 30328 */ 0250,0205,011,0302,01,0133,0110,0,
+    /* 30336 */ 0250,0205,0,0315,01,0132,0110,0,
+    /* 30344 */ 0250,0205,04,0315,01,0132,0110,0,
+    /* 30352 */ 0250,0205,010,0315,01,0132,0110,0,
+    /* 30360 */ 0250,0206,01,0302,01,023,0110,0,
+    /* 30368 */ 0250,0206,05,0302,01,023,0110,0,
+    /* 30376 */ 0250,0206,011,0302,01,023,0110,0,
+    /* 30384 */ 0250,0205,01,0315,01,0173,0110,0,
+    /* 30392 */ 0250,0205,05,0315,01,0173,0110,0,
+    /* 30400 */ 0250,0205,011,0315,01,0173,0110,0,
+    /* 30408 */ 0250,0205,0,0302,01,0171,0110,0,
+    /* 30416 */ 0250,0205,04,0302,01,0171,0110,0,
+    /* 30424 */ 0250,0205,010,0302,01,0171,0110,0,
+    /* 30432 */ 0250,0205,01,0315,01,0171,0110,0,
+    /* 30440 */ 0250,0205,05,0315,01,0171,0110,0,
+    /* 30448 */ 0250,0205,011,0315,01,0171,0110,0,
+    /* 30456 */ 0250,0205,0,0301,01,0175,0110,0,
+    /* 30464 */ 0250,0205,04,0301,01,0175,0110,0,
+    /* 30472 */ 0250,0205,010,0301,01,0175,0110,0,
+    /* 30480 */ 0250,0205,01,0301,01,0175,0110,0,
+    /* 30488 */ 0250,0205,05,0301,01,0175,0110,0,
+    /* 30496 */ 0250,0205,011,0301,01,0175,0110,0,
+    /* 30504 */ 0250,0205,01,0301,01,035,0110,0,
+    /* 30512 */ 0250,0205,05,0301,01,035,0110,0,
+    /* 30520 */ 0250,0205,011,0301,01,035,0110,0,
+    /* 30528 */ 0250,0205,020,0301,01,0133,0110,0,
+    /* 30536 */ 0250,0205,024,0301,01,0133,0110,0,
+    /* 30544 */ 0250,0205,030,0301,01,0133,0110,0,
+    /* 30552 */ 0241,0205,023,0306,01,0132,0120,0,
+    /* 30560 */ 0240,0205,023,0306,01,0132,0110,0,
+    /* 30568 */ 0241,0205,02,0306,01,0132,0120,0,
+    /* 30576 */ 0240,0205,02,0306,01,0132,0110,0,
+    /* 30584 */ 0250,0205,02,0306,01,055,0110,0,
+    /* 30592 */ 0250,0205,022,0306,01,055,0110,0,
+    /* 30600 */ 0241,0206,0,0306,01,023,0120,0,
+    /* 30608 */ 0240,0206,0,0306,01,023,0110,0,
+    /* 30616 */ 0250,0205,02,0306,01,0171,0110,0,
+    /* 30624 */ 0250,0205,022,0306,01,0171,0110,0,
+    /* 30632 */ 0241,0205,02,0306,01,052,0120,0,
+    /* 30640 */ 0240,0205,02,0306,01,052,0110,0,
+    /* 30648 */ 0241,0205,022,0306,01,052,0120,0,
+    /* 30656 */ 0240,0205,022,0306,01,052,0110,0,
+    /* 30664 */ 0241,0205,040,0306,01,035,0120,0,
+    /* 30672 */ 0240,0205,040,0306,01,035,0110,0,
+    /* 30680 */ 0250,0205,02,0302,01,0133,0110,0,
+    /* 30688 */ 0250,0205,06,0302,01,0133,0110,0,
+    /* 30696 */ 0250,0205,012,0302,01,0133,0110,0,
+    /* 30704 */ 0250,0205,01,0306,01,0172,0110,0,
+    /* 30712 */ 0250,0205,05,0306,01,0172,0110,0,
+    /* 30720 */ 0250,0205,011,0306,01,0172,0110,0,
+    /* 30728 */ 0250,0205,0,0302,01,0170,0110,0,
+    /* 30736 */ 0250,0205,04,0302,01,0170,0110,0,
+    /* 30744 */ 0250,0205,010,0302,01,0170,0110,0,
+    /* 30752 */ 0250,0205,01,0306,01,0170,0110,0,
+    /* 30760 */ 0250,0205,05,0306,01,0170,0110,0,
+    /* 30768 */ 0250,0205,011,0306,01,0170,0110,0,
+    /* 30776 */ 0250,0205,0,0301,01,0174,0110,0,
+    /* 30784 */ 0250,0205,04,0301,01,0174,0110,0,
+    /* 30792 */ 0250,0205,010,0301,01,0174,0110,0,
+    /* 30800 */ 0250,0205,01,0301,01,0174,0110,0,
+    /* 30808 */ 0250,0205,05,0301,01,0174,0110,0,
+    /* 30816 */ 0250,0205,011,0301,01,0174,0110,0,
+    /* 30824 */ 0250,0205,02,0306,01,054,0110,0,
+    /* 30832 */ 0250,0205,022,0306,01,054,0110,0,
+    /* 30840 */ 0250,0205,02,0306,01,0170,0110,0,
+    /* 30848 */ 0250,0205,022,0306,01,0170,0110,0,
+    /* 30856 */ 0250,0205,03,0301,01,0172,0110,0,
+    /* 30864 */ 0250,0205,07,0301,01,0172,0110,0,
+    /* 30872 */ 0250,0205,013,0301,01,0172,0110,0,
+    /* 30880 */ 0250,0205,023,0301,01,0172,0110,0,
+    /* 30888 */ 0250,0205,027,0301,01,0172,0110,0,
+    /* 30896 */ 0250,0205,033,0301,01,0172,0110,0,
+    /* 30904 */ 0241,0205,02,0306,01,0173,0120,0,
+    /* 30912 */ 0241,0205,022,0306,01,0173,0120,0,
+    /* 30920 */ 0250,0205,03,0301,01,0175,0110,0,
+    /* 30928 */ 0250,0205,07,0301,01,0175,0110,0,
+    /* 30936 */ 0250,0205,013,0301,01,0175,0110,0,
+    /* 30944 */ 0250,0205,02,0301,01,0175,0110,0,
+    /* 30952 */ 0250,0205,06,0301,01,0175,0110,0,
+    /* 30960 */ 0250,0205,012,0301,01,0175,0110,0,
+    /* 30968 */ 0241,0205,040,0301,01,0136,0120,0,
+    /* 30976 */ 0240,0205,040,0301,01,0136,0110,0,
+    /* 30984 */ 0241,0205,044,0301,01,0136,0120,0,
+    /* 30992 */ 0240,0205,044,0301,01,0136,0110,0,
+    /* 31000 */ 0241,0205,050,0301,01,0136,0120,0,
+    /* 31008 */ 0240,0205,050,0301,01,0136,0110,0,
+    /* 31016 */ 0241,0205,042,0306,01,0136,0120,0,
+    /* 31024 */ 0240,0205,042,0306,01,0136,0110,0,
+    /* 31032 */ 0241,0206,03,0301,01,0126,0120,0,
+    /* 31040 */ 0240,0206,03,0301,01,0126,0110,0,
+    /* 31048 */ 0241,0206,07,0301,01,0126,0120,0,
+    /* 31056 */ 0240,0206,07,0301,01,0126,0110,0,
+    /* 31064 */ 0241,0206,013,0301,01,0126,0120,0,
+    /* 31072 */ 0240,0206,013,0301,01,0126,0110,0,
+    /* 31080 */ 0241,0206,02,0301,01,0126,0120,0,
+    /* 31088 */ 0240,0206,02,0301,01,0126,0110,0,
+    /* 31096 */ 0241,0206,06,0301,01,0126,0120,0,
+    /* 31104 */ 0240,0206,06,0301,01,0126,0110,0,
+    /* 31112 */ 0241,0206,012,0301,01,0126,0120,0,
+    /* 31120 */ 0240,0206,012,0301,01,0126,0110,0,
+    /* 31128 */ 0241,0206,03,0306,01,0127,0120,0,
+    /* 31136 */ 0240,0206,03,0306,01,0127,0110,0,
+    /* 31144 */ 0241,0206,02,0306,01,0127,0120,0,
+    /* 31152 */ 0240,0206,02,0306,01,0127,0110,0,
+    /* 31160 */ 0241,0206,03,0301,01,0326,0120,0,
+    /* 31168 */ 0240,0206,03,0301,01,0326,0110,0,
+    /* 31176 */ 0241,0206,07,0301,01,0326,0120,0,
+    /* 31184 */ 0240,0206,07,0301,01,0326,0110,0,
+    /* 31192 */ 0241,0206,013,0301,01,0326,0120,0,
+    /* 31200 */ 0240,0206,013,0301,01,0326,0110,0,
+    /* 31208 */ 0241,0206,02,0301,01,0326,0120,0,
+    /* 31216 */ 0240,0206,02,0301,01,0326,0110,0,
+    /* 31224 */ 0241,0206,06,0301,01,0326,0120,0,
+    /* 31232 */ 0240,0206,06,0301,01,0326,0110,0,
+    /* 31240 */ 0241,0206,012,0301,01,0326,0120,0,
+    /* 31248 */ 0240,0206,012,0301,01,0326,0110,0,
+    /* 31256 */ 0241,0206,03,0306,01,0327,0120,0,
+    /* 31264 */ 0240,0206,03,0306,01,0327,0110,0,
+    /* 31272 */ 0241,0206,02,0306,01,0327,0120,0,
+    /* 31280 */ 0240,0206,02,0306,01,0327,0110,0,
+    /* 31288 */ 0241,0206,01,0301,01,0226,0120,0,
+    /* 31296 */ 0240,0206,01,0301,01,0226,0110,0,
+    /* 31304 */ 0241,0206,05,0301,01,0226,0120,0,
+    /* 31312 */ 0240,0206,05,0301,01,0226,0110,0,
+    /* 31320 */ 0241,0206,011,0301,01,0226,0120,0,
+    /* 31328 */ 0240,0206,011,0301,01,0226,0110,0,
+    /* 31336 */ 0241,0206,01,0301,01,0246,0120,0,
+    /* 31344 */ 0240,0206,01,0301,01,0246,0110,0,
+    /* 31352 */ 0241,0206,05,0301,01,0246,0120,0,
+    /* 31360 */ 0240,0206,05,0301,01,0246,0110,0,
+    /* 31368 */ 0241,0206,011,0301,01,0246,0120,0,
+    /* 31376 */ 0240,0206,011,0301,01,0246,0110,0,
+    /* 31384 */ 0241,0206,01,0301,01,0266,0120,0,
+    /* 31392 */ 0240,0206,01,0301,01,0266,0110,0,
+    /* 31400 */ 0241,0206,05,0301,01,0266,0120,0,
+    /* 31408 */ 0240,0206,05,0301,01,0266,0110,0,
+    /* 31416 */ 0241,0206,011,0301,01,0266,0120,0,
+    /* 31424 */ 0240,0206,011,0301,01,0266,0110,0,
+    /* 31432 */ 0241,0206,01,0301,01,0227,0120,0,
+    /* 31440 */ 0240,0206,01,0301,01,0227,0110,0,
+    /* 31448 */ 0241,0206,05,0301,01,0227,0120,0,
+    /* 31456 */ 0240,0206,05,0301,01,0227,0110,0,
+    /* 31464 */ 0241,0206,011,0301,01,0227,0120,0,
+    /* 31472 */ 0240,0206,011,0301,01,0227,0110,0,
+    /* 31480 */ 0241,0206,01,0301,01,0247,0120,0,
+    /* 31488 */ 0240,0206,01,0301,01,0247,0110,0,
+    /* 31496 */ 0241,0206,05,0301,01,0247,0120,0,
+    /* 31504 */ 0240,0206,05,0301,01,0247,0110,0,
+    /* 31512 */ 0241,0206,011,0301,01,0247,0120,0,
+    /* 31520 */ 0240,0206,011,0301,01,0247,0110,0,
+    /* 31528 */ 0241,0206,01,0301,01,0267,0120,0,
+    /* 31536 */ 0240,0206,01,0301,01,0267,0110,0,
+    /* 31544 */ 0241,0206,05,0301,01,0267,0120,0,
+    /* 31552 */ 0240,0206,05,0301,01,0267,0110,0,
+    /* 31560 */ 0241,0206,011,0301,01,0267,0120,0,
+    /* 31568 */ 0240,0206,011,0301,01,0267,0110,0,
+    /* 31576 */ 0241,0206,01,0301,01,0230,0120,0,
+    /* 31584 */ 0240,0206,01,0301,01,0230,0110,0,
+    /* 31592 */ 0241,0206,05,0301,01,0230,0120,0,
+    /* 31600 */ 0240,0206,05,0301,01,0230,0110,0,
+    /* 31608 */ 0241,0206,011,0301,01,0230,0120,0,
+    /* 31616 */ 0240,0206,011,0301,01,0230,0110,0,
+    /* 31624 */ 0241,0206,01,0301,01,0250,0120,0,
+    /* 31632 */ 0240,0206,01,0301,01,0250,0110,0,
+    /* 31640 */ 0241,0206,05,0301,01,0250,0120,0,
+    /* 31648 */ 0240,0206,05,0301,01,0250,0110,0,
+    /* 31656 */ 0241,0206,011,0301,01,0250,0120,0,
+    /* 31664 */ 0240,0206,011,0301,01,0250,0110,0,
+    /* 31672 */ 0241,0206,01,0301,01,0270,0120,0,
+    /* 31680 */ 0240,0206,01,0301,01,0270,0110,0,
+    /* 31688 */ 0241,0206,05,0301,01,0270,0120,0,
+    /* 31696 */ 0240,0206,05,0301,01,0270,0110,0,
+    /* 31704 */ 0241,0206,011,0301,01,0270,0120,0,
+    /* 31712 */ 0240,0206,011,0301,01,0270,0110,0,
+    /* 31720 */ 0241,0206,01,0301,01,0234,0120,0,
+    /* 31728 */ 0240,0206,01,0301,01,0234,0110,0,
+    /* 31736 */ 0241,0206,05,0301,01,0234,0120,0,
+    /* 31744 */ 0240,0206,05,0301,01,0234,0110,0,
+    /* 31752 */ 0241,0206,011,0301,01,0234,0120,0,
+    /* 31760 */ 0240,0206,011,0301,01,0234,0110,0,
+    /* 31768 */ 0241,0206,01,0301,01,0254,0120,0,
+    /* 31776 */ 0240,0206,01,0301,01,0254,0110,0,
+    /* 31784 */ 0241,0206,05,0301,01,0254,0120,0,
+    /* 31792 */ 0240,0206,05,0301,01,0254,0110,0,
+    /* 31800 */ 0241,0206,011,0301,01,0254,0120,0,
+    /* 31808 */ 0240,0206,011,0301,01,0254,0110,0,
+    /* 31816 */ 0241,0206,01,0301,01,0274,0120,0,
+    /* 31824 */ 0240,0206,01,0301,01,0274,0110,0,
+    /* 31832 */ 0241,0206,05,0301,01,0274,0120,0,
+    /* 31840 */ 0240,0206,05,0301,01,0274,0110,0,
+    /* 31848 */ 0241,0206,011,0301,01,0274,0120,0,
+    /* 31856 */ 0240,0206,011,0301,01,0274,0110,0,
+    /* 31864 */ 0241,0206,01,0306,01,0231,0120,0,
+    /* 31872 */ 0240,0206,01,0306,01,0231,0110,0,
+    /* 31880 */ 0241,0206,01,0306,01,0251,0120,0,
+    /* 31888 */ 0240,0206,01,0306,01,0251,0110,0,
+    /* 31896 */ 0241,0206,01,0306,01,0271,0120,0,
+    /* 31904 */ 0240,0206,01,0306,01,0271,0110,0,
+    /* 31912 */ 0241,0206,01,0306,01,0235,0120,0,
+    /* 31920 */ 0240,0206,01,0306,01,0235,0110,0,
+    /* 31928 */ 0241,0206,01,0306,01,0255,0120,0,
+    /* 31936 */ 0240,0206,01,0306,01,0255,0110,0,
+    /* 31944 */ 0241,0206,01,0306,01,0275,0120,0,
+    /* 31952 */ 0240,0206,01,0306,01,0275,0110,0,
+    /* 31960 */ 0241,0206,01,0301,01,0232,0120,0,
+    /* 31968 */ 0240,0206,01,0301,01,0232,0110,0,
+    /* 31976 */ 0241,0206,05,0301,01,0232,0120,0,
+    /* 31984 */ 0240,0206,05,0301,01,0232,0110,0,
+    /* 31992 */ 0241,0206,011,0301,01,0232,0120,0,
+    /* 32000 */ 0240,0206,011,0301,01,0232,0110,0,
+    /* 32008 */ 0241,0206,01,0301,01,0252,0120,0,
+    /* 32016 */ 0240,0206,01,0301,01,0252,0110,0,
+    /* 32024 */ 0241,0206,05,0301,01,0252,0120,0,
+    /* 32032 */ 0240,0206,05,0301,01,0252,0110,0,
+    /* 32040 */ 0241,0206,011,0301,01,0252,0120,0,
+    /* 32048 */ 0240,0206,011,0301,01,0252,0110,0,
+    /* 32056 */ 0241,0206,01,0301,01,0272,0120,0,
+    /* 32064 */ 0240,0206,01,0301,01,0272,0110,0,
+    /* 32072 */ 0241,0206,05,0301,01,0272,0120,0,
+    /* 32080 */ 0240,0206,05,0301,01,0272,0110,0,
+    /* 32088 */ 0241,0206,011,0301,01,0272,0120,0,
+    /* 32096 */ 0240,0206,011,0301,01,0272,0110,0,
+    /* 32104 */ 0241,0206,01,0301,01,0236,0120,0,
+    /* 32112 */ 0240,0206,01,0301,01,0236,0110,0,
+    /* 32120 */ 0241,0206,05,0301,01,0236,0120,0,
+    /* 32128 */ 0240,0206,05,0301,01,0236,0110,0,
+    /* 32136 */ 0241,0206,011,0301,01,0236,0120,0,
+    /* 32144 */ 0240,0206,011,0301,01,0236,0110,0,
+    /* 32152 */ 0241,0206,01,0301,01,0256,0120,0,
+    /* 32160 */ 0240,0206,01,0301,01,0256,0110,0,
+    /* 32168 */ 0241,0206,05,0301,01,0256,0120,0,
+    /* 32176 */ 0240,0206,05,0301,01,0256,0110,0,
+    /* 32184 */ 0241,0206,011,0301,01,0256,0120,0,
+    /* 32192 */ 0240,0206,011,0301,01,0256,0110,0,
+    /* 32200 */ 0241,0206,01,0301,01,0276,0120,0,
+    /* 32208 */ 0240,0206,01,0301,01,0276,0110,0,
+    /* 32216 */ 0241,0206,05,0301,01,0276,0120,0,
+    /* 32224 */ 0240,0206,05,0301,01,0276,0110,0,
+    /* 32232 */ 0241,0206,011,0301,01,0276,0120,0,
+    /* 32240 */ 0240,0206,011,0301,01,0276,0110,0,
+    /* 32248 */ 0241,0206,01,0306,01,0233,0120,0,
+    /* 32256 */ 0240,0206,01,0306,01,0233,0110,0,
+    /* 32264 */ 0241,0206,01,0306,01,0253,0120,0,
+    /* 32272 */ 0240,0206,01,0306,01,0253,0110,0,
+    /* 32280 */ 0241,0206,01,0306,01,0273,0120,0,
+    /* 32288 */ 0240,0206,01,0306,01,0273,0110,0,
+    /* 32296 */ 0241,0206,01,0306,01,0237,0120,0,
+    /* 32304 */ 0240,0206,01,0306,01,0237,0110,0,
+    /* 32312 */ 0241,0206,01,0306,01,0257,0120,0,
+    /* 32320 */ 0240,0206,01,0306,01,0257,0110,0,
+    /* 32328 */ 0241,0206,01,0306,01,0277,0120,0,
+    /* 32336 */ 0240,0206,01,0306,01,0277,0110,0,
+    /* 32344 */ 0250,0206,01,0301,01,0102,0110,0,
+    /* 32352 */ 0250,0206,05,0301,01,0102,0110,0,
+    /* 32360 */ 0250,0206,011,0301,01,0102,0110,0,
+    /* 32368 */ 0250,0206,01,0306,01,0103,0110,0,
+    /* 32376 */ 0250,0205,0,0301,01,0137,0110,0,
+    /* 32384 */ 0250,0205,04,0301,01,0137,0110,0,
+    /* 32392 */ 0250,0205,010,0301,01,0137,0110,0,
+    /* 32400 */ 0250,0205,02,0306,01,0137,0110,0,
+    /* 32408 */ 0250,0205,0,0301,01,0135,0110,0,
+    /* 32416 */ 0250,0205,04,0301,01,0135,0110,0,
+    /* 32424 */ 0250,0205,010,0301,01,0135,0110,0,
+    /* 32432 */ 0250,0205,02,0306,01,0135,0110,0,
+    /* 32440 */ 0250,0205,02,0306,01,020,0110,0,
+    /* 32448 */ 0250,0205,02,0306,01,021,0101,0,
+    /* 32456 */ 0241,0205,02,0300,01,020,0120,0,
+    /* 32464 */ 0240,0205,02,0300,01,020,0110,0,
+    /* 32472 */ 0241,0205,02,0300,01,021,0120,0,
+    /* 32480 */ 0240,0205,02,0300,01,021,0110,0,
+    /* 32488 */ 0250,0205,041,0306,01,0156,0110,0,
+    /* 32496 */ 0250,0205,041,0306,01,0176,0101,0,
+    /* 32504 */ 0241,0205,0,0301,01,0131,0120,0,
+    /* 32512 */ 0240,0205,0,0301,01,0131,0110,0,
+    /* 32520 */ 0241,0205,04,0301,01,0131,0120,0,
+    /* 32528 */ 0240,0205,04,0301,01,0131,0110,0,
+    /* 32536 */ 0241,0205,010,0301,01,0131,0120,0,
+    /* 32544 */ 0240,0205,010,0301,01,0131,0110,0,
+    /* 32552 */ 0241,0205,02,0306,01,0131,0120,0,
+    /* 32560 */ 0240,0205,02,0306,01,0131,0110,0,
+    /* 32568 */ 0241,0206,01,0301,01,0114,0120,0,
+    /* 32576 */ 0240,0206,01,0301,01,0114,0110,0,
+    /* 32584 */ 0241,0206,05,0301,01,0114,0120,0,
+    /* 32592 */ 0240,0206,05,0301,01,0114,0110,0,
+    /* 32600 */ 0241,0206,011,0301,01,0114,0120,0,
+    /* 32608 */ 0240,0206,011,0301,01,0114,0110,0,
+    /* 32616 */ 0241,0206,01,0306,01,0115,0120,0,
+    /* 32624 */ 0240,0206,01,0306,01,0115,0110,0,
+    /* 32632 */ 0241,0206,01,0301,01,054,0120,0,
+    /* 32640 */ 0240,0206,01,0301,01,054,0110,0,
+    /* 32648 */ 0241,0206,05,0301,01,054,0120,0,
+    /* 32656 */ 0240,0206,05,0301,01,054,0110,0,
+    /* 32664 */ 0241,0206,011,0301,01,054,0120,0,
+    /* 32672 */ 0240,0206,011,0301,01,054,0110,0,
+    /* 32680 */ 0241,0206,01,0306,01,055,0120,0,
+    /* 32688 */ 0240,0206,01,0306,01,055,0110,0,
+    /* 32696 */ 0250,0205,0,0301,01,0121,0110,0,
+    /* 32704 */ 0250,0205,04,0301,01,0121,0110,0,
+    /* 32712 */ 0250,0205,010,0301,01,0121,0110,0,
+    /* 32720 */ 0241,0205,02,0306,01,0121,0120,0,
+    /* 32728 */ 0240,0205,02,0306,01,0121,0110,0,
+    /* 32736 */ 0241,0205,0,0301,01,0134,0120,0,
+    /* 32744 */ 0240,0205,0,0301,01,0134,0110,0,
+    /* 32752 */ 0241,0205,04,0301,01,0134,0120,0,
+    /* 32760 */ 0240,0205,04,0301,01,0134,0110,0,
+    /* 32768 */ 0241,0205,010,0301,01,0134,0120,0,
+    /* 32776 */ 0240,0205,010,0301,01,0134,0110,0,
+    /* 32784 */ 0241,0205,02,0306,01,0134,0120,0,
+    /* 32792 */ 0240,0205,02,0306,01,0134,0110,0,
+    /* 32800 */ 0250,0205,0,0306,01,056,0110,0,
+    /* 32808 */ 0317,0360,03,017,070,0374,0101,0,
+    /* 32816 */ 0324,0360,03,017,070,0374,0101,0,
+    /* 32824 */ 0317,0361,03,017,070,0374,0101,0,
+    /* 32832 */ 0324,0361,03,017,070,0374,0101,0,
+    /* 32840 */ 0317,0333,03,017,070,0374,0101,0,
+    /* 32848 */ 0324,0333,03,017,070,0374,0101,0,
+    /* 32856 */ 0333,04,017,072,0360,0300,020,0,
+    /* 32864 */ 0273,0320,01,0203,0202,0275,0,
+    /* 32871 */ 0273,0321,01,0203,0202,0275,0,
+    /* 32878 */ 0273,0324,01,0203,0202,0275,0,
+    /* 32885 */ 0273,0320,01,0201,0202,031,0,
+    /* 32892 */ 0273,0321,01,0201,0202,041,0,
+    /* 32899 */ 0273,0324,01,0201,0202,0255,0,
+    /* 32906 */ 0273,0320,01,0203,0200,0275,0,
+    /* 32913 */ 0273,0321,01,0203,0200,0275,0,
+    /* 32920 */ 0273,0324,01,0203,0200,0275,0,
+    /* 32927 */ 0273,0320,01,0201,0200,031,0,
+    /* 32934 */ 0273,0321,01,0201,0200,041,0,
+    /* 32941 */ 0273,0324,01,0201,0200,0255,0,
+    /* 32948 */ 0273,0320,01,0203,0204,0275,0,
+    /* 32955 */ 0273,0321,01,0203,0204,0275,0,
+    /* 32962 */ 0273,0324,01,0203,0204,0275,0,
+    /* 32969 */ 0273,0320,01,0201,0204,031,0,
+    /* 32976 */ 0273,0321,01,0201,0204,041,0,
+    /* 32983 */ 0273,0324,01,0201,0204,0255,0,
+    /* 32990 */ 0320,0326,02,017,0274,0110,0,
+    /* 32997 */ 0321,0326,02,017,0274,0110,0,
+    /* 33004 */ 0324,0326,02,017,0274,0110,0,
+    /* 33011 */ 0320,0326,02,017,0275,0110,0,
+    /* 33018 */ 0321,0326,02,017,0275,0110,0,
+    /* 33025 */ 0324,0326,02,017,0275,0110,0,
+    /* 33032 */ 0320,02,017,0272,0204,025,0,
+    /* 33039 */ 0321,02,017,0272,0204,025,0,
+    /* 33046 */ 0324,02,017,0272,0204,025,0,
+    /* 33053 */ 0273,0320,02,017,0273,0101,0,
+    /* 33060 */ 0273,0321,02,017,0273,0101,0,
+    /* 33067 */ 0273,0324,02,017,0273,0101,0,
+    /* 33074 */ 0273,0320,02,017,0263,0101,0,
+    /* 33081 */ 0273,0321,02,017,0263,0101,0,
+    /* 33088 */ 0273,0324,02,017,0263,0101,0,
+    /* 33095 */ 0273,0320,02,017,0253,0101,0,
+    /* 33102 */ 0273,0321,02,017,0253,0101,0,
+    /* 33109 */ 0273,0324,02,017,0253,0101,0,
+    /* 33116 */ 0273,0320,02,017,0261,0101,0,
+    /* 33123 */ 0273,0321,02,017,0261,0101,0,
+    /* 33130 */ 0273,0324,02,017,0261,0101,0,
+    /* 33137 */ 0273,0317,02,017,0307,0201,0,
+    /* 33144 */ 0361,03,017,070,0202,0110,0,
+    /* 33151 */ 0323,0313,03,017,01,0337,0,
+    /* 33158 */ 0320,0323,02,017,02,0110,0,
+    /* 33165 */ 0321,0323,02,017,02,0110,0,
+    /* 33172 */ 0320,0323,02,017,03,0110,0,
+    /* 33179 */ 0321,0323,02,017,03,0110,0,
+    /* 33186 */ 0271,0320,01,0307,0200,031,0,
+    /* 33193 */ 0271,0321,01,0307,0200,041,0,
+    /* 33200 */ 0271,0324,01,0307,0200,0255,0,
+    /* 33207 */ 0360,0324,02,017,0156,0110,0,
+    /* 33214 */ 0360,0324,02,017,0176,0101,0,
+    /* 33221 */ 0273,0320,01,0203,0201,0275,0,
+    /* 33228 */ 0273,0321,01,0203,0201,0275,0,
+    /* 33235 */ 0273,0324,01,0203,0201,0275,0,
+    /* 33242 */ 0273,0320,01,0201,0201,031,0,
+    /* 33249 */ 0273,0321,01,0201,0201,041,0,
+    /* 33256 */ 0273,0324,01,0201,0201,0255,0,
+    /* 33263 */ 0360,0323,02,017,0153,0110,0,
+    /* 33270 */ 0360,0323,02,017,0143,0110,0,
+    /* 33277 */ 0360,0323,02,017,0147,0110,0,
+    /* 33284 */ 0360,0323,02,017,0374,0110,0,
+    /* 33291 */ 0360,0323,02,017,0376,0110,0,
+    /* 33298 */ 0360,0323,02,017,0354,0110,0,
+    /* 33305 */ 0360,0323,02,017,0355,0110,0,
+    /* 33312 */ 0360,0323,02,017,0334,0110,0,
+    /* 33319 */ 0360,0323,02,017,0335,0110,0,
+    /* 33326 */ 0360,0323,02,017,0375,0110,0,
+    /* 33333 */ 0360,0323,02,017,0333,0110,0,
+    /* 33340 */ 0360,0323,02,017,0337,0110,0,
+    /* 33347 */ 0360,0323,02,017,0164,0110,0,
+    /* 33354 */ 0360,0323,02,017,0166,0110,0,
+    /* 33361 */ 0360,0323,02,017,0165,0110,0,
+    /* 33368 */ 0360,0323,02,017,0144,0110,0,
+    /* 33375 */ 0360,0323,02,017,0146,0110,0,
+    /* 33382 */ 0360,0323,02,017,0145,0110,0,
+    /* 33389 */ 0360,0323,02,017,0365,0110,0,
+    /* 33396 */ 0360,0323,02,017,0345,0110,0,
+    /* 33403 */ 0360,0323,02,017,0325,0110,0,
+    /* 33410 */ 0360,0323,02,017,0353,0110,0,
+    /* 33417 */ 0360,0323,02,017,0362,0110,0,
+    /* 33424 */ 0360,02,017,0162,0206,025,0,
+    /* 33431 */ 0360,0323,02,017,0363,0110,0,
+    /* 33438 */ 0360,02,017,0163,0206,025,0,
+    /* 33445 */ 0360,0323,02,017,0361,0110,0,
+    /* 33452 */ 0360,02,017,0161,0206,025,0,
+    /* 33459 */ 0360,0323,02,017,0342,0110,0,
+    /* 33466 */ 0360,02,017,0162,0204,025,0,
+    /* 33473 */ 0360,0323,02,017,0341,0110,0,
+    /* 33480 */ 0360,02,017,0161,0204,025,0,
+    /* 33487 */ 0360,0323,02,017,0322,0110,0,
+    /* 33494 */ 0360,02,017,0162,0202,025,0,
+    /* 33501 */ 0360,0323,02,017,0323,0110,0,
+    /* 33508 */ 0360,02,017,0163,0202,025,0,
+    /* 33515 */ 0360,0323,02,017,0321,0110,0,
+    /* 33522 */ 0360,02,017,0161,0202,025,0,
+    /* 33529 */ 0360,0323,02,017,0370,0110,0,
+    /* 33536 */ 0360,0323,02,017,0372,0110,0,
+    /* 33543 */ 0360,0323,02,017,0350,0110,0,
+    /* 33550 */ 0360,0323,02,017,0351,0110,0,
+    /* 33557 */ 0360,0323,02,017,0330,0110,0,
+    /* 33564 */ 0360,0323,02,017,0331,0110,0,
+    /* 33571 */ 0360,0323,02,017,0371,0110,0,
+    /* 33578 */ 0360,0323,02,017,0150,0110,0,
+    /* 33585 */ 0360,0323,02,017,0152,0110,0,
+    /* 33592 */ 0360,0323,02,017,0151,0110,0,
+    /* 33599 */ 0360,0323,02,017,0140,0110,0,
+    /* 33606 */ 0360,0323,02,017,0142,0110,0,
+    /* 33613 */ 0360,0323,02,017,0141,0110,0,
+    /* 33620 */ 0360,0323,02,017,0357,0110,0,
+    /* 33627 */ 0273,0320,01,0203,0203,0275,0,
+    /* 33634 */ 0273,0321,01,0203,0203,0275,0,
+    /* 33641 */ 0273,0324,01,0203,0203,0275,0,
+    /* 33648 */ 0273,0320,01,0201,0203,031,0,
+    /* 33655 */ 0273,0321,01,0201,0203,041,0,
+    /* 33662 */ 0273,0324,01,0201,0203,0255,0,
+    /* 33669 */ 0320,02,017,0244,0101,026,0,
+    /* 33676 */ 0321,02,017,0244,0101,026,0,
+    /* 33683 */ 0324,02,017,0244,0101,026,0,
+    /* 33690 */ 0320,02,017,0254,0101,026,0,
+    /* 33697 */ 0321,02,017,0254,0101,026,0,
+    /* 33704 */ 0324,02,017,0254,0101,026,0,
+    /* 33711 */ 0273,0320,01,0203,0205,0275,0,
+    /* 33718 */ 0273,0321,01,0203,0205,0275,0,
+    /* 33725 */ 0273,0324,01,0203,0205,0275,0,
+    /* 33732 */ 0273,0320,01,0201,0205,031,0,
+    /* 33739 */ 0273,0321,01,0201,0205,041,0,
+    /* 33746 */ 0273,0324,01,0201,0205,0255,0,
+    /* 33753 */ 0360,0320,02,017,021,0101,0,
+    /* 33760 */ 0360,0321,02,017,021,0101,0,
+    /* 33767 */ 0360,0320,02,017,023,0110,0,
+    /* 33774 */ 0360,0321,02,017,023,0110,0,
+    /* 33781 */ 0273,0320,02,017,0301,0101,0,
+    /* 33788 */ 0273,0321,02,017,0301,0101,0,
+    /* 33795 */ 0273,0324,02,017,0301,0101,0,
+    /* 33802 */ 0273,0320,01,0203,0206,0275,0,
+    /* 33809 */ 0273,0321,01,0203,0206,0275,0,
+    /* 33816 */ 0273,0324,01,0203,0206,0275,0,
+    /* 33823 */ 0273,0320,01,0201,0206,031,0,
+    /* 33830 */ 0273,0321,01,0201,0206,041,0,
+    /* 33837 */ 0273,0324,01,0201,0206,0255,0,
+    /* 33844 */ 01,0166,0373,01,0351,064,0,
+    /* 33851 */ 01,0162,0373,01,0351,064,0,
+    /* 33858 */ 01,0163,0373,01,0351,064,0,
+    /* 33865 */ 01,0167,0373,01,0351,064,0,
+    /* 33872 */ 01,0165,0373,01,0351,064,0,
+    /* 33879 */ 01,0176,0373,01,0351,064,0,
+    /* 33886 */ 01,0174,0373,01,0351,064,0,
+    /* 33893 */ 01,0175,0373,01,0351,064,0,
+    /* 33900 */ 01,0177,0373,01,0351,064,0,
+    /* 33907 */ 01,0164,0373,01,0351,064,0,
+    /* 33914 */ 01,0160,0373,01,0351,064,0,
+    /* 33921 */ 01,0172,0373,01,0351,064,0,
+    /* 33928 */ 01,0170,0373,01,0351,064,0,
+    /* 33935 */ 01,0161,0373,01,0351,064,0,
+    /* 33942 */ 01,0173,0373,01,0351,064,0,
+    /* 33949 */ 01,0171,0373,01,0351,064,0,
+    /* 33956 */ 0360,02,017,0302,0110,026,0,
+    /* 33963 */ 0333,02,017,0302,0110,026,0,
+    /* 33970 */ 0324,0333,02,017,052,0110,0,
+    /* 33977 */ 0324,0333,02,017,055,0110,0,
+    /* 33984 */ 0324,0333,02,017,054,0110,0,
+    /* 33991 */ 0360,0324,02,017,0120,0110,0,
+    /* 33998 */ 0360,02,017,0306,0110,026,0,
+    /* 34005 */ 0324,0360,02,017,0256,0201,0,
+    /* 34012 */ 0324,0360,02,017,0256,0200,0,
+    /* 34019 */ 0324,0360,02,017,0256,0204,0,
+    /* 34026 */ 0324,0360,02,017,0307,0204,0,
+    /* 34033 */ 0324,0360,02,017,0256,0206,0,
+    /* 34040 */ 0324,0360,02,017,0307,0205,0,
+    /* 34047 */ 0324,0360,02,017,0256,0205,0,
+    /* 34054 */ 0324,0360,02,017,0307,0203,0,
+    /* 34061 */ 0360,0323,02,017,0340,0110,0,
+    /* 34068 */ 0360,0323,02,017,0343,0110,0,
+    /* 34075 */ 0360,02,017,0305,0110,026,0,
+    /* 34082 */ 0360,02,017,0304,0110,026,0,
+    /* 34089 */ 0360,0323,02,017,0356,0110,0,
+    /* 34096 */ 0360,0323,02,017,0336,0110,0,
+    /* 34103 */ 0360,0323,02,017,0352,0110,0,
+    /* 34110 */ 0360,0323,02,017,0332,0110,0,
+    /* 34117 */ 0360,0323,02,017,0344,0110,0,
+    /* 34124 */ 0360,0323,02,017,0366,0110,0,
+    /* 34131 */ 0324,0360,02,017,0303,0101,0,
+    /* 34138 */ 0361,0317,02,017,0176,0101,0,
+    /* 34145 */ 0361,0317,02,017,0156,0110,0,
+    /* 34152 */ 0361,0324,02,017,0156,0110,0,
+    /* 34159 */ 0361,0324,02,017,0176,0101,0,
+    /* 34166 */ 0361,02,017,0305,0110,026,0,
+    /* 34173 */ 0361,02,017,0304,0110,026,0,
+    /* 34180 */ 0360,0323,02,017,0364,0110,0,
+    /* 34187 */ 0361,02,017,0160,0110,022,0,
+    /* 34194 */ 0333,02,017,0160,0110,022,0,
+    /* 34201 */ 0332,02,017,0160,0110,022,0,
+    /* 34208 */ 0361,02,017,0163,0207,025,0,
+    /* 34215 */ 0361,02,017,0161,0206,025,0,
+    /* 34222 */ 0361,02,017,0162,0206,025,0,
+    /* 34229 */ 0361,02,017,0163,0206,025,0,
+    /* 34236 */ 0361,02,017,0161,0204,025,0,
+    /* 34243 */ 0361,02,017,0162,0204,025,0,
+    /* 34250 */ 0361,02,017,0163,0203,025,0,
+    /* 34257 */ 0361,02,017,0161,0202,025,0,
+    /* 34264 */ 0361,02,017,0162,0202,025,0,
+    /* 34271 */ 0361,02,017,0163,0202,025,0,
+    /* 34278 */ 0360,0323,02,017,0373,0110,0,
+    /* 34285 */ 0361,02,017,0302,0110,026,0,
+    /* 34292 */ 0332,02,017,0302,0110,026,0,
+    /* 34299 */ 0317,0332,02,017,055,0110,0,
+    /* 34306 */ 0324,0332,02,017,055,0110,0,
+    /* 34313 */ 0317,0332,02,017,052,0110,0,
+    /* 34320 */ 0324,0332,02,017,052,0110,0,
+    /* 34327 */ 0317,0332,02,017,054,0110,0,
+    /* 34334 */ 0324,0332,02,017,054,0110,0,
+    /* 34341 */ 0361,0324,02,017,0120,0110,0,
+    /* 34348 */ 0361,02,017,0306,0110,026,0,
+    /* 34355 */ 0323,0360,02,017,0170,0101,0,
+    /* 34362 */ 0323,0360,02,017,0171,0110,0,
+    /* 34369 */ 0360,03,017,070,034,0110,0,
+    /* 34376 */ 0361,03,017,070,034,0110,0,
+    /* 34383 */ 0360,03,017,070,035,0110,0,
+    /* 34390 */ 0361,03,017,070,035,0110,0,
+    /* 34397 */ 0360,03,017,070,036,0110,0,
+    /* 34404 */ 0361,03,017,070,036,0110,0,
+    /* 34411 */ 0360,03,017,070,01,0110,0,
+    /* 34418 */ 0361,03,017,070,01,0110,0,
+    /* 34425 */ 0360,03,017,070,02,0110,0,
+    /* 34432 */ 0361,03,017,070,02,0110,0,
+    /* 34439 */ 0360,03,017,070,03,0110,0,
+    /* 34446 */ 0361,03,017,070,03,0110,0,
+    /* 34453 */ 0360,03,017,070,05,0110,0,
+    /* 34460 */ 0361,03,017,070,05,0110,0,
+    /* 34467 */ 0360,03,017,070,06,0110,0,
+    /* 34474 */ 0361,03,017,070,06,0110,0,
+    /* 34481 */ 0360,03,017,070,07,0110,0,
+    /* 34488 */ 0361,03,017,070,07,0110,0,
+    /* 34495 */ 0360,03,017,070,04,0110,0,
+    /* 34502 */ 0361,03,017,070,04,0110,0,
+    /* 34509 */ 0360,03,017,070,013,0110,0,
+    /* 34516 */ 0361,03,017,070,013,0110,0,
+    /* 34523 */ 0360,03,017,070,0,0110,0,
+    /* 34530 */ 0361,03,017,070,0,0110,0,
+    /* 34537 */ 0360,03,017,070,010,0110,0,
+    /* 34544 */ 0361,03,017,070,010,0110,0,
+    /* 34551 */ 0360,03,017,070,011,0110,0,
+    /* 34558 */ 0361,03,017,070,011,0110,0,
+    /* 34565 */ 0360,03,017,070,012,0110,0,
+    /* 34572 */ 0361,03,017,070,012,0110,0,
+    /* 34579 */ 0320,0333,02,017,0275,0110,0,
+    /* 34586 */ 0321,0333,02,017,0275,0110,0,
+    /* 34593 */ 0324,0333,02,017,0275,0110,0,
+    /* 34600 */ 0361,03,017,070,025,0110,0,
+    /* 34607 */ 0361,03,017,070,024,0110,0,
+    /* 34614 */ 0361,03,017,070,052,0110,0,
+    /* 34621 */ 0361,03,017,070,053,0110,0,
+    /* 34628 */ 0361,03,017,070,020,0110,0,
+    /* 34635 */ 0361,03,017,070,051,0110,0,
+    /* 34642 */ 0361,03,017,070,0101,0110,0,
+    /* 34649 */ 0361,03,017,070,074,0110,0,
+    /* 34656 */ 0361,03,017,070,075,0110,0,
+    /* 34663 */ 0361,03,017,070,077,0110,0,
+    /* 34670 */ 0361,03,017,070,076,0110,0,
+    /* 34677 */ 0361,03,017,070,070,0110,0,
+    /* 34684 */ 0361,03,017,070,071,0110,0,
+    /* 34691 */ 0361,03,017,070,073,0110,0,
+    /* 34698 */ 0361,03,017,070,072,0110,0,
+    /* 34705 */ 0361,03,017,070,040,0110,0,
+    /* 34712 */ 0361,03,017,070,041,0110,0,
+    /* 34719 */ 0361,03,017,070,042,0110,0,
+    /* 34726 */ 0361,03,017,070,043,0110,0,
+    /* 34733 */ 0361,03,017,070,044,0110,0,
+    /* 34740 */ 0361,03,017,070,045,0110,0,
+    /* 34747 */ 0361,03,017,070,060,0110,0,
+    /* 34754 */ 0361,03,017,070,061,0110,0,
+    /* 34761 */ 0361,03,017,070,062,0110,0,
+    /* 34768 */ 0361,03,017,070,063,0110,0,
+    /* 34775 */ 0361,03,017,070,064,0110,0,
+    /* 34782 */ 0361,03,017,070,065,0110,0,
+    /* 34789 */ 0361,03,017,070,050,0110,0,
+    /* 34796 */ 0361,03,017,070,0100,0110,0,
+    /* 34803 */ 0361,03,017,070,027,0110,0,
+    /* 34810 */ 0361,03,017,070,067,0110,0,
+    /* 34817 */ 0320,0333,02,017,0270,0110,0,
+    /* 34824 */ 0321,0333,02,017,0270,0110,0,
+    /* 34831 */ 0324,0333,02,017,0270,0110,0,
+    /* 34838 */ 0361,03,017,070,0334,0110,0,
+    /* 34845 */ 0361,03,017,070,0335,0110,0,
+    /* 34852 */ 0361,03,017,070,0336,0110,0,
+    /* 34859 */ 0361,03,017,070,0337,0110,0,
+    /* 34866 */ 0361,03,017,070,0333,0110,0,
+    /* 34873 */ 0261,02,041,01,0334,0120,0,
+    /* 34880 */ 0260,02,041,01,0334,0110,0,
+    /* 34887 */ 0261,02,041,01,0335,0120,0,
+    /* 34894 */ 0260,02,041,01,0335,0110,0,
+    /* 34901 */ 0261,02,041,01,0336,0120,0,
+    /* 34908 */ 0260,02,041,01,0336,0110,0,
+    /* 34915 */ 0261,02,041,01,0337,0120,0,
+    /* 34922 */ 0260,02,041,01,0337,0110,0,
+    /* 34929 */ 0270,02,041,01,0333,0110,0,
+    /* 34936 */ 0261,02,045,01,0334,0120,0,
+    /* 34943 */ 0260,02,045,01,0334,0110,0,
+    /* 34950 */ 0261,02,045,01,0335,0120,0,
+    /* 34957 */ 0260,02,045,01,0335,0110,0,
+    /* 34964 */ 0261,02,045,01,0336,0120,0,
+    /* 34971 */ 0260,02,045,01,0336,0110,0,
+    /* 34978 */ 0261,02,045,01,0337,0120,0,
+    /* 34985 */ 0260,02,045,01,0337,0110,0,
+    /* 34992 */ 0261,01,041,01,0130,0120,0,
+    /* 34999 */ 0260,01,041,01,0130,0110,0,
+    /* 35006 */ 0261,01,045,01,0130,0120,0,
+    /* 35013 */ 0260,01,045,01,0130,0110,0,
+    /* 35020 */ 0261,01,040,01,0130,0120,0,
+    /* 35027 */ 0260,01,040,01,0130,0110,0,
+    /* 35034 */ 0261,01,044,01,0130,0120,0,
+    /* 35041 */ 0260,01,044,01,0130,0110,0,
+    /* 35048 */ 0261,01,053,01,0130,0120,0,
+    /* 35055 */ 0260,01,053,01,0130,0110,0,
+    /* 35062 */ 0261,01,052,01,0130,0120,0,
+    /* 35069 */ 0260,01,052,01,0130,0110,0,
+    /* 35076 */ 0261,01,041,01,0320,0120,0,
+    /* 35083 */ 0260,01,041,01,0320,0110,0,
+    /* 35090 */ 0261,01,045,01,0320,0120,0,
+    /* 35097 */ 0260,01,045,01,0320,0110,0,
+    /* 35104 */ 0261,01,043,01,0320,0120,0,
+    /* 35111 */ 0260,01,043,01,0320,0110,0,
+    /* 35118 */ 0261,01,047,01,0320,0120,0,
+    /* 35125 */ 0260,01,047,01,0320,0110,0,
+    /* 35132 */ 0261,01,041,01,0124,0120,0,
+    /* 35139 */ 0260,01,041,01,0124,0110,0,
+    /* 35146 */ 0261,01,045,01,0124,0120,0,
+    /* 35153 */ 0260,01,045,01,0124,0110,0,
+    /* 35160 */ 0261,01,040,01,0124,0120,0,
+    /* 35167 */ 0260,01,040,01,0124,0110,0,
+    /* 35174 */ 0261,01,044,01,0124,0120,0,
+    /* 35181 */ 0260,01,044,01,0124,0110,0,
+    /* 35188 */ 0261,01,041,01,0125,0120,0,
+    /* 35195 */ 0260,01,041,01,0125,0110,0,
+    /* 35202 */ 0261,01,045,01,0125,0120,0,
+    /* 35209 */ 0260,01,045,01,0125,0110,0,
+    /* 35216 */ 0261,01,040,01,0125,0120,0,
+    /* 35223 */ 0260,01,040,01,0125,0110,0,
+    /* 35230 */ 0261,01,044,01,0125,0120,0,
+    /* 35237 */ 0260,01,044,01,0125,0110,0,
+    /* 35244 */ 0270,02,01,01,030,0110,0,
+    /* 35251 */ 0270,02,05,01,030,0110,0,
+    /* 35258 */ 0270,02,05,01,031,0110,0,
+    /* 35265 */ 0270,02,05,01,032,0110,0,
+    /* 35272 */ 0270,01,051,01,057,0110,0,
+    /* 35279 */ 0270,01,050,01,057,0110,0,
+    /* 35286 */ 0270,01,042,01,0346,0110,0,
+    /* 35293 */ 0270,01,046,01,0346,0110,0,
+    /* 35300 */ 0270,01,040,01,0133,0110,0,
+    /* 35307 */ 0270,01,044,01,0133,0110,0,
+    /* 35314 */ 0270,01,043,01,0346,0110,0,
+    /* 35321 */ 0270,01,047,01,0346,0110,0,
+    /* 35328 */ 0270,01,041,01,0132,0110,0,
+    /* 35335 */ 0270,01,045,01,0132,0110,0,
+    /* 35342 */ 0270,01,041,01,0133,0110,0,
+    /* 35349 */ 0270,01,045,01,0133,0110,0,
+    /* 35356 */ 0270,01,040,01,0132,0110,0,
+    /* 35363 */ 0270,01,044,01,0132,0110,0,
+    /* 35370 */ 0270,01,013,01,055,0110,0,
+    /* 35377 */ 0270,01,033,01,055,0110,0,
+    /* 35384 */ 0261,01,053,01,0132,0120,0,
+    /* 35391 */ 0260,01,053,01,0132,0110,0,
+    /* 35398 */ 0261,01,013,01,052,0120,0,
+    /* 35405 */ 0260,01,013,01,052,0110,0,
+    /* 35412 */ 0261,01,033,01,052,0120,0,
+    /* 35419 */ 0260,01,033,01,052,0110,0,
+    /* 35426 */ 0261,01,012,01,052,0120,0,
+    /* 35433 */ 0260,01,012,01,052,0110,0,
+    /* 35440 */ 0261,01,032,01,052,0120,0,
+    /* 35447 */ 0260,01,032,01,052,0110,0,
+    /* 35454 */ 0261,01,052,01,0132,0120,0,
+    /* 35461 */ 0260,01,052,01,0132,0110,0,
+    /* 35468 */ 0270,01,012,01,055,0110,0,
+    /* 35475 */ 0270,01,032,01,055,0110,0,
+    /* 35482 */ 0270,01,041,01,0346,0110,0,
+    /* 35489 */ 0270,01,045,01,0346,0110,0,
+    /* 35496 */ 0270,01,042,01,0133,0110,0,
+    /* 35503 */ 0270,01,046,01,0133,0110,0,
+    /* 35510 */ 0270,01,013,01,054,0110,0,
+    /* 35517 */ 0270,01,033,01,054,0110,0,
+    /* 35524 */ 0270,01,012,01,054,0110,0,
+    /* 35531 */ 0270,01,032,01,054,0110,0,
+    /* 35538 */ 0261,01,041,01,0136,0120,0,
+    /* 35545 */ 0260,01,041,01,0136,0110,0,
+    /* 35552 */ 0261,01,045,01,0136,0120,0,
+    /* 35559 */ 0260,01,045,01,0136,0110,0,
+    /* 35566 */ 0261,01,040,01,0136,0120,0,
+    /* 35573 */ 0260,01,040,01,0136,0110,0,
+    /* 35580 */ 0261,01,044,01,0136,0120,0,
+    /* 35587 */ 0260,01,044,01,0136,0110,0,
+    /* 35594 */ 0261,01,053,01,0136,0120,0,
+    /* 35601 */ 0260,01,053,01,0136,0110,0,
+    /* 35608 */ 0261,01,052,01,0136,0120,0,
+    /* 35615 */ 0260,01,052,01,0136,0110,0,
+    /* 35622 */ 0261,01,041,01,0174,0120,0,
+    /* 35629 */ 0260,01,041,01,0174,0110,0,
+    /* 35636 */ 0261,01,045,01,0174,0120,0,
+    /* 35643 */ 0260,01,045,01,0174,0110,0,
+    /* 35650 */ 0261,01,043,01,0174,0120,0,
+    /* 35657 */ 0260,01,043,01,0174,0110,0,
+    /* 35664 */ 0261,01,047,01,0174,0120,0,
+    /* 35671 */ 0260,01,047,01,0174,0110,0,
+    /* 35678 */ 0261,01,041,01,0175,0120,0,
+    /* 35685 */ 0260,01,041,01,0175,0110,0,
+    /* 35692 */ 0261,01,045,01,0175,0120,0,
+    /* 35699 */ 0260,01,045,01,0175,0110,0,
+    /* 35706 */ 0261,01,043,01,0175,0120,0,
+    /* 35713 */ 0260,01,043,01,0175,0110,0,
+    /* 35720 */ 0261,01,047,01,0175,0120,0,
+    /* 35727 */ 0260,01,047,01,0175,0110,0,
+    /* 35734 */ 0270,01,043,01,0360,0110,0,
+    /* 35741 */ 0270,01,047,01,0360,0110,0,
+    /* 35748 */ 0270,01,040,01,0256,0202,0,
+    /* 35755 */ 0270,01,041,01,0367,0110,0,
+    /* 35762 */ 0261,02,01,01,054,0120,0,
+    /* 35769 */ 0261,02,05,01,054,0120,0,
+    /* 35776 */ 0261,02,01,01,056,0102,0,
+    /* 35783 */ 0261,02,05,01,056,0102,0,
+    /* 35790 */ 0261,02,01,01,055,0120,0,
+    /* 35797 */ 0261,02,05,01,055,0120,0,
+    /* 35804 */ 0261,02,01,01,057,0102,0,
+    /* 35811 */ 0261,02,05,01,057,0102,0,
+    /* 35818 */ 0261,01,041,01,0137,0120,0,
+    /* 35825 */ 0260,01,041,01,0137,0110,0,
+    /* 35832 */ 0261,01,045,01,0137,0120,0,
+    /* 35839 */ 0260,01,045,01,0137,0110,0,
+    /* 35846 */ 0261,01,040,01,0137,0120,0,
+    /* 35853 */ 0260,01,040,01,0137,0110,0,
+    /* 35860 */ 0261,01,044,01,0137,0120,0,
+    /* 35867 */ 0260,01,044,01,0137,0110,0,
+    /* 35874 */ 0261,01,053,01,0137,0120,0,
+    /* 35881 */ 0260,01,053,01,0137,0110,0,
+    /* 35888 */ 0261,01,052,01,0137,0120,0,
+    /* 35895 */ 0260,01,052,01,0137,0110,0,
+    /* 35902 */ 0261,01,041,01,0135,0120,0,
+    /* 35909 */ 0260,01,041,01,0135,0110,0,
+    /* 35916 */ 0261,01,045,01,0135,0120,0,
+    /* 35923 */ 0260,01,045,01,0135,0110,0,
+    /* 35930 */ 0261,01,040,01,0135,0120,0,
+    /* 35937 */ 0260,01,040,01,0135,0110,0,
+    /* 35944 */ 0261,01,044,01,0135,0120,0,
+    /* 35951 */ 0260,01,044,01,0135,0110,0,
+    /* 35958 */ 0261,01,053,01,0135,0120,0,
+    /* 35965 */ 0260,01,053,01,0135,0110,0,
+    /* 35972 */ 0261,01,052,01,0135,0120,0,
+    /* 35979 */ 0260,01,052,01,0135,0110,0,
+    /* 35986 */ 0270,01,041,01,050,0110,0,
+    /* 35993 */ 0270,01,041,01,051,0101,0,
+    /* 36000 */ 0270,01,045,01,050,0110,0,
+    /* 36007 */ 0270,01,045,01,051,0101,0,
+    /* 36014 */ 0270,01,040,01,050,0110,0,
+    /* 36021 */ 0270,01,040,01,051,0101,0,
+    /* 36028 */ 0270,01,044,01,050,0110,0,
+    /* 36035 */ 0270,01,044,01,051,0101,0,
+    /* 36042 */ 0270,01,01,01,0156,0110,0,
+    /* 36049 */ 0270,01,01,01,0176,0101,0,
+    /* 36056 */ 0270,01,042,01,0176,0110,0,
+    /* 36063 */ 0270,01,041,01,0326,0101,0,
+    /* 36070 */ 0270,01,021,01,0156,0110,0,
+    /* 36077 */ 0270,01,021,01,0176,0101,0,
+    /* 36084 */ 0270,01,043,01,022,0110,0,
+    /* 36091 */ 0270,01,047,01,022,0110,0,
+    /* 36098 */ 0270,01,041,01,0157,0110,0,
+    /* 36105 */ 0270,01,041,01,0177,0101,0,
+    /* 36112 */ 0270,01,045,01,0157,0110,0,
+    /* 36119 */ 0270,01,045,01,0177,0101,0,
+    /* 36126 */ 0270,01,042,01,0157,0110,0,
+    /* 36133 */ 0270,01,042,01,0177,0101,0,
+    /* 36140 */ 0270,01,046,01,0157,0110,0,
+    /* 36147 */ 0270,01,046,01,0177,0101,0,
+    /* 36154 */ 0261,01,040,01,022,0120,0,
+    /* 36161 */ 0260,01,040,01,022,0110,0,
+    /* 36168 */ 0261,01,041,01,026,0120,0,
+    /* 36175 */ 0260,01,041,01,026,0110,0,
+    /* 36182 */ 0270,01,041,01,027,0101,0,
+    /* 36189 */ 0261,01,040,01,026,0120,0,
+    /* 36196 */ 0260,01,040,01,026,0110,0,
+    /* 36203 */ 0270,01,040,01,027,0101,0,
+    /* 36210 */ 0261,01,041,01,022,0120,0,
+    /* 36217 */ 0260,01,041,01,022,0110,0,
+    /* 36224 */ 0270,01,041,01,023,0101,0,
+    /* 36231 */ 0270,01,040,01,023,0101,0,
+    /* 36238 */ 0270,01,041,01,0120,0110,0,
+    /* 36245 */ 0270,01,045,01,0120,0110,0,
+    /* 36252 */ 0270,01,040,01,0120,0110,0,
+    /* 36259 */ 0270,01,044,01,0120,0110,0,
+    /* 36266 */ 0270,01,041,01,0347,0101,0,
+    /* 36273 */ 0270,01,045,01,0347,0101,0,
+    /* 36280 */ 0270,02,041,01,052,0110,0,
+    /* 36287 */ 0270,01,041,01,053,0101,0,
+    /* 36294 */ 0270,01,045,01,053,0101,0,
+    /* 36301 */ 0270,01,040,01,053,0101,0,
+    /* 36308 */ 0270,01,044,01,053,0101,0,
+    /* 36315 */ 0261,01,053,01,020,0120,0,
+    /* 36322 */ 0260,01,053,01,020,0110,0,
+    /* 36329 */ 0270,01,053,01,020,0110,0,
+    /* 36336 */ 0261,01,053,01,021,0102,0,
+    /* 36343 */ 0260,01,053,01,021,0101,0,
+    /* 36350 */ 0270,01,053,01,021,0101,0,
+    /* 36357 */ 0270,01,042,01,026,0110,0,
+    /* 36364 */ 0270,01,046,01,026,0110,0,
+    /* 36371 */ 0270,01,042,01,022,0110,0,
+    /* 36378 */ 0270,01,046,01,022,0110,0,
+    /* 36385 */ 0261,01,052,01,020,0120,0,
+    /* 36392 */ 0260,01,052,01,020,0110,0,
+    /* 36399 */ 0270,01,052,01,020,0110,0,
+    /* 36406 */ 0261,01,052,01,021,0102,0,
+    /* 36413 */ 0260,01,052,01,021,0101,0,
+    /* 36420 */ 0270,01,052,01,021,0101,0,
+    /* 36427 */ 0270,01,041,01,020,0110,0,
+    /* 36434 */ 0270,01,041,01,021,0101,0,
+    /* 36441 */ 0270,01,045,01,020,0110,0,
+    /* 36448 */ 0270,01,045,01,021,0101,0,
+    /* 36455 */ 0270,01,040,01,020,0110,0,
+    /* 36462 */ 0270,01,040,01,021,0101,0,
+    /* 36469 */ 0270,01,044,01,020,0110,0,
+    /* 36476 */ 0270,01,044,01,021,0101,0,
+    /* 36483 */ 0261,01,041,01,0131,0120,0,
+    /* 36490 */ 0260,01,041,01,0131,0110,0,
+    /* 36497 */ 0261,01,045,01,0131,0120,0,
+    /* 36504 */ 0260,01,045,01,0131,0110,0,
+    /* 36511 */ 0261,01,040,01,0131,0120,0,
+    /* 36518 */ 0260,01,040,01,0131,0110,0,
+    /* 36525 */ 0261,01,044,01,0131,0120,0,
+    /* 36532 */ 0260,01,044,01,0131,0110,0,
+    /* 36539 */ 0261,01,053,01,0131,0120,0,
+    /* 36546 */ 0260,01,053,01,0131,0110,0,
+    /* 36553 */ 0261,01,052,01,0131,0120,0,
+    /* 36560 */ 0260,01,052,01,0131,0110,0,
+    /* 36567 */ 0261,01,041,01,0126,0120,0,
+    /* 36574 */ 0260,01,041,01,0126,0110,0,
+    /* 36581 */ 0261,01,045,01,0126,0120,0,
+    /* 36588 */ 0260,01,045,01,0126,0110,0,
+    /* 36595 */ 0261,01,040,01,0126,0120,0,
+    /* 36602 */ 0260,01,040,01,0126,0110,0,
+    /* 36609 */ 0261,01,044,01,0126,0120,0,
+    /* 36616 */ 0260,01,044,01,0126,0110,0,
+    /* 36623 */ 0270,02,041,01,034,0110,0,
+    /* 36630 */ 0270,02,041,01,035,0110,0,
+    /* 36637 */ 0270,02,041,01,036,0110,0,
+    /* 36644 */ 0261,01,041,01,0143,0120,0,
+    /* 36651 */ 0260,01,041,01,0143,0110,0,
+    /* 36658 */ 0261,01,041,01,0153,0120,0,
+    /* 36665 */ 0260,01,041,01,0153,0110,0,
+    /* 36672 */ 0261,01,041,01,0147,0120,0,
+    /* 36679 */ 0260,01,041,01,0147,0110,0,
+    /* 36686 */ 0261,02,041,01,053,0120,0,
+    /* 36693 */ 0260,02,041,01,053,0110,0,
+    /* 36700 */ 0261,01,041,01,0374,0120,0,
+    /* 36707 */ 0260,01,041,01,0374,0110,0,
+    /* 36714 */ 0261,01,041,01,0375,0120,0,
+    /* 36721 */ 0260,01,041,01,0375,0110,0,
+    /* 36728 */ 0261,01,041,01,0376,0120,0,
+    /* 36735 */ 0260,01,041,01,0376,0110,0,
+    /* 36742 */ 0261,01,041,01,0324,0120,0,
+    /* 36749 */ 0260,01,041,01,0324,0110,0,
+    /* 36756 */ 0261,01,041,01,0354,0120,0,
+    /* 36763 */ 0260,01,041,01,0354,0110,0,
+    /* 36770 */ 0261,01,041,01,0355,0120,0,
+    /* 36777 */ 0260,01,041,01,0355,0110,0,
+    /* 36784 */ 0261,01,041,01,0334,0120,0,
+    /* 36791 */ 0260,01,041,01,0334,0110,0,
+    /* 36798 */ 0261,01,041,01,0335,0120,0,
+    /* 36805 */ 0260,01,041,01,0335,0110,0,
+    /* 36812 */ 0261,01,041,01,0333,0120,0,
+    /* 36819 */ 0260,01,041,01,0333,0110,0,
+    /* 36826 */ 0261,01,041,01,0337,0120,0,
+    /* 36833 */ 0260,01,041,01,0337,0110,0,
+    /* 36840 */ 0261,01,041,01,0340,0120,0,
+    /* 36847 */ 0260,01,041,01,0340,0110,0,
+    /* 36854 */ 0261,01,041,01,0343,0120,0,
+    /* 36861 */ 0260,01,041,01,0343,0110,0,
+    /* 36868 */ 0261,01,041,01,0164,0120,0,
+    /* 36875 */ 0260,01,041,01,0164,0110,0,
+    /* 36882 */ 0261,01,041,01,0165,0120,0,
+    /* 36889 */ 0260,01,041,01,0165,0110,0,
+    /* 36896 */ 0261,01,041,01,0166,0120,0,
+    /* 36903 */ 0260,01,041,01,0166,0110,0,
+    /* 36910 */ 0261,02,041,01,051,0120,0,
+    /* 36917 */ 0260,02,041,01,051,0110,0,
+    /* 36924 */ 0261,01,041,01,0144,0120,0,
+    /* 36931 */ 0260,01,041,01,0144,0110,0,
+    /* 36938 */ 0261,01,041,01,0145,0120,0,
+    /* 36945 */ 0260,01,041,01,0145,0110,0,
+    /* 36952 */ 0261,01,041,01,0146,0120,0,
+    /* 36959 */ 0260,01,041,01,0146,0110,0,
+    /* 36966 */ 0261,02,041,01,067,0120,0,
+    /* 36973 */ 0260,02,041,01,067,0110,0,
+    /* 36980 */ 0261,02,01,01,015,0120,0,
+    /* 36987 */ 0260,02,01,01,015,0110,0,
+    /* 36994 */ 0261,02,05,01,015,0120,0,
+    /* 37001 */ 0260,02,05,01,015,0110,0,
+    /* 37008 */ 0261,02,01,01,014,0120,0,
+    /* 37015 */ 0260,02,01,01,014,0110,0,
+    /* 37022 */ 0261,02,05,01,014,0120,0,
+    /* 37029 */ 0260,02,05,01,014,0110,0,
+    /* 37036 */ 0261,02,041,01,01,0120,0,
+    /* 37043 */ 0260,02,041,01,01,0110,0,
+    /* 37050 */ 0261,02,041,01,02,0120,0,
+    /* 37057 */ 0260,02,041,01,02,0110,0,
+    /* 37064 */ 0261,02,041,01,03,0120,0,
+    /* 37071 */ 0260,02,041,01,03,0110,0,
+    /* 37078 */ 0270,02,041,01,0101,0110,0,
+    /* 37085 */ 0261,02,041,01,05,0120,0,
+    /* 37092 */ 0260,02,041,01,05,0110,0,
+    /* 37099 */ 0261,02,041,01,06,0120,0,
+    /* 37106 */ 0260,02,041,01,06,0110,0,
+    /* 37113 */ 0261,02,041,01,07,0120,0,
+    /* 37120 */ 0260,02,041,01,07,0110,0,
+    /* 37127 */ 0261,01,041,01,0365,0120,0,
+    /* 37134 */ 0260,01,041,01,0365,0110,0,
+    /* 37141 */ 0261,02,041,01,04,0120,0,
+    /* 37148 */ 0260,02,041,01,04,0110,0,
+    /* 37155 */ 0261,02,041,01,074,0120,0,
+    /* 37162 */ 0260,02,041,01,074,0110,0,
+    /* 37169 */ 0261,01,041,01,0356,0120,0,
+    /* 37176 */ 0260,01,041,01,0356,0110,0,
+    /* 37183 */ 0261,02,041,01,075,0120,0,
+    /* 37190 */ 0260,02,041,01,075,0110,0,
+    /* 37197 */ 0261,01,041,01,0336,0120,0,
+    /* 37204 */ 0260,01,041,01,0336,0110,0,
+    /* 37211 */ 0261,02,041,01,076,0120,0,
+    /* 37218 */ 0260,02,041,01,076,0110,0,
+    /* 37225 */ 0261,02,041,01,077,0120,0,
+    /* 37232 */ 0260,02,041,01,077,0110,0,
+    /* 37239 */ 0261,02,041,01,070,0120,0,
+    /* 37246 */ 0260,02,041,01,070,0110,0,
+    /* 37253 */ 0261,01,041,01,0352,0120,0,
+    /* 37260 */ 0260,01,041,01,0352,0110,0,
+    /* 37267 */ 0261,02,041,01,071,0120,0,
+    /* 37274 */ 0260,02,041,01,071,0110,0,
+    /* 37281 */ 0261,01,041,01,0332,0120,0,
+    /* 37288 */ 0260,01,041,01,0332,0110,0,
+    /* 37295 */ 0261,02,041,01,072,0120,0,
+    /* 37302 */ 0260,02,041,01,072,0110,0,
+    /* 37309 */ 0261,02,041,01,073,0120,0,
+    /* 37316 */ 0260,02,041,01,073,0110,0,
+    /* 37323 */ 0270,01,041,01,0327,0110,0,
+    /* 37330 */ 0270,02,041,01,040,0110,0,
+    /* 37337 */ 0270,02,041,01,041,0110,0,
+    /* 37344 */ 0270,02,041,01,042,0110,0,
+    /* 37351 */ 0270,02,041,01,043,0110,0,
+    /* 37358 */ 0270,02,041,01,044,0110,0,
+    /* 37365 */ 0270,02,041,01,045,0110,0,
+    /* 37372 */ 0270,02,041,01,060,0110,0,
+    /* 37379 */ 0270,02,041,01,061,0110,0,
+    /* 37386 */ 0270,02,041,01,062,0110,0,
+    /* 37393 */ 0270,02,041,01,063,0110,0,
+    /* 37400 */ 0270,02,041,01,064,0110,0,
+    /* 37407 */ 0270,02,041,01,065,0110,0,
+    /* 37414 */ 0261,01,041,01,0344,0120,0,
+    /* 37421 */ 0260,01,041,01,0344,0110,0,
+    /* 37428 */ 0261,02,041,01,013,0120,0,
+    /* 37435 */ 0260,02,041,01,013,0110,0,
+    /* 37442 */ 0261,01,041,01,0345,0120,0,
+    /* 37449 */ 0260,01,041,01,0345,0110,0,
+    /* 37456 */ 0261,01,041,01,0325,0120,0,
+    /* 37463 */ 0260,01,041,01,0325,0110,0,
+    /* 37470 */ 0261,02,041,01,0100,0120,0,
+    /* 37477 */ 0260,02,041,01,0100,0110,0,
+    /* 37484 */ 0261,01,041,01,0364,0120,0,
+    /* 37491 */ 0260,01,041,01,0364,0110,0,
+    /* 37498 */ 0261,02,041,01,050,0120,0,
+    /* 37505 */ 0260,02,041,01,050,0110,0,
+    /* 37512 */ 0261,01,041,01,0353,0120,0,
+    /* 37519 */ 0260,01,041,01,0353,0110,0,
+    /* 37526 */ 0261,01,041,01,0366,0120,0,
+    /* 37533 */ 0260,01,041,01,0366,0110,0,
+    /* 37540 */ 0261,02,041,01,0,0120,0,
+    /* 37547 */ 0260,02,041,01,0,0110,0,
+    /* 37554 */ 0261,02,041,01,010,0120,0,
+    /* 37561 */ 0260,02,041,01,010,0110,0,
+    /* 37568 */ 0261,02,041,01,011,0120,0,
+    /* 37575 */ 0260,02,041,01,011,0110,0,
+    /* 37582 */ 0261,02,041,01,012,0120,0,
+    /* 37589 */ 0260,02,041,01,012,0110,0,
+    /* 37596 */ 0261,01,041,01,0361,0120,0,
+    /* 37603 */ 0260,01,041,01,0361,0110,0,
+    /* 37610 */ 0261,01,041,01,0362,0120,0,
+    /* 37617 */ 0260,01,041,01,0362,0110,0,
+    /* 37624 */ 0261,01,041,01,0363,0120,0,
+    /* 37631 */ 0260,01,041,01,0363,0110,0,
+    /* 37638 */ 0261,01,041,01,0341,0120,0,
+    /* 37645 */ 0260,01,041,01,0341,0110,0,
+    /* 37652 */ 0261,01,041,01,0342,0120,0,
+    /* 37659 */ 0260,01,041,01,0342,0110,0,
+    /* 37666 */ 0261,01,041,01,0321,0120,0,
+    /* 37673 */ 0260,01,041,01,0321,0110,0,
+    /* 37680 */ 0261,01,041,01,0322,0120,0,
+    /* 37687 */ 0260,01,041,01,0322,0110,0,
+    /* 37694 */ 0261,01,041,01,0323,0120,0,
+    /* 37701 */ 0260,01,041,01,0323,0110,0,
+    /* 37708 */ 0270,02,041,01,027,0110,0,
+    /* 37715 */ 0270,02,045,01,027,0110,0,
+    /* 37722 */ 0261,01,041,01,0370,0120,0,
+    /* 37729 */ 0260,01,041,01,0370,0110,0,
+    /* 37736 */ 0261,01,041,01,0371,0120,0,
+    /* 37743 */ 0260,01,041,01,0371,0110,0,
+    /* 37750 */ 0261,01,041,01,0372,0120,0,
+    /* 37757 */ 0260,01,041,01,0372,0110,0,
+    /* 37764 */ 0261,01,041,01,0373,0120,0,
+    /* 37771 */ 0260,01,041,01,0373,0110,0,
+    /* 37778 */ 0261,01,041,01,0350,0120,0,
+    /* 37785 */ 0260,01,041,01,0350,0110,0,
+    /* 37792 */ 0261,01,041,01,0351,0120,0,
+    /* 37799 */ 0260,01,041,01,0351,0110,0,
+    /* 37806 */ 0261,01,041,01,0330,0120,0,
+    /* 37813 */ 0260,01,041,01,0330,0110,0,
+    /* 37820 */ 0261,01,041,01,0331,0120,0,
+    /* 37827 */ 0260,01,041,01,0331,0110,0,
+    /* 37834 */ 0261,01,041,01,0150,0120,0,
+    /* 37841 */ 0260,01,041,01,0150,0110,0,
+    /* 37848 */ 0261,01,041,01,0151,0120,0,
+    /* 37855 */ 0260,01,041,01,0151,0110,0,
+    /* 37862 */ 0261,01,041,01,0152,0120,0,
+    /* 37869 */ 0260,01,041,01,0152,0110,0,
+    /* 37876 */ 0261,01,041,01,0155,0120,0,
+    /* 37883 */ 0260,01,041,01,0155,0110,0,
+    /* 37890 */ 0261,01,041,01,0140,0120,0,
+    /* 37897 */ 0260,01,041,01,0140,0110,0,
+    /* 37904 */ 0261,01,041,01,0141,0120,0,
+    /* 37911 */ 0260,01,041,01,0141,0110,0,
+    /* 37918 */ 0261,01,041,01,0142,0120,0,
+    /* 37925 */ 0260,01,041,01,0142,0110,0,
+    /* 37932 */ 0261,01,041,01,0154,0120,0,
+    /* 37939 */ 0260,01,041,01,0154,0110,0,
+    /* 37946 */ 0261,01,041,01,0357,0120,0,
+    /* 37953 */ 0260,01,041,01,0357,0110,0,
+    /* 37960 */ 0270,01,040,01,0123,0110,0,
+    /* 37967 */ 0270,01,044,01,0123,0110,0,
+    /* 37974 */ 0261,01,052,01,0123,0120,0,
+    /* 37981 */ 0260,01,052,01,0123,0110,0,
+    /* 37988 */ 0270,01,040,01,0122,0110,0,
+    /* 37995 */ 0270,01,044,01,0122,0110,0,
+    /* 38002 */ 0261,01,052,01,0122,0120,0,
+    /* 38009 */ 0260,01,052,01,0122,0110,0,
+    /* 38016 */ 0270,01,041,01,0121,0110,0,
+    /* 38023 */ 0270,01,045,01,0121,0110,0,
+    /* 38030 */ 0270,01,040,01,0121,0110,0,
+    /* 38037 */ 0270,01,044,01,0121,0110,0,
+    /* 38044 */ 0261,01,053,01,0121,0120,0,
+    /* 38051 */ 0260,01,053,01,0121,0110,0,
+    /* 38058 */ 0261,01,052,01,0121,0120,0,
+    /* 38065 */ 0260,01,052,01,0121,0110,0,
+    /* 38072 */ 0270,01,040,01,0256,0203,0,
+    /* 38079 */ 0261,01,041,01,0134,0120,0,
+    /* 38086 */ 0260,01,041,01,0134,0110,0,
+    /* 38093 */ 0261,01,045,01,0134,0120,0,
+    /* 38100 */ 0260,01,045,01,0134,0110,0,
+    /* 38107 */ 0261,01,040,01,0134,0120,0,
+    /* 38114 */ 0260,01,040,01,0134,0110,0,
+    /* 38121 */ 0261,01,044,01,0134,0120,0,
+    /* 38128 */ 0260,01,044,01,0134,0110,0,
+    /* 38135 */ 0261,01,053,01,0134,0120,0,
+    /* 38142 */ 0260,01,053,01,0134,0110,0,
+    /* 38149 */ 0261,01,052,01,0134,0120,0,
+    /* 38156 */ 0260,01,052,01,0134,0110,0,
+    /* 38163 */ 0270,02,01,01,016,0110,0,
+    /* 38170 */ 0270,02,05,01,016,0110,0,
+    /* 38177 */ 0270,02,01,01,017,0110,0,
+    /* 38184 */ 0270,02,05,01,017,0110,0,
+    /* 38191 */ 0270,01,051,01,056,0110,0,
+    /* 38198 */ 0270,01,050,01,056,0110,0,
+    /* 38205 */ 0261,01,041,01,025,0120,0,
+    /* 38212 */ 0260,01,041,01,025,0110,0,
+    /* 38219 */ 0261,01,045,01,025,0120,0,
+    /* 38226 */ 0260,01,045,01,025,0110,0,
+    /* 38233 */ 0261,01,040,01,025,0120,0,
+    /* 38240 */ 0260,01,040,01,025,0110,0,
+    /* 38247 */ 0261,01,044,01,025,0120,0,
+    /* 38254 */ 0260,01,044,01,025,0110,0,
+    /* 38261 */ 0261,01,041,01,024,0120,0,
+    /* 38268 */ 0260,01,041,01,024,0110,0,
+    /* 38275 */ 0261,01,045,01,024,0120,0,
+    /* 38282 */ 0260,01,045,01,024,0110,0,
+    /* 38289 */ 0261,01,040,01,024,0120,0,
+    /* 38296 */ 0260,01,040,01,024,0110,0,
+    /* 38303 */ 0261,01,044,01,024,0120,0,
+    /* 38310 */ 0260,01,044,01,024,0110,0,
+    /* 38317 */ 0261,01,041,01,0127,0120,0,
+    /* 38324 */ 0260,01,041,01,0127,0110,0,
+    /* 38331 */ 0261,01,045,01,0127,0120,0,
+    /* 38338 */ 0260,01,045,01,0127,0110,0,
+    /* 38345 */ 0261,01,040,01,0127,0120,0,
+    /* 38352 */ 0260,01,040,01,0127,0110,0,
+    /* 38359 */ 0261,01,044,01,0127,0120,0,
+    /* 38366 */ 0260,01,044,01,0127,0110,0,
+    /* 38373 */ 0261,02,01,01,0230,0120,0,
+    /* 38380 */ 0261,02,05,01,0230,0120,0,
+    /* 38387 */ 0261,02,021,01,0230,0120,0,
+    /* 38394 */ 0261,02,025,01,0230,0120,0,
+    /* 38401 */ 0261,02,01,01,0250,0120,0,
+    /* 38408 */ 0261,02,05,01,0250,0120,0,
+    /* 38415 */ 0261,02,021,01,0250,0120,0,
+    /* 38422 */ 0261,02,025,01,0250,0120,0,
+    /* 38429 */ 0261,02,01,01,0270,0120,0,
+    /* 38436 */ 0261,02,05,01,0270,0120,0,
+    /* 38443 */ 0261,02,021,01,0270,0120,0,
+    /* 38450 */ 0261,02,025,01,0270,0120,0,
+    /* 38457 */ 0261,02,01,01,0226,0120,0,
+    /* 38464 */ 0261,02,05,01,0226,0120,0,
+    /* 38471 */ 0261,02,021,01,0226,0120,0,
+    /* 38478 */ 0261,02,025,01,0226,0120,0,
+    /* 38485 */ 0261,02,01,01,0246,0120,0,
+    /* 38492 */ 0261,02,05,01,0246,0120,0,
+    /* 38499 */ 0261,02,021,01,0246,0120,0,
+    /* 38506 */ 0261,02,025,01,0246,0120,0,
+    /* 38513 */ 0261,02,01,01,0266,0120,0,
+    /* 38520 */ 0261,02,05,01,0266,0120,0,
+    /* 38527 */ 0261,02,021,01,0266,0120,0,
+    /* 38534 */ 0261,02,025,01,0266,0120,0,
+    /* 38541 */ 0261,02,01,01,0232,0120,0,
+    /* 38548 */ 0261,02,05,01,0232,0120,0,
+    /* 38555 */ 0261,02,021,01,0232,0120,0,
+    /* 38562 */ 0261,02,025,01,0232,0120,0,
+    /* 38569 */ 0261,02,01,01,0252,0120,0,
+    /* 38576 */ 0261,02,05,01,0252,0120,0,
+    /* 38583 */ 0261,02,021,01,0252,0120,0,
+    /* 38590 */ 0261,02,025,01,0252,0120,0,
+    /* 38597 */ 0261,02,01,01,0272,0120,0,
+    /* 38604 */ 0261,02,05,01,0272,0120,0,
+    /* 38611 */ 0261,02,021,01,0272,0120,0,
+    /* 38618 */ 0261,02,025,01,0272,0120,0,
+    /* 38625 */ 0261,02,01,01,0227,0120,0,
+    /* 38632 */ 0261,02,05,01,0227,0120,0,
+    /* 38639 */ 0261,02,021,01,0227,0120,0,
+    /* 38646 */ 0261,02,025,01,0227,0120,0,
+    /* 38653 */ 0261,02,01,01,0247,0120,0,
+    /* 38660 */ 0261,02,05,01,0247,0120,0,
+    /* 38667 */ 0261,02,021,01,0247,0120,0,
+    /* 38674 */ 0261,02,025,01,0247,0120,0,
+    /* 38681 */ 0261,02,01,01,0267,0120,0,
+    /* 38688 */ 0261,02,05,01,0267,0120,0,
+    /* 38695 */ 0261,02,021,01,0267,0120,0,
+    /* 38702 */ 0261,02,025,01,0267,0120,0,
+    /* 38709 */ 0261,02,01,01,0234,0120,0,
+    /* 38716 */ 0261,02,05,01,0234,0120,0,
+    /* 38723 */ 0261,02,021,01,0234,0120,0,
+    /* 38730 */ 0261,02,025,01,0234,0120,0,
+    /* 38737 */ 0261,02,01,01,0254,0120,0,
+    /* 38744 */ 0261,02,05,01,0254,0120,0,
+    /* 38751 */ 0261,02,021,01,0254,0120,0,
+    /* 38758 */ 0261,02,025,01,0254,0120,0,
+    /* 38765 */ 0261,02,01,01,0274,0120,0,
+    /* 38772 */ 0261,02,05,01,0274,0120,0,
+    /* 38779 */ 0261,02,021,01,0274,0120,0,
+    /* 38786 */ 0261,02,025,01,0274,0120,0,
+    /* 38793 */ 0261,02,01,01,0236,0120,0,
+    /* 38800 */ 0261,02,05,01,0236,0120,0,
+    /* 38807 */ 0261,02,021,01,0236,0120,0,
+    /* 38814 */ 0261,02,025,01,0236,0120,0,
+    /* 38821 */ 0261,02,01,01,0256,0120,0,
+    /* 38828 */ 0261,02,05,01,0256,0120,0,
+    /* 38835 */ 0261,02,021,01,0256,0120,0,
+    /* 38842 */ 0261,02,025,01,0256,0120,0,
+    /* 38849 */ 0261,02,01,01,0276,0120,0,
+    /* 38856 */ 0261,02,05,01,0276,0120,0,
+    /* 38863 */ 0261,02,021,01,0276,0120,0,
+    /* 38870 */ 0261,02,025,01,0276,0120,0,
+    /* 38877 */ 0261,02,01,01,0231,0120,0,
+    /* 38884 */ 0261,02,021,01,0231,0120,0,
+    /* 38891 */ 0261,02,01,01,0251,0120,0,
+    /* 38898 */ 0261,02,021,01,0251,0120,0,
+    /* 38905 */ 0261,02,01,01,0271,0120,0,
+    /* 38912 */ 0261,02,021,01,0271,0120,0,
+    /* 38919 */ 0261,02,01,01,0233,0120,0,
+    /* 38926 */ 0261,02,021,01,0233,0120,0,
+    /* 38933 */ 0261,02,01,01,0253,0120,0,
+    /* 38940 */ 0261,02,021,01,0253,0120,0,
+    /* 38947 */ 0261,02,01,01,0273,0120,0,
+    /* 38954 */ 0261,02,021,01,0273,0120,0,
+    /* 38961 */ 0261,02,01,01,0235,0120,0,
+    /* 38968 */ 0261,02,021,01,0235,0120,0,
+    /* 38975 */ 0261,02,01,01,0255,0120,0,
+    /* 38982 */ 0261,02,021,01,0255,0120,0,
+    /* 38989 */ 0261,02,01,01,0275,0120,0,
+    /* 38996 */ 0261,02,021,01,0275,0120,0,
+    /* 39003 */ 0261,02,01,01,0237,0120,0,
+    /* 39010 */ 0261,02,021,01,0237,0120,0,
+    /* 39017 */ 0261,02,01,01,0257,0120,0,
+    /* 39024 */ 0261,02,021,01,0257,0120,0,
+    /* 39031 */ 0261,02,01,01,0277,0120,0,
+    /* 39038 */ 0261,02,021,01,0277,0120,0,
+    /* 39045 */ 0317,0333,02,017,0256,0200,0,
+    /* 39052 */ 0324,0333,02,017,0256,0200,0,
+    /* 39059 */ 0317,0333,02,017,0256,0201,0,
+    /* 39066 */ 0324,0333,02,017,0256,0201,0,
+    /* 39073 */ 0317,0333,02,017,0256,0202,0,
+    /* 39080 */ 0324,0333,02,017,0256,0202,0,
+    /* 39087 */ 0317,0333,02,017,0256,0203,0,
+    /* 39094 */ 0324,0333,02,017,0256,0203,0,
+    /* 39101 */ 0270,02,05,01,023,0110,0,
+    /* 39108 */ 0270,02,01,01,023,0110,0,
+    /* 39115 */ 0270,0111,0,01,022,0200,0,
+    /* 39122 */ 0270,0111,020,01,022,0200,0,
+    /* 39129 */ 0270,0111,0,01,022,0201,0,
+    /* 39136 */ 0270,0111,020,01,022,0201,0,
+    /* 39143 */ 0270,0111,0,01,0201,0110,0,
+    /* 39150 */ 0270,0111,0,01,0201,0100,0,
+    /* 39157 */ 0270,0111,04,01,0201,0110,0,
+    /* 39164 */ 0270,0111,04,01,0201,0100,0,
+    /* 39171 */ 0270,0111,0,01,0200,0110,0,
+    /* 39178 */ 0270,0111,0,01,0200,0100,0,
+    /* 39185 */ 0270,0111,04,01,0200,0110,0,
+    /* 39192 */ 0270,0111,04,01,0200,0100,0,
+    /* 39199 */ 0270,0111,0,01,0203,0110,0,
+    /* 39206 */ 0270,0111,0,01,0203,0100,0,
+    /* 39213 */ 0270,0111,0,01,0202,0110,0,
+    /* 39220 */ 0270,0111,0,01,0202,0100,0,
+    /* 39227 */ 0270,0111,0,01,0302,0110,0,
+    /* 39234 */ 0270,0111,0,01,0302,0100,0,
+    /* 39241 */ 0270,0111,0,01,0303,0110,0,
+    /* 39248 */ 0270,0111,0,01,0303,0100,0,
+    /* 39255 */ 0270,0111,0,01,0301,0110,0,
+    /* 39262 */ 0270,0111,0,01,0301,0100,0,
+    /* 39269 */ 0270,0111,0,01,0313,0110,0,
+    /* 39276 */ 0270,0111,0,01,0313,0100,0,
+    /* 39283 */ 0270,0111,0,01,0322,0110,0,
+    /* 39290 */ 0270,0111,0,01,0322,0100,0,
+    /* 39297 */ 0270,0111,0,01,0323,0110,0,
+    /* 39304 */ 0270,0111,0,01,0323,0100,0,
+    /* 39311 */ 0270,0111,0,01,0321,0110,0,
+    /* 39318 */ 0270,0111,0,01,0321,0100,0,
+    /* 39325 */ 0270,0111,0,01,0333,0110,0,
+    /* 39332 */ 0270,0111,0,01,0333,0100,0,
+    /* 39339 */ 0270,0111,0,01,0326,0110,0,
+    /* 39346 */ 0270,0111,0,01,0326,0100,0,
+    /* 39353 */ 0270,0111,0,01,0327,0110,0,
+    /* 39360 */ 0270,0111,0,01,0327,0100,0,
+    /* 39367 */ 0270,0111,0,01,0306,0110,0,
+    /* 39374 */ 0270,0111,0,01,0306,0100,0,
+    /* 39381 */ 0270,0111,0,01,0307,0110,0,
+    /* 39388 */ 0270,0111,0,01,0307,0100,0,
+    /* 39395 */ 0270,0111,0,01,0341,0110,0,
+    /* 39402 */ 0270,0111,0,01,0341,0100,0,
+    /* 39409 */ 0270,0111,0,01,0343,0110,0,
+    /* 39416 */ 0270,0111,0,01,0343,0100,0,
+    /* 39423 */ 0270,0111,0,01,0342,0110,0,
+    /* 39430 */ 0270,0111,0,01,0342,0100,0,
+    /* 39437 */ 0262,0111,0,01,0220,0110,0,
+    /* 39444 */ 0261,0111,0,01,0220,0100,0,
+    /* 39451 */ 0261,0111,020,01,0220,0120,0,
+    /* 39458 */ 0260,0111,020,01,0220,0110,0,
+    /* 39465 */ 0262,0111,0,01,0222,0110,0,
+    /* 39472 */ 0261,0111,0,01,0222,0100,0,
+    /* 39479 */ 0261,0111,020,01,0222,0120,0,
+    /* 39486 */ 0260,0111,020,01,0222,0110,0,
+    /* 39493 */ 0262,0111,0,01,0223,0110,0,
+    /* 39500 */ 0261,0111,0,01,0223,0100,0,
+    /* 39507 */ 0261,0111,020,01,0223,0120,0,
+    /* 39514 */ 0260,0111,020,01,0223,0110,0,
+    /* 39521 */ 0262,0111,0,01,0221,0110,0,
+    /* 39528 */ 0261,0111,0,01,0221,0100,0,
+    /* 39535 */ 0261,0111,020,01,0221,0120,0,
+    /* 39542 */ 0260,0111,020,01,0221,0110,0,
+    /* 39549 */ 0262,0111,0,01,0230,0110,0,
+    /* 39556 */ 0261,0111,0,01,0230,0100,0,
+    /* 39563 */ 0261,0111,020,01,0230,0120,0,
+    /* 39570 */ 0260,0111,020,01,0230,0110,0,
+    /* 39577 */ 0262,0111,0,01,0232,0110,0,
+    /* 39584 */ 0261,0111,0,01,0232,0100,0,
+    /* 39591 */ 0261,0111,020,01,0232,0120,0,
+    /* 39598 */ 0260,0111,020,01,0232,0110,0,
+    /* 39605 */ 0262,0111,0,01,0233,0110,0,
+    /* 39612 */ 0261,0111,0,01,0233,0100,0,
+    /* 39619 */ 0261,0111,020,01,0233,0120,0,
+    /* 39626 */ 0260,0111,020,01,0233,0110,0,
+    /* 39633 */ 0262,0111,0,01,0231,0110,0,
+    /* 39640 */ 0261,0111,0,01,0231,0100,0,
+    /* 39647 */ 0261,0111,020,01,0231,0120,0,
+    /* 39654 */ 0260,0111,020,01,0231,0110,0,
+    /* 39661 */ 0262,0111,0,01,0224,0110,0,
+    /* 39668 */ 0261,0111,0,01,0224,0100,0,
+    /* 39675 */ 0261,0111,020,01,0224,0120,0,
+    /* 39682 */ 0260,0111,020,01,0224,0110,0,
+    /* 39689 */ 0262,0111,0,01,0226,0110,0,
+    /* 39696 */ 0261,0111,0,01,0226,0100,0,
+    /* 39703 */ 0261,0111,020,01,0226,0120,0,
+    /* 39710 */ 0260,0111,020,01,0226,0110,0,
+    /* 39717 */ 0262,0111,0,01,0227,0110,0,
+    /* 39724 */ 0261,0111,0,01,0227,0100,0,
+    /* 39731 */ 0261,0111,020,01,0227,0120,0,
+    /* 39738 */ 0260,0111,020,01,0227,0110,0,
+    /* 39745 */ 0262,0111,0,01,0225,0110,0,
+    /* 39752 */ 0261,0111,0,01,0225,0100,0,
+    /* 39759 */ 0261,0111,020,01,0225,0120,0,
+    /* 39766 */ 0260,0111,020,01,0225,0110,0,
+    /* 39773 */ 0270,02,045,01,034,0110,0,
+    /* 39780 */ 0270,02,045,01,035,0110,0,
+    /* 39787 */ 0270,02,045,01,036,0110,0,
+    /* 39794 */ 0261,01,045,01,0143,0120,0,
+    /* 39801 */ 0260,01,045,01,0143,0110,0,
+    /* 39808 */ 0261,01,045,01,0153,0120,0,
+    /* 39815 */ 0260,01,045,01,0153,0110,0,
+    /* 39822 */ 0261,02,045,01,053,0120,0,
+    /* 39829 */ 0260,02,045,01,053,0110,0,
+    /* 39836 */ 0261,01,045,01,0147,0120,0,
+    /* 39843 */ 0260,01,045,01,0147,0110,0,
+    /* 39850 */ 0261,01,045,01,0374,0120,0,
+    /* 39857 */ 0260,01,045,01,0374,0110,0,
+    /* 39864 */ 0261,01,045,01,0375,0120,0,
+    /* 39871 */ 0260,01,045,01,0375,0110,0,
+    /* 39878 */ 0261,01,045,01,0376,0120,0,
+    /* 39885 */ 0260,01,045,01,0376,0110,0,
+    /* 39892 */ 0261,01,045,01,0324,0120,0,
+    /* 39899 */ 0260,01,045,01,0324,0110,0,
+    /* 39906 */ 0261,01,045,01,0354,0120,0,
+    /* 39913 */ 0260,01,045,01,0354,0110,0,
+    /* 39920 */ 0261,01,045,01,0355,0120,0,
+    /* 39927 */ 0260,01,045,01,0355,0110,0,
+    /* 39934 */ 0261,01,045,01,0334,0120,0,
+    /* 39941 */ 0260,01,045,01,0334,0110,0,
+    /* 39948 */ 0261,01,045,01,0335,0120,0,
+    /* 39955 */ 0260,01,045,01,0335,0110,0,
+    /* 39962 */ 0261,01,045,01,0333,0120,0,
+    /* 39969 */ 0260,01,045,01,0333,0110,0,
+    /* 39976 */ 0261,01,045,01,0337,0120,0,
+    /* 39983 */ 0260,01,045,01,0337,0110,0,
+    /* 39990 */ 0261,01,045,01,0340,0120,0,
+    /* 39997 */ 0260,01,045,01,0340,0110,0,
+    /* 40004 */ 0261,01,045,01,0343,0120,0,
+    /* 40011 */ 0260,01,045,01,0343,0110,0,
+    /* 40018 */ 0261,01,045,01,0164,0120,0,
+    /* 40025 */ 0260,01,045,01,0164,0110,0,
+    /* 40032 */ 0261,01,045,01,0165,0120,0,
+    /* 40039 */ 0260,01,045,01,0165,0110,0,
+    /* 40046 */ 0261,01,045,01,0166,0120,0,
+    /* 40053 */ 0260,01,045,01,0166,0110,0,
+    /* 40060 */ 0261,02,045,01,051,0120,0,
+    /* 40067 */ 0260,02,045,01,051,0110,0,
+    /* 40074 */ 0261,01,045,01,0144,0120,0,
+    /* 40081 */ 0260,01,045,01,0144,0110,0,
+    /* 40088 */ 0261,01,045,01,0145,0120,0,
+    /* 40095 */ 0260,01,045,01,0145,0110,0,
+    /* 40102 */ 0261,01,045,01,0146,0120,0,
+    /* 40109 */ 0260,01,045,01,0146,0110,0,
+    /* 40116 */ 0261,02,045,01,067,0120,0,
+    /* 40123 */ 0260,02,045,01,067,0110,0,
+    /* 40130 */ 0261,02,045,01,01,0120,0,
+    /* 40137 */ 0260,02,045,01,01,0110,0,
+    /* 40144 */ 0261,02,045,01,02,0120,0,
+    /* 40151 */ 0260,02,045,01,02,0110,0,
+    /* 40158 */ 0261,02,045,01,03,0120,0,
+    /* 40165 */ 0260,02,045,01,03,0110,0,
+    /* 40172 */ 0261,02,045,01,05,0120,0,
+    /* 40179 */ 0260,02,045,01,05,0110,0,
+    /* 40186 */ 0261,02,045,01,06,0120,0,
+    /* 40193 */ 0260,02,045,01,06,0110,0,
+    /* 40200 */ 0261,02,045,01,07,0120,0,
+    /* 40207 */ 0260,02,045,01,07,0110,0,
+    /* 40214 */ 0261,02,045,01,04,0120,0,
+    /* 40221 */ 0260,02,045,01,04,0110,0,
+    /* 40228 */ 0261,01,045,01,0365,0120,0,
+    /* 40235 */ 0260,01,045,01,0365,0110,0,
+    /* 40242 */ 0261,02,045,01,074,0120,0,
+    /* 40249 */ 0260,02,045,01,074,0110,0,
+    /* 40256 */ 0261,01,045,01,0356,0120,0,
+    /* 40263 */ 0260,01,045,01,0356,0110,0,
+    /* 40270 */ 0261,02,045,01,075,0120,0,
+    /* 40277 */ 0260,02,045,01,075,0110,0,
+    /* 40284 */ 0261,01,045,01,0336,0120,0,
+    /* 40291 */ 0260,01,045,01,0336,0110,0,
+    /* 40298 */ 0261,02,045,01,076,0120,0,
+    /* 40305 */ 0260,02,045,01,076,0110,0,
+    /* 40312 */ 0261,02,045,01,077,0120,0,
+    /* 40319 */ 0260,02,045,01,077,0110,0,
+    /* 40326 */ 0261,02,045,01,070,0120,0,
+    /* 40333 */ 0260,02,045,01,070,0110,0,
+    /* 40340 */ 0261,01,045,01,0352,0120,0,
+    /* 40347 */ 0260,01,045,01,0352,0110,0,
+    /* 40354 */ 0261,02,045,01,071,0120,0,
+    /* 40361 */ 0260,02,045,01,071,0110,0,
+    /* 40368 */ 0261,01,045,01,0332,0120,0,
+    /* 40375 */ 0260,01,045,01,0332,0110,0,
+    /* 40382 */ 0261,02,045,01,072,0120,0,
+    /* 40389 */ 0260,02,045,01,072,0110,0,
+    /* 40396 */ 0261,02,045,01,073,0120,0,
+    /* 40403 */ 0260,02,045,01,073,0110,0,
+    /* 40410 */ 0270,01,045,01,0327,0110,0,
+    /* 40417 */ 0270,02,045,01,040,0110,0,
+    /* 40424 */ 0270,02,045,01,041,0110,0,
+    /* 40431 */ 0270,02,045,01,042,0110,0,
+    /* 40438 */ 0270,02,045,01,043,0110,0,
+    /* 40445 */ 0270,02,045,01,044,0110,0,
+    /* 40452 */ 0270,02,045,01,045,0110,0,
+    /* 40459 */ 0270,02,045,01,060,0110,0,
+    /* 40466 */ 0270,02,045,01,061,0110,0,
+    /* 40473 */ 0270,02,045,01,062,0110,0,
+    /* 40480 */ 0270,02,045,01,063,0110,0,
+    /* 40487 */ 0270,02,045,01,064,0110,0,
+    /* 40494 */ 0270,02,045,01,065,0110,0,
+    /* 40501 */ 0261,02,045,01,050,0120,0,
+    /* 40508 */ 0260,02,045,01,050,0110,0,
+    /* 40515 */ 0261,02,045,01,013,0120,0,
+    /* 40522 */ 0260,02,045,01,013,0110,0,
+    /* 40529 */ 0261,01,045,01,0344,0120,0,
+    /* 40536 */ 0260,01,045,01,0344,0110,0,
+    /* 40543 */ 0261,01,045,01,0345,0120,0,
+    /* 40550 */ 0260,01,045,01,0345,0110,0,
+    /* 40557 */ 0261,01,045,01,0325,0120,0,
+    /* 40564 */ 0260,01,045,01,0325,0110,0,
+    /* 40571 */ 0261,02,045,01,0100,0120,0,
+    /* 40578 */ 0260,02,045,01,0100,0110,0,
+    /* 40585 */ 0261,01,045,01,0364,0120,0,
+    /* 40592 */ 0260,01,045,01,0364,0110,0,
+    /* 40599 */ 0261,01,045,01,0353,0120,0,
+    /* 40606 */ 0260,01,045,01,0353,0110,0,
+    /* 40613 */ 0261,01,045,01,0366,0120,0,
+    /* 40620 */ 0260,01,045,01,0366,0110,0,
+    /* 40627 */ 0261,02,045,01,0,0120,0,
+    /* 40634 */ 0260,02,045,01,0,0110,0,
+    /* 40641 */ 0261,02,045,01,010,0120,0,
+    /* 40648 */ 0260,02,045,01,010,0110,0,
+    /* 40655 */ 0261,02,045,01,011,0120,0,
+    /* 40662 */ 0260,02,045,01,011,0110,0,
+    /* 40669 */ 0261,02,045,01,012,0120,0,
+    /* 40676 */ 0260,02,045,01,012,0110,0,
+    /* 40683 */ 0261,01,045,01,0361,0120,0,
+    /* 40690 */ 0260,01,045,01,0361,0110,0,
+    /* 40697 */ 0261,01,045,01,0362,0120,0,
+    /* 40704 */ 0260,01,045,01,0362,0110,0,
+    /* 40711 */ 0261,01,045,01,0363,0120,0,
+    /* 40718 */ 0260,01,045,01,0363,0110,0,
+    /* 40725 */ 0261,01,045,01,0341,0120,0,
+    /* 40732 */ 0260,01,045,01,0341,0110,0,
+    /* 40739 */ 0261,01,045,01,0342,0120,0,
+    /* 40746 */ 0260,01,045,01,0342,0110,0,
+    /* 40753 */ 0261,01,045,01,0321,0120,0,
+    /* 40760 */ 0260,01,045,01,0321,0110,0,
+    /* 40767 */ 0261,01,045,01,0322,0120,0,
+    /* 40774 */ 0260,01,045,01,0322,0110,0,
+    /* 40781 */ 0261,01,045,01,0323,0120,0,
+    /* 40788 */ 0260,01,045,01,0323,0110,0,
+    /* 40795 */ 0261,01,045,01,0370,0120,0,
+    /* 40802 */ 0260,01,045,01,0370,0110,0,
+    /* 40809 */ 0261,01,045,01,0371,0120,0,
+    /* 40816 */ 0260,01,045,01,0371,0110,0,
+    /* 40823 */ 0261,01,045,01,0372,0120,0,
+    /* 40830 */ 0260,01,045,01,0372,0110,0,
+    /* 40837 */ 0261,01,045,01,0373,0120,0,
+    /* 40844 */ 0260,01,045,01,0373,0110,0,
+    /* 40851 */ 0261,01,045,01,0350,0120,0,
+    /* 40858 */ 0260,01,045,01,0350,0110,0,
+    /* 40865 */ 0261,01,045,01,0351,0120,0,
+    /* 40872 */ 0260,01,045,01,0351,0110,0,
+    /* 40879 */ 0261,01,045,01,0330,0120,0,
+    /* 40886 */ 0260,01,045,01,0330,0110,0,
+    /* 40893 */ 0261,01,045,01,0331,0120,0,
+    /* 40900 */ 0260,01,045,01,0331,0110,0,
+    /* 40907 */ 0261,01,045,01,0150,0120,0,
+    /* 40914 */ 0260,01,045,01,0150,0110,0,
+    /* 40921 */ 0261,01,045,01,0151,0120,0,
+    /* 40928 */ 0260,01,045,01,0151,0110,0,
+    /* 40935 */ 0261,01,045,01,0152,0120,0,
+    /* 40942 */ 0260,01,045,01,0152,0110,0,
+    /* 40949 */ 0261,01,045,01,0155,0120,0,
+    /* 40956 */ 0260,01,045,01,0155,0110,0,
+    /* 40963 */ 0261,01,045,01,0140,0120,0,
+    /* 40970 */ 0260,01,045,01,0140,0110,0,
+    /* 40977 */ 0261,01,045,01,0141,0120,0,
+    /* 40984 */ 0260,01,045,01,0141,0110,0,
+    /* 40991 */ 0261,01,045,01,0142,0120,0,
+    /* 40998 */ 0260,01,045,01,0142,0110,0,
+    /* 41005 */ 0261,01,045,01,0154,0120,0,
+    /* 41012 */ 0260,01,045,01,0154,0110,0,
+    /* 41019 */ 0261,01,045,01,0357,0120,0,
+    /* 41026 */ 0260,01,045,01,0357,0110,0,
+    /* 41033 */ 0270,02,045,01,052,0110,0,
+    /* 41040 */ 0270,02,05,01,0132,0110,0,
+    /* 41047 */ 0270,02,01,01,0170,0110,0,
+    /* 41054 */ 0270,02,05,01,0170,0110,0,
+    /* 41061 */ 0270,02,01,01,0171,0110,0,
+    /* 41068 */ 0270,02,05,01,0171,0110,0,
+    /* 41075 */ 0270,02,01,01,0130,0110,0,
+    /* 41082 */ 0270,02,05,01,0130,0110,0,
+    /* 41089 */ 0270,02,01,01,0131,0110,0,
+    /* 41096 */ 0270,02,05,01,0131,0110,0,
+    /* 41103 */ 0261,02,05,01,066,0120,0,
+    /* 41110 */ 0260,02,05,01,066,0110,0,
+    /* 41117 */ 0261,02,05,01,026,0120,0,
+    /* 41124 */ 0260,02,05,01,026,0110,0,
+    /* 41131 */ 0261,02,01,01,0214,0120,0,
+    /* 41138 */ 0260,02,01,01,0214,0110,0,
+    /* 41145 */ 0261,02,05,01,0214,0120,0,
+    /* 41152 */ 0260,02,05,01,0214,0110,0,
+    /* 41159 */ 0261,02,021,01,0214,0120,0,
+    /* 41166 */ 0260,02,021,01,0214,0110,0,
+    /* 41173 */ 0261,02,025,01,0214,0120,0,
+    /* 41180 */ 0260,02,025,01,0214,0110,0,
+    /* 41187 */ 0261,02,01,01,0216,0102,0,
+    /* 41194 */ 0260,02,01,01,0216,0101,0,
+    /* 41201 */ 0261,02,05,01,0216,0102,0,
+    /* 41208 */ 0260,02,05,01,0216,0101,0,
+    /* 41215 */ 0261,02,021,01,0216,0102,0,
+    /* 41222 */ 0260,02,021,01,0216,0101,0,
+    /* 41229 */ 0261,02,025,01,0216,0102,0,
+    /* 41236 */ 0260,02,025,01,0216,0101,0,
+    /* 41243 */ 0261,02,01,01,0107,0120,0,
+    /* 41250 */ 0260,02,01,01,0107,0110,0,
+    /* 41257 */ 0261,02,021,01,0107,0120,0,
+    /* 41264 */ 0260,02,021,01,0107,0110,0,
+    /* 41271 */ 0261,02,05,01,0107,0120,0,
+    /* 41278 */ 0260,02,05,01,0107,0110,0,
+    /* 41285 */ 0261,02,025,01,0107,0120,0,
+    /* 41292 */ 0260,02,025,01,0107,0110,0,
+    /* 41299 */ 0261,02,01,01,0106,0120,0,
+    /* 41306 */ 0260,02,01,01,0106,0110,0,
+    /* 41313 */ 0261,02,05,01,0106,0120,0,
+    /* 41320 */ 0260,02,05,01,0106,0110,0,
+    /* 41327 */ 0261,02,01,01,0105,0120,0,
+    /* 41334 */ 0260,02,01,01,0105,0110,0,
+    /* 41341 */ 0261,02,021,01,0105,0120,0,
+    /* 41348 */ 0260,02,021,01,0105,0110,0,
+    /* 41355 */ 0261,02,05,01,0105,0120,0,
+    /* 41362 */ 0260,02,05,01,0105,0110,0,
+    /* 41369 */ 0261,02,025,01,0105,0120,0,
+    /* 41376 */ 0260,02,025,01,0105,0110,0,
+    /* 41383 */ 0261,02,0,01,0362,0120,0,
+    /* 41390 */ 0261,02,020,01,0362,0120,0,
+    /* 41397 */ 0262,02,0,01,0367,0110,0,
+    /* 41404 */ 0262,02,020,01,0367,0110,0,
+    /* 41411 */ 0260,0111,0,01,02,0216,0,
+    /* 41418 */ 0260,0111,020,01,02,0216,0,
+    /* 41425 */ 0260,0111,0,01,01,0215,0,
+    /* 41432 */ 0260,0111,020,01,01,0215,0,
+    /* 41439 */ 0260,02,0,01,0363,0213,0,
+    /* 41446 */ 0260,02,020,01,0363,0213,0,
+    /* 41453 */ 0260,0111,0,01,01,0216,0,
+    /* 41460 */ 0260,0111,020,01,01,0216,0,
+    /* 41467 */ 0260,0111,0,01,01,0211,0,
+    /* 41474 */ 0260,0111,020,01,01,0211,0,
+    /* 41481 */ 0260,0111,0,01,01,0212,0,
+    /* 41488 */ 0260,0111,020,01,01,0212,0,
+    /* 41495 */ 0260,0111,0,01,02,0211,0,
+    /* 41502 */ 0260,0111,020,01,02,0211,0,
+    /* 41509 */ 0260,02,0,01,0363,0212,0,
+    /* 41516 */ 0260,02,020,01,0363,0212,0,
+    /* 41523 */ 0260,02,0,01,0363,0211,0,
+    /* 41530 */ 0260,02,020,01,0363,0211,0,
+    /* 41537 */ 0260,0111,0,01,01,0213,0,
+    /* 41544 */ 0260,0111,020,01,01,0213,0,
+    /* 41551 */ 0262,02,0,01,0365,0110,0,
+    /* 41558 */ 0262,02,020,01,0365,0110,0,
+    /* 41565 */ 0261,02,03,01,0366,0120,0,
+    /* 41572 */ 0261,02,023,01,0366,0120,0,
+    /* 41579 */ 0261,02,03,01,0365,0120,0,
+    /* 41586 */ 0261,02,023,01,0365,0120,0,
+    /* 41593 */ 0261,02,02,01,0365,0120,0,
+    /* 41600 */ 0261,02,022,01,0365,0120,0,
+    /* 41607 */ 0262,02,02,01,0367,0110,0,
+    /* 41614 */ 0262,02,022,01,0367,0110,0,
+    /* 41621 */ 0262,02,01,01,0367,0110,0,
+    /* 41628 */ 0262,02,021,01,0367,0110,0,
+    /* 41635 */ 0262,02,03,01,0367,0110,0,
+    /* 41642 */ 0262,02,023,01,0367,0110,0,
+    /* 41649 */ 0320,0333,02,017,0274,0110,0,
+    /* 41656 */ 0321,0333,02,017,0274,0110,0,
+    /* 41663 */ 0324,0333,02,017,0274,0110,0,
+    /* 41670 */ 0260,0111,0,01,01,0214,0,
+    /* 41677 */ 0260,0111,020,01,01,0214,0,
+    /* 41684 */ 0260,0111,0,01,01,0217,0,
+    /* 41691 */ 0260,0111,020,01,01,0217,0,
+    /* 41698 */ 0323,0333,02,017,032,0110,0,
+    /* 41705 */ 0323,0332,02,017,032,0110,0,
+    /* 41712 */ 0323,0332,02,017,033,0110,0,
+    /* 41719 */ 03,017,072,0314,0110,022,0,
+    /* 41726 */ 0270,02,02,01,0261,0110,0,
+    /* 41733 */ 0270,02,06,01,0261,0110,0,
+    /* 41740 */ 0270,02,01,01,0261,0110,0,
+    /* 41747 */ 0270,02,05,01,0261,0110,0,
+    /* 41754 */ 0270,02,02,01,0260,0110,0,
+    /* 41761 */ 0270,02,06,01,0260,0110,0,
+    /* 41768 */ 0270,02,01,01,0260,0110,0,
+    /* 41775 */ 0270,02,05,01,0260,0110,0,
+    /* 41782 */ 0270,02,03,01,0260,0110,0,
+    /* 41789 */ 0270,02,07,01,0260,0110,0,
+    /* 41796 */ 0270,02,0,01,0260,0110,0,
+    /* 41803 */ 0270,02,04,01,0260,0110,0,
+    /* 41810 */ 0270,02,02,01,0162,0110,0,
+    /* 41817 */ 0270,02,06,01,0162,0110,0,
+    /* 41824 */ 0261,02,03,01,0120,0120,0,
+    /* 41831 */ 0261,02,07,01,0120,0120,0,
+    /* 41838 */ 0261,02,03,01,0121,0120,0,
+    /* 41845 */ 0261,02,07,01,0121,0120,0,
+    /* 41852 */ 0261,02,02,01,0120,0120,0,
+    /* 41859 */ 0261,02,06,01,0120,0120,0,
+    /* 41866 */ 0261,02,02,01,0121,0120,0,
+    /* 41873 */ 0261,02,06,01,0121,0120,0,
+    /* 41880 */ 0261,02,0,01,0120,0120,0,
+    /* 41887 */ 0261,02,04,01,0120,0120,0,
+    /* 41894 */ 0261,02,0,01,0121,0120,0,
+    /* 41901 */ 0261,02,04,01,0121,0120,0,
+    /* 41908 */ 0261,02,021,01,0265,0120,0,
+    /* 41915 */ 0261,02,025,01,0265,0120,0,
+    /* 41922 */ 0261,02,021,01,0264,0120,0,
+    /* 41929 */ 0261,02,025,01,0264,0120,0,
+    /* 41936 */ 0261,01,05,01,0112,0120,0,
+    /* 41943 */ 0261,01,025,01,0112,0120,0,
+    /* 41950 */ 0261,01,024,01,0112,0120,0,
+    /* 41957 */ 0261,01,04,01,0112,0120,0,
+    /* 41964 */ 0261,01,05,01,0101,0120,0,
+    /* 41971 */ 0261,01,025,01,0101,0120,0,
+    /* 41978 */ 0261,01,05,01,0102,0120,0,
+    /* 41985 */ 0261,01,025,01,0102,0120,0,
+    /* 41992 */ 0261,01,024,01,0102,0120,0,
+    /* 41999 */ 0261,01,04,01,0102,0120,0,
+    /* 42006 */ 0261,01,024,01,0101,0120,0,
+    /* 42013 */ 0261,01,04,01,0101,0120,0,
+    /* 42020 */ 0270,01,01,01,0220,0110,0,
+    /* 42027 */ 0270,01,01,01,0221,0101,0,
+    /* 42034 */ 0270,01,01,01,0222,0110,0,
+    /* 42041 */ 0270,01,01,01,0223,0110,0,
+    /* 42048 */ 0270,01,021,01,0220,0110,0,
+    /* 42055 */ 0270,01,021,01,0221,0101,0,
+    /* 42062 */ 0270,01,03,01,0222,0110,0,
+    /* 42069 */ 0270,01,03,01,0223,0110,0,
+    /* 42076 */ 0270,01,020,01,0220,0110,0,
+    /* 42083 */ 0270,01,020,01,0221,0101,0,
+    /* 42090 */ 0270,01,023,01,0222,0110,0,
+    /* 42097 */ 0270,01,023,01,0223,0110,0,
+    /* 42104 */ 0270,01,0,01,0220,0110,0,
+    /* 42111 */ 0270,01,0,01,0221,0101,0,
+    /* 42118 */ 0270,01,0,01,0222,0110,0,
+    /* 42125 */ 0270,01,0,01,0223,0110,0,
+    /* 42132 */ 0270,01,01,01,0104,0110,0,
+    /* 42139 */ 0270,01,021,01,0104,0110,0,
+    /* 42146 */ 0270,01,020,01,0104,0110,0,
+    /* 42153 */ 0270,01,0,01,0104,0110,0,
+    /* 42160 */ 0261,01,05,01,0105,0120,0,
+    /* 42167 */ 0261,01,025,01,0105,0120,0,
+    /* 42174 */ 0261,01,024,01,0105,0120,0,
+    /* 42181 */ 0261,01,04,01,0105,0120,0,
+    /* 42188 */ 0270,01,01,01,0230,0110,0,
+    /* 42195 */ 0270,01,021,01,0230,0110,0,
+    /* 42202 */ 0270,01,020,01,0230,0110,0,
+    /* 42209 */ 0270,01,0,01,0230,0110,0,
+    /* 42216 */ 0270,01,01,01,0231,0110,0,
+    /* 42223 */ 0270,01,021,01,0231,0110,0,
+    /* 42230 */ 0270,01,020,01,0231,0110,0,
+    /* 42237 */ 0270,01,0,01,0231,0110,0,
+    /* 42244 */ 0261,01,05,01,0113,0120,0,
+    /* 42251 */ 0261,01,024,01,0113,0120,0,
+    /* 42258 */ 0261,01,04,01,0113,0120,0,
+    /* 42265 */ 0261,01,05,01,0106,0120,0,
+    /* 42272 */ 0261,01,025,01,0106,0120,0,
+    /* 42279 */ 0261,01,024,01,0106,0120,0,
+    /* 42286 */ 0261,01,04,01,0106,0120,0,
+    /* 42293 */ 0261,01,05,01,0107,0120,0,
+    /* 42300 */ 0261,01,025,01,0107,0120,0,
+    /* 42307 */ 0261,01,024,01,0107,0120,0,
+    /* 42314 */ 0261,01,04,01,0107,0120,0,
+    /* 42321 */ 0323,0333,02,017,0307,0207,0,
+    /* 42328 */ 0360,03,017,070,0371,0101,0,
+    /* 42335 */ 0324,03,017,070,0371,0101,0,
+    /* 42342 */ 0310,0333,02,017,0256,0206,0,
+    /* 42349 */ 0311,0333,02,017,0256,0206,0,
+    /* 42356 */ 0361,03,017,070,0317,0110,0,
+    /* 42363 */ 0261,02,01,01,0317,0120,0,
+    /* 42370 */ 0260,02,01,01,0317,0110,0,
+    /* 42377 */ 0261,02,05,01,0317,0120,0,
+    /* 42384 */ 0260,02,05,01,0317,0110,0,
+    /* 42391 */ 0321,0333,02,017,0256,0205,0,
+    /* 42398 */ 0324,0333,02,017,0256,0205,0,
+    /* 42405 */ 0321,0333,02,017,036,0201,0,
+    /* 42412 */ 0324,0333,02,017,036,0201,0,
+    /* 42419 */ 0321,03,017,070,0366,0101,0,
+    /* 42426 */ 0324,03,017,070,0366,0101,0,
+    /* 42433 */ 0270,02,0,01,0111,0200,0,
+    /* 42440 */ 0270,02,01,01,0111,0200,0,
+    /* 42447 */ 0262,02,02,01,0134,0110,0,
+    /* 42454 */ 0262,02,03,01,0136,0110,0,
+    /* 42461 */ 0262,02,02,01,0136,0110,0,
+    /* 42468 */ 0262,02,01,01,0136,0110,0,
+    /* 42475 */ 0262,02,0,01,0136,0110,0,
+    /* 42482 */ 0270,02,03,01,0113,0110,0,
+    /* 42489 */ 0270,02,01,01,0113,0110,0,
+    /* 42496 */ 0270,02,0,02,0111,0300,0,
+    /* 42503 */ 0270,02,02,01,0113,0101,0,
+    /* 42510 */ 0323,0333,02,017,0307,0206,0,
+    /* 42517 */ 0262,02,01,01,0347,0101,0,
+    /* 42524 */ 0262,02,01,01,0343,0101,0,
+    /* 42531 */ 0262,02,01,01,0342,0101,0,
+    /* 42538 */ 0262,02,01,01,0346,0101,0,
+    /* 42545 */ 0262,02,01,01,0344,0101,0,
+    /* 42552 */ 0262,02,01,01,0357,0101,0,
+    /* 42559 */ 0262,02,01,01,0355,0101,0,
+    /* 42566 */ 0262,02,01,01,0354,0101,0,
+    /* 42573 */ 0262,02,01,01,0356,0101,0,
+    /* 42580 */ 0262,02,01,01,0345,0101,0,
+    /* 42587 */ 0262,02,01,01,0341,0101,0,
+    /* 42594 */ 0262,02,01,01,0353,0101,0,
+    /* 42601 */ 0262,02,01,01,0351,0101,0,
+    /* 42608 */ 0262,02,01,01,0340,0101,0,
+    /* 42615 */ 0262,02,01,01,0352,0101,0,
+    /* 42622 */ 0262,02,01,01,0350,0101,0,
+    /* 42629 */ 0262,02,021,01,0347,0101,0,
+    /* 42636 */ 0262,02,021,01,0343,0101,0,
+    /* 42643 */ 0262,02,021,01,0342,0101,0,
+    /* 42650 */ 0262,02,021,01,0346,0101,0,
+    /* 42657 */ 0262,02,021,01,0344,0101,0,
+    /* 42664 */ 0262,02,021,01,0357,0101,0,
+    /* 42671 */ 0262,02,021,01,0355,0101,0,
+    /* 42678 */ 0262,02,021,01,0354,0101,0,
+    /* 42685 */ 0262,02,021,01,0356,0101,0,
+    /* 42692 */ 0262,02,021,01,0345,0101,0,
+    /* 42699 */ 0262,02,021,01,0341,0101,0,
+    /* 42706 */ 0262,02,021,01,0353,0101,0,
+    /* 42713 */ 0262,02,021,01,0351,0101,0,
+    /* 42720 */ 0262,02,021,01,0340,0101,0,
+    /* 42727 */ 0262,02,021,01,0352,0101,0,
+    /* 42734 */ 0262,02,021,01,0350,0101,0,
+    /* 42741 */ 0273,0320,01,021,0101,0,
+    /* 42747 */ 0273,0321,01,021,0101,0,
+    /* 42753 */ 0273,0324,01,021,0101,0,
+    /* 42759 */ 0273,01,0200,0202,021,0,
+    /* 42765 */ 0273,01,0202,0202,021,0,
+    /* 42771 */ 0273,0320,01,01,0101,0,
+    /* 42777 */ 0273,0321,01,01,0101,0,
+    /* 42783 */ 0273,0324,01,01,0101,0,
+    /* 42789 */ 0273,01,0200,0200,021,0,
+    /* 42795 */ 0273,01,0202,0200,021,0,
+    /* 42801 */ 0273,0320,01,041,0101,0,
+    /* 42807 */ 0273,0321,01,041,0101,0,
+    /* 42813 */ 0273,0324,01,041,0101,0,
+    /* 42819 */ 0273,01,0200,0204,021,0,
+    /* 42825 */ 0273,01,0202,0204,021,0,
+    /* 42831 */ 0321,01,017,010,0310,0,
+    /* 42837 */ 0324,01,017,010,0310,0,
+    /* 42843 */ 0320,02,017,0243,0101,0,
+    /* 42849 */ 0321,02,017,0243,0101,0,
+    /* 42855 */ 0324,02,017,0243,0101,0,
+    /* 42861 */ 0322,01,0232,034,074,0,
+    /* 42867 */ 0320,01,0232,034,074,0,
+    /* 42873 */ 0321,01,0232,034,074,0,
+    /* 42879 */ 0322,01,0232,035,030,0,
+    /* 42885 */ 0320,01,0232,031,030,0,
+    /* 42891 */ 0321,01,0232,041,030,0,
+    /* 42897 */ 0320,01,0203,0207,0275,0,
+    /* 42903 */ 0321,01,0203,0207,0275,0,
+    /* 42909 */ 0324,01,0203,0207,0275,0,
+    /* 42915 */ 0320,01,0201,0207,031,0,
+    /* 42921 */ 0321,01,0201,0207,041,0,
+    /* 42927 */ 0324,01,0201,0207,0255,0,
+    /* 42933 */ 0273,02,017,0260,0101,0,
+    /* 42939 */ 0320,02,017,0247,0101,0,
+    /* 42945 */ 0321,02,017,0247,0101,0,
+    /* 42951 */ 0324,02,017,0307,0201,0,
+    /* 42957 */ 0273,0320,01,0377,0201,0,
+    /* 42963 */ 0273,0321,01,0377,0201,0,
+    /* 42969 */ 0273,0324,01,0377,0201,0,
+    /* 42975 */ 0320,02,017,0257,0110,0,
+    /* 42981 */ 0321,02,017,0257,0110,0,
+    /* 42987 */ 0324,02,017,0257,0110,0,
+    /* 42993 */ 0320,01,0153,0110,0276,0,
+    /* 42999 */ 0320,01,0151,0110,032,0,
+    /* 43005 */ 0321,01,0153,0110,0276,0,
+    /* 43011 */ 0321,01,0151,0110,042,0,
+    /* 43017 */ 0324,01,0153,0110,0276,0,
+    /* 43023 */ 0324,01,0151,0110,042,0,
+    /* 43029 */ 0324,01,0151,0110,0256,0,
+    /* 43035 */ 0320,01,0153,0100,0275,0,
+    /* 43041 */ 0320,01,0151,0100,031,0,
+    /* 43047 */ 0321,01,0153,0100,0275,0,
+    /* 43053 */ 0321,01,0151,0100,041,0,
+    /* 43059 */ 0324,01,0153,0100,0275,0,
+    /* 43065 */ 0324,01,0151,0100,0255,0,
+    /* 43071 */ 0273,0320,01,0377,0200,0,
+    /* 43077 */ 0273,0321,01,0377,0200,0,
+    /* 43083 */ 0273,0324,01,0377,0200,0,
+    /* 43089 */ 0310,03,017,01,0337,0,
+    /* 43095 */ 0311,03,017,01,0337,0,
+    /* 43101 */ 0323,0313,01,0343,050,0,
+    /* 43107 */ 0322,01,0352,034,074,0,
+    /* 43113 */ 0320,01,0352,034,074,0,
+    /* 43119 */ 0321,01,0352,034,074,0,
+    /* 43125 */ 0322,01,0352,035,030,0,
+    /* 43131 */ 0320,01,0352,031,030,0,
+    /* 43137 */ 0321,01,0352,041,030,0,
+    /* 43143 */ 0322,02,017,0270,064,0,
+    /* 43149 */ 0320,02,017,0270,064,0,
+    /* 43155 */ 0321,02,017,0270,064,0,
+    /* 43161 */ 0320,02,017,0,0206,0,
+    /* 43167 */ 0321,02,017,0,0206,0,
+    /* 43173 */ 0320,02,017,02,0110,0,
+    /* 43179 */ 0321,02,017,02,0110,0,
+    /* 43185 */ 0324,02,017,02,0110,0,
+    /* 43191 */ 0360,03,017,0256,0350,0,
+    /* 43197 */ 0320,02,017,0264,0110,0,
+    /* 43203 */ 0321,02,017,0264,0110,0,
+    /* 43209 */ 0324,02,017,0264,0110,0,
+    /* 43215 */ 0320,02,017,0265,0110,0,
+    /* 43221 */ 0321,02,017,0265,0110,0,
+    /* 43227 */ 0324,02,017,0265,0110,0,
+    /* 43233 */ 0320,02,017,03,0110,0,
+    /* 43239 */ 0321,02,017,03,0110,0,
+    /* 43245 */ 0324,02,017,03,0110,0,
+    /* 43251 */ 0320,02,017,0262,0110,0,
+    /* 43257 */ 0321,02,017,0262,0110,0,
+    /* 43263 */ 0324,02,017,0262,0110,0,
+    /* 43269 */ 0360,03,017,0256,0360,0,
+    /* 43275 */ 0334,02,017,040,0101,0,
+    /* 43281 */ 0323,02,017,040,0101,0,
+    /* 43287 */ 0334,02,017,042,0110,0,
+    /* 43293 */ 0323,02,017,042,0110,0,
+    /* 43299 */ 0323,02,017,041,0101,0,
+    /* 43305 */ 0323,02,017,043,0110,0,
+    /* 43311 */ 0271,0320,01,0211,0101,0,
+    /* 43317 */ 0271,0321,01,0211,0101,0,
+    /* 43323 */ 0271,0324,01,0211,0101,0,
+    /* 43329 */ 0271,01,0306,0200,021,0,
+    /* 43335 */ 0360,02,017,0156,0110,0,
+    /* 43341 */ 0360,02,017,0176,0101,0,
+    /* 43347 */ 0360,02,017,0157,0110,0,
+    /* 43353 */ 0360,02,017,0177,0101,0,
+    /* 43359 */ 0320,02,017,0276,0110,0,
+    /* 43365 */ 0321,02,017,0276,0110,0,
+    /* 43371 */ 0321,02,017,0277,0110,0,
+    /* 43377 */ 0324,02,017,0276,0110,0,
+    /* 43383 */ 0324,02,017,0277,0110,0,
+    /* 43389 */ 0320,02,017,0266,0110,0,
+    /* 43395 */ 0321,02,017,0266,0110,0,
+    /* 43401 */ 0321,02,017,0267,0110,0,
+    /* 43407 */ 0324,02,017,0266,0110,0,
+    /* 43413 */ 0324,02,017,0267,0110,0,
+    /* 43419 */ 0273,0320,01,0367,0203,0,
+    /* 43425 */ 0273,0321,01,0367,0203,0,
+    /* 43431 */ 0273,0324,01,0367,0203,0,
+    /* 43437 */ 0320,02,017,037,0200,0,
+    /* 43443 */ 0321,02,017,037,0200,0,
+    /* 43449 */ 0324,02,017,037,0200,0,
+    /* 43455 */ 0273,0320,01,0367,0202,0,
+    /* 43461 */ 0273,0321,01,0367,0202,0,
+    /* 43467 */ 0273,0324,01,0367,0202,0,
+    /* 43473 */ 0273,0320,01,011,0101,0,
+    /* 43479 */ 0273,0321,01,011,0101,0,
+    /* 43485 */ 0273,0324,01,011,0101,0,
+    /* 43491 */ 0273,01,0200,0201,021,0,
+    /* 43497 */ 0273,01,0202,0201,021,0,
+    /* 43503 */ 0323,02,017,0121,0110,0,
+    /* 43509 */ 0323,02,017,0120,0110,0,
+    /* 43515 */ 0323,02,017,0122,0110,0,
+    /* 43521 */ 0323,02,017,0135,0110,0,
+    /* 43527 */ 0323,02,017,0131,0110,0,
+    /* 43533 */ 0323,02,017,0125,0110,0,
+    /* 43539 */ 0320,01,0301,0202,025,0,
+    /* 43545 */ 0321,01,0301,0202,025,0,
+    /* 43551 */ 0324,01,0301,0202,025,0,
+    /* 43557 */ 0320,01,0301,0203,025,0,
+    /* 43563 */ 0321,01,0301,0203,025,0,
+    /* 43569 */ 0324,01,0301,0203,025,0,
+    /* 43575 */ 0321,02,017,066,0200,0,
+    /* 43581 */ 0320,01,0301,0200,025,0,
+    /* 43587 */ 0321,01,0301,0200,025,0,
+    /* 43593 */ 0324,01,0301,0200,025,0,
+    /* 43599 */ 0320,01,0301,0201,025,0,
+    /* 43605 */ 0321,01,0301,0201,025,0,
+    /* 43611 */ 0324,01,0301,0201,025,0,
+    /* 43617 */ 0320,01,0301,0204,025,0,
+    /* 43623 */ 0321,01,0301,0204,025,0,
+    /* 43629 */ 0324,01,0301,0204,025,0,
+    /* 43635 */ 0320,01,0301,0207,025,0,
+    /* 43641 */ 0321,01,0301,0207,025,0,
+    /* 43647 */ 0324,01,0301,0207,025,0,
+    /* 43653 */ 0273,0320,01,031,0101,0,
+    /* 43659 */ 0273,0321,01,031,0101,0,
+    /* 43665 */ 0273,0324,01,031,0101,0,
+    /* 43671 */ 0273,01,0200,0203,021,0,
+    /* 43677 */ 0273,01,0202,0203,021,0,
+    /* 43683 */ 0360,03,017,0256,0370,0,
+    /* 43689 */ 0320,02,017,0245,0101,0,
+    /* 43695 */ 0321,02,017,0245,0101,0,
+    /* 43701 */ 0324,02,017,0245,0101,0,
+    /* 43707 */ 0320,01,0301,0205,025,0,
+    /* 43713 */ 0321,01,0301,0205,025,0,
+    /* 43719 */ 0324,01,0301,0205,025,0,
+    /* 43725 */ 0320,02,017,0255,0101,0,
+    /* 43731 */ 0321,02,017,0255,0101,0,
+    /* 43737 */ 0324,02,017,0255,0101,0,
+    /* 43743 */ 0320,02,017,0,0200,0,
+    /* 43749 */ 0321,02,017,0,0200,0,
+    /* 43755 */ 0323,02,017,0,0200,0,
+    /* 43761 */ 0324,02,017,0,0200,0,
+    /* 43767 */ 0320,02,017,01,0204,0,
+    /* 43773 */ 0321,02,017,01,0204,0,
+    /* 43779 */ 0324,02,017,01,0204,0,
+    /* 43785 */ 0320,02,017,0,0201,0,
+    /* 43791 */ 0321,02,017,0,0201,0,
+    /* 43797 */ 0324,02,017,0,0201,0,
+    /* 43803 */ 0273,0320,01,051,0101,0,
+    /* 43809 */ 0273,0321,01,051,0101,0,
+    /* 43815 */ 0273,0324,01,051,0101,0,
+    /* 43821 */ 0273,01,0200,0205,021,0,
+    /* 43827 */ 0273,01,0202,0205,021,0,
+    /* 43833 */ 0320,01,0367,0200,031,0,
+    /* 43839 */ 0321,01,0367,0200,041,0,
+    /* 43845 */ 0324,01,0367,0200,0255,0,
+    /* 43851 */ 0320,02,017,0377,0110,0,
+    /* 43857 */ 0321,02,017,0377,0110,0,
+    /* 43863 */ 0324,02,017,0377,0110,0,
+    /* 43869 */ 0320,02,017,0271,0110,0,
+    /* 43875 */ 0321,02,017,0271,0110,0,
+    /* 43881 */ 0324,02,017,0271,0110,0,
+    /* 43887 */ 0360,02,017,020,0101,0,
+    /* 43893 */ 0360,02,017,022,0110,0,
+    /* 43899 */ 0321,02,017,067,0200,0,
+    /* 43905 */ 0273,02,017,0300,0101,0,
+    /* 43911 */ 0320,02,017,0246,0110,0,
+    /* 43917 */ 0321,02,017,0246,0110,0,
+    /* 43923 */ 0272,0320,01,0207,0110,0,
+    /* 43929 */ 0272,0321,01,0207,0110,0,
+    /* 43935 */ 0272,0324,01,0207,0110,0,
+    /* 43941 */ 0272,0320,01,0207,0101,0,
+    /* 43947 */ 0272,0321,01,0207,0101,0,
+    /* 43953 */ 0272,0324,01,0207,0101,0,
+    /* 43959 */ 0273,0320,01,061,0101,0,
+    /* 43965 */ 0273,0321,01,061,0101,0,
+    /* 43971 */ 0273,0324,01,061,0101,0,
+    /* 43977 */ 0273,01,0200,0206,021,0,
+    /* 43983 */ 0273,01,0202,0206,021,0,
+    /* 43989 */ 0320,02,017,0107,0110,0,
+    /* 43995 */ 0320,02,017,0103,0110,0,
+    /* 44001 */ 0320,02,017,0102,0110,0,
+    /* 44007 */ 0320,02,017,0106,0110,0,
+    /* 44013 */ 0320,02,017,0104,0110,0,
+    /* 44019 */ 0320,02,017,0117,0110,0,
+    /* 44025 */ 0320,02,017,0115,0110,0,
+    /* 44031 */ 0320,02,017,0114,0110,0,
+    /* 44037 */ 0320,02,017,0116,0110,0,
+    /* 44043 */ 0320,02,017,0105,0110,0,
+    /* 44049 */ 0320,02,017,0101,0110,0,
+    /* 44055 */ 0320,02,017,0113,0110,0,
+    /* 44061 */ 0320,02,017,0111,0110,0,
+    /* 44067 */ 0320,02,017,0100,0110,0,
+    /* 44073 */ 0320,02,017,0112,0110,0,
+    /* 44079 */ 0320,02,017,0110,0110,0,
+    /* 44085 */ 0321,02,017,0107,0110,0,
+    /* 44091 */ 0321,02,017,0103,0110,0,
+    /* 44097 */ 0321,02,017,0102,0110,0,
+    /* 44103 */ 0321,02,017,0106,0110,0,
+    /* 44109 */ 0321,02,017,0104,0110,0,
+    /* 44115 */ 0321,02,017,0117,0110,0,
+    /* 44121 */ 0321,02,017,0115,0110,0,
+    /* 44127 */ 0321,02,017,0114,0110,0,
+    /* 44133 */ 0321,02,017,0116,0110,0,
+    /* 44139 */ 0321,02,017,0105,0110,0,
+    /* 44145 */ 0321,02,017,0101,0110,0,
+    /* 44151 */ 0321,02,017,0113,0110,0,
+    /* 44157 */ 0321,02,017,0111,0110,0,
+    /* 44163 */ 0321,02,017,0100,0110,0,
+    /* 44169 */ 0321,02,017,0112,0110,0,
+    /* 44175 */ 0321,02,017,0110,0110,0,
+    /* 44181 */ 0324,02,017,0107,0110,0,
+    /* 44187 */ 0324,02,017,0103,0110,0,
+    /* 44193 */ 0324,02,017,0102,0110,0,
+    /* 44199 */ 0324,02,017,0106,0110,0,
+    /* 44205 */ 0324,02,017,0104,0110,0,
+    /* 44211 */ 0324,02,017,0117,0110,0,
+    /* 44217 */ 0324,02,017,0115,0110,0,
+    /* 44223 */ 0324,02,017,0114,0110,0,
+    /* 44229 */ 0324,02,017,0116,0110,0,
+    /* 44235 */ 0324,02,017,0105,0110,0,
+    /* 44241 */ 0324,02,017,0101,0110,0,
+    /* 44247 */ 0324,02,017,0113,0110,0,
+    /* 44253 */ 0324,02,017,0111,0110,0,
+    /* 44259 */ 0324,02,017,0100,0110,0,
+    /* 44265 */ 0324,02,017,0112,0110,0,
+    /* 44271 */ 0324,02,017,0110,0110,0,
+    /* 44277 */ 0322,02,017,0207,064,0,
+    /* 44283 */ 0322,02,017,0203,064,0,
+    /* 44289 */ 0322,02,017,0202,064,0,
+    /* 44295 */ 0322,02,017,0206,064,0,
+    /* 44301 */ 0322,02,017,0204,064,0,
+    /* 44307 */ 0322,02,017,0217,064,0,
+    /* 44313 */ 0322,02,017,0215,064,0,
+    /* 44319 */ 0322,02,017,0214,064,0,
+    /* 44325 */ 0322,02,017,0216,064,0,
+    /* 44331 */ 0322,02,017,0205,064,0,
+    /* 44337 */ 0322,02,017,0201,064,0,
+    /* 44343 */ 0322,02,017,0213,064,0,
+    /* 44349 */ 0322,02,017,0211,064,0,
+    /* 44355 */ 0322,02,017,0200,064,0,
+    /* 44361 */ 0322,02,017,0212,064,0,
+    /* 44367 */ 0322,02,017,0210,064,0,
+    /* 44373 */ 0320,02,017,0207,064,0,
+    /* 44379 */ 0320,02,017,0203,064,0,
+    /* 44385 */ 0320,02,017,0202,064,0,
+    /* 44391 */ 0320,02,017,0206,064,0,
+    /* 44397 */ 0320,02,017,0204,064,0,
+    /* 44403 */ 0320,02,017,0217,064,0,
+    /* 44409 */ 0320,02,017,0215,064,0,
+    /* 44415 */ 0320,02,017,0214,064,0,
+    /* 44421 */ 0320,02,017,0216,064,0,
+    /* 44427 */ 0320,02,017,0205,064,0,
+    /* 44433 */ 0320,02,017,0201,064,0,
+    /* 44439 */ 0320,02,017,0213,064,0,
+    /* 44445 */ 0320,02,017,0211,064,0,
+    /* 44451 */ 0320,02,017,0200,064,0,
+    /* 44457 */ 0320,02,017,0212,064,0,
+    /* 44463 */ 0320,02,017,0210,064,0,
+    /* 44469 */ 0321,02,017,0207,064,0,
+    /* 44475 */ 0321,02,017,0203,064,0,
+    /* 44481 */ 0321,02,017,0202,064,0,
+    /* 44487 */ 0321,02,017,0206,064,0,
+    /* 44493 */ 0321,02,017,0204,064,0,
+    /* 44499 */ 0321,02,017,0217,064,0,
+    /* 44505 */ 0321,02,017,0215,064,0,
+    /* 44511 */ 0321,02,017,0214,064,0,
+    /* 44517 */ 0321,02,017,0216,064,0,
+    /* 44523 */ 0321,02,017,0205,064,0,
+    /* 44529 */ 0321,02,017,0201,064,0,
+    /* 44535 */ 0321,02,017,0213,064,0,
+    /* 44541 */ 0321,02,017,0211,064,0,
+    /* 44547 */ 0321,02,017,0200,064,0,
+    /* 44553 */ 0321,02,017,0212,064,0,
+    /* 44559 */ 0321,02,017,0210,064,0,
+    /* 44565 */ 0323,02,017,0207,064,0,
+    /* 44571 */ 0323,02,017,0203,064,0,
+    /* 44577 */ 0323,02,017,0202,064,0,
+    /* 44583 */ 0323,02,017,0206,064,0,
+    /* 44589 */ 0323,02,017,0204,064,0,
+    /* 44595 */ 0323,02,017,0217,064,0,
+    /* 44601 */ 0323,02,017,0215,064,0,
+    /* 44607 */ 0323,02,017,0214,064,0,
+    /* 44613 */ 0323,02,017,0216,064,0,
+    /* 44619 */ 0323,02,017,0205,064,0,
+    /* 44625 */ 0323,02,017,0201,064,0,
+    /* 44631 */ 0323,02,017,0213,064,0,
+    /* 44637 */ 0323,02,017,0211,064,0,
+    /* 44643 */ 0323,02,017,0200,064,0,
+    /* 44649 */ 0323,02,017,0212,064,0,
+    /* 44655 */ 0323,02,017,0210,064,0,
+    /* 44661 */ 0360,02,017,0130,0110,0,
+    /* 44667 */ 0333,02,017,0130,0110,0,
+    /* 44673 */ 0360,02,017,0125,0110,0,
+    /* 44679 */ 0360,02,017,0124,0110,0,
+    /* 44685 */ 0360,02,017,057,0110,0,
+    /* 44691 */ 0360,02,017,052,0110,0,
+    /* 44697 */ 0360,02,017,055,0110,0,
+    /* 44703 */ 0360,02,017,054,0110,0,
+    /* 44709 */ 0360,02,017,0136,0110,0,
+    /* 44715 */ 0333,02,017,0136,0110,0,
+    /* 44721 */ 0360,02,017,0256,0202,0,
+    /* 44727 */ 0360,02,017,0137,0110,0,
+    /* 44733 */ 0333,02,017,0137,0110,0,
+    /* 44739 */ 0360,02,017,0135,0110,0,
+    /* 44745 */ 0333,02,017,0135,0110,0,
+    /* 44751 */ 0360,02,017,050,0110,0,
+    /* 44757 */ 0360,02,017,051,0101,0,
+    /* 44763 */ 0360,02,017,026,0110,0,
+    /* 44769 */ 0360,02,017,027,0101,0,
+    /* 44775 */ 0360,02,017,023,0101,0,
+    /* 44781 */ 0360,02,017,0120,0110,0,
+    /* 44787 */ 0360,02,017,053,0101,0,
+    /* 44793 */ 0333,02,017,020,0110,0,
+    /* 44799 */ 0333,02,017,021,0101,0,
+    /* 44805 */ 0360,02,017,020,0110,0,
+    /* 44811 */ 0360,02,017,021,0101,0,
+    /* 44817 */ 0360,02,017,0131,0110,0,
+    /* 44823 */ 0333,02,017,0131,0110,0,
+    /* 44829 */ 0360,02,017,0126,0110,0,
+    /* 44835 */ 0360,02,017,0123,0110,0,
+    /* 44841 */ 0333,02,017,0123,0110,0,
+    /* 44847 */ 0360,02,017,0122,0110,0,
+    /* 44853 */ 0333,02,017,0122,0110,0,
+    /* 44859 */ 0360,02,017,0121,0110,0,
+    /* 44865 */ 0333,02,017,0121,0110,0,
+    /* 44871 */ 0360,02,017,0256,0203,0,
+    /* 44877 */ 0360,02,017,0134,0110,0,
+    /* 44883 */ 0333,02,017,0134,0110,0,
+    /* 44889 */ 0360,02,017,056,0110,0,
+    /* 44895 */ 0360,02,017,025,0110,0,
+    /* 44901 */ 0360,02,017,024,0110,0,
+    /* 44907 */ 0360,02,017,0127,0110,0,
+    /* 44913 */ 0360,02,017,0367,0110,0,
+    /* 44919 */ 0360,02,017,0347,0101,0,
+    /* 44925 */ 0360,02,017,0327,0110,0,
+    /* 44931 */ 0361,02,017,0367,0110,0,
+    /* 44937 */ 0360,02,017,0256,0207,0,
+    /* 44943 */ 0361,02,017,0347,0101,0,
+    /* 44949 */ 0361,02,017,053,0101,0,
+    /* 44955 */ 0361,02,017,0157,0110,0,
+    /* 44961 */ 0361,02,017,0177,0101,0,
+    /* 44967 */ 0333,02,017,0157,0110,0,
+    /* 44973 */ 0333,02,017,0177,0101,0,
+    /* 44979 */ 0332,02,017,0326,0110,0,
+    /* 44985 */ 0333,02,017,0176,0110,0,
+    /* 44991 */ 0361,02,017,0326,0101,0,
+    /* 44997 */ 0333,02,017,0326,0110,0,
+    /* 45003 */ 0361,02,017,0143,0110,0,
+    /* 45009 */ 0361,02,017,0153,0110,0,
+    /* 45015 */ 0361,02,017,0147,0110,0,
+    /* 45021 */ 0361,02,017,0374,0110,0,
+    /* 45027 */ 0361,02,017,0375,0110,0,
+    /* 45033 */ 0361,02,017,0376,0110,0,
+    /* 45039 */ 0360,02,017,0324,0110,0,
+    /* 45045 */ 0361,02,017,0324,0110,0,
+    /* 45051 */ 0361,02,017,0354,0110,0,
+    /* 45057 */ 0361,02,017,0355,0110,0,
+    /* 45063 */ 0361,02,017,0334,0110,0,
+    /* 45069 */ 0361,02,017,0335,0110,0,
+    /* 45075 */ 0361,02,017,0333,0110,0,
+    /* 45081 */ 0361,02,017,0337,0110,0,
+    /* 45087 */ 0361,02,017,0340,0110,0,
+    /* 45093 */ 0361,02,017,0343,0110,0,
+    /* 45099 */ 0361,02,017,0164,0110,0,
+    /* 45105 */ 0361,02,017,0165,0110,0,
+    /* 45111 */ 0361,02,017,0166,0110,0,
+    /* 45117 */ 0361,02,017,0144,0110,0,
+    /* 45123 */ 0361,02,017,0145,0110,0,
+    /* 45129 */ 0361,02,017,0146,0110,0,
+    /* 45135 */ 0361,02,017,0365,0110,0,
+    /* 45141 */ 0361,02,017,0356,0110,0,
+    /* 45147 */ 0361,02,017,0336,0110,0,
+    /* 45153 */ 0361,02,017,0352,0110,0,
+    /* 45159 */ 0361,02,017,0332,0110,0,
+    /* 45165 */ 0361,02,017,0327,0110,0,
+    /* 45171 */ 0361,02,017,0344,0110,0,
+    /* 45177 */ 0361,02,017,0345,0110,0,
+    /* 45183 */ 0361,02,017,0325,0110,0,
+    /* 45189 */ 0361,02,017,0364,0110,0,
+    /* 45195 */ 0361,02,017,0353,0110,0,
+    /* 45201 */ 0361,02,017,0366,0110,0,
+    /* 45207 */ 0361,02,017,0361,0110,0,
+    /* 45213 */ 0361,02,017,0362,0110,0,
+    /* 45219 */ 0361,02,017,0363,0110,0,
+    /* 45225 */ 0361,02,017,0341,0110,0,
+    /* 45231 */ 0361,02,017,0342,0110,0,
+    /* 45237 */ 0361,02,017,0321,0110,0,
+    /* 45243 */ 0361,02,017,0322,0110,0,
+    /* 45249 */ 0361,02,017,0323,0110,0,
+    /* 45255 */ 0361,02,017,0370,0110,0,
+    /* 45261 */ 0361,02,017,0371,0110,0,
+    /* 45267 */ 0361,02,017,0372,0110,0,
+    /* 45273 */ 0361,02,017,0373,0110,0,
+    /* 45279 */ 0361,02,017,0350,0110,0,
+    /* 45285 */ 0361,02,017,0351,0110,0,
+    /* 45291 */ 0361,02,017,0330,0110,0,
+    /* 45297 */ 0361,02,017,0331,0110,0,
+    /* 45303 */ 0361,02,017,0150,0110,0,
+    /* 45309 */ 0361,02,017,0151,0110,0,
+    /* 45315 */ 0361,02,017,0152,0110,0,
+    /* 45321 */ 0361,02,017,0155,0110,0,
+    /* 45327 */ 0361,02,017,0140,0110,0,
+    /* 45333 */ 0361,02,017,0141,0110,0,
+    /* 45339 */ 0361,02,017,0142,0110,0,
+    /* 45345 */ 0361,02,017,0154,0110,0,
+    /* 45351 */ 0361,02,017,0357,0110,0,
+    /* 45357 */ 0361,02,017,0130,0110,0,
+    /* 45363 */ 0332,02,017,0130,0110,0,
+    /* 45369 */ 0361,02,017,0125,0110,0,
+    /* 45375 */ 0361,02,017,0124,0110,0,
+    /* 45381 */ 0361,02,017,057,0110,0,
+    /* 45387 */ 0333,02,017,0346,0110,0,
+    /* 45393 */ 0360,02,017,0133,0110,0,
+    /* 45399 */ 0332,02,017,0346,0110,0,
+    /* 45405 */ 0361,02,017,055,0110,0,
+    /* 45411 */ 0361,02,017,0132,0110,0,
+    /* 45417 */ 0361,02,017,052,0110,0,
+    /* 45423 */ 0361,02,017,0133,0110,0,
+    /* 45429 */ 0360,02,017,0132,0110,0,
+    /* 45435 */ 0332,02,017,0132,0110,0,
+    /* 45441 */ 0333,02,017,0132,0110,0,
+    /* 45447 */ 0361,02,017,054,0110,0,
+    /* 45453 */ 0361,02,017,0346,0110,0,
+    /* 45459 */ 0333,02,017,0133,0110,0,
+    /* 45465 */ 0361,02,017,0136,0110,0,
+    /* 45471 */ 0332,02,017,0136,0110,0,
+    /* 45477 */ 0361,02,017,0137,0110,0,
+    /* 45483 */ 0332,02,017,0137,0110,0,
+    /* 45489 */ 0361,02,017,0135,0110,0,
+    /* 45495 */ 0332,02,017,0135,0110,0,
+    /* 45501 */ 0361,02,017,050,0110,0,
+    /* 45507 */ 0361,02,017,051,0101,0,
+    /* 45513 */ 0361,02,017,027,0101,0,
+    /* 45519 */ 0361,02,017,026,0110,0,
+    /* 45525 */ 0361,02,017,023,0101,0,
+    /* 45531 */ 0361,02,017,022,0110,0,
+    /* 45537 */ 0361,02,017,0120,0110,0,
+    /* 45543 */ 0332,02,017,020,0110,0,
+    /* 45549 */ 0332,02,017,021,0101,0,
+    /* 45555 */ 0361,02,017,020,0110,0,
+    /* 45561 */ 0361,02,017,021,0101,0,
+    /* 45567 */ 0361,02,017,0131,0110,0,
+    /* 45573 */ 0332,02,017,0131,0110,0,
+    /* 45579 */ 0361,02,017,0126,0110,0,
+    /* 45585 */ 0361,02,017,0121,0110,0,
+    /* 45591 */ 0332,02,017,0121,0110,0,
+    /* 45597 */ 0361,02,017,0134,0110,0,
+    /* 45603 */ 0332,02,017,0134,0110,0,
+    /* 45609 */ 0361,02,017,056,0110,0,
+    /* 45615 */ 0361,02,017,025,0110,0,
+    /* 45621 */ 0361,02,017,024,0110,0,
+    /* 45627 */ 0361,02,017,0127,0110,0,
+    /* 45633 */ 0361,02,017,0320,0110,0,
+    /* 45639 */ 0332,02,017,0320,0110,0,
+    /* 45645 */ 0361,02,017,0174,0110,0,
+    /* 45651 */ 0332,02,017,0174,0110,0,
+    /* 45657 */ 0361,02,017,0175,0110,0,
+    /* 45663 */ 0332,02,017,0175,0110,0,
+    /* 45669 */ 0332,02,017,0360,0110,0,
+    /* 45675 */ 0332,02,017,022,0110,0,
+    /* 45681 */ 0333,02,017,026,0110,0,
+    /* 45687 */ 0333,02,017,022,0110,0,
+    /* 45693 */ 0361,02,017,0307,0206,0,
+    /* 45699 */ 0360,02,017,0307,0206,0,
+    /* 45705 */ 0360,02,017,0307,0207,0,
+    /* 45711 */ 0332,03,017,01,0377,0,
+    /* 45717 */ 0333,03,017,01,0376,0,
+    /* 45723 */ 0332,03,017,01,0301,0,
+    /* 45729 */ 0333,03,017,01,0301,0,
+    /* 45735 */ 0361,02,017,0171,0110,0,
+    /* 45741 */ 0332,02,017,0171,0110,0,
+    /* 45747 */ 0332,02,017,053,0101,0,
+    /* 45753 */ 0333,02,017,053,0101,0,
+    /* 45759 */ 0270,01,04,01,0167,0,
+    /* 45765 */ 0270,01,0,01,0167,0,
+    /* 45771 */ 0320,02,017,0307,0206,0,
+    /* 45777 */ 0321,02,017,0307,0206,0,
+    /* 45783 */ 0324,02,017,0307,0206,0,
+    /* 45789 */ 0320,02,017,0307,0207,0,
+    /* 45795 */ 0321,02,017,0307,0207,0,
+    /* 45801 */ 0324,02,017,0307,0207,0,
+    /* 45807 */ 0336,03,017,0247,0310,0,
+    /* 45813 */ 0336,03,017,0247,0320,0,
+    /* 45819 */ 0336,03,017,0247,0330,0,
+    /* 45825 */ 0336,03,017,0247,0340,0,
+    /* 45831 */ 0336,03,017,0247,0350,0,
+    /* 45837 */ 0336,03,017,0246,0300,0,
+    /* 45843 */ 0336,03,017,0246,0310,0,
+    /* 45849 */ 0336,03,017,0246,0320,0,
+    /* 45855 */ 0322,02,0307,0370,064,0,
+    /* 45861 */ 0320,02,0307,0370,064,0,
+    /* 45867 */ 0321,02,0307,0370,064,0,
+    /* 45873 */ 0323,02,0307,0370,064,0,
+    /* 45879 */ 0333,02,017,033,0110,0,
+    /* 45885 */ 0361,02,017,032,0110,0,
+    /* 45891 */ 0361,02,017,033,0101,0,
+    /* 45897 */ 02,017,032,016,0110,0,
+    /* 45903 */ 02,017,033,015,0102,0,
+    /* 45909 */ 02,017,033,016,0101,0,
+    /* 45915 */ 03,017,070,0311,0110,0,
+    /* 45921 */ 03,017,070,0312,0110,0,
+    /* 45927 */ 03,017,070,0310,0110,0,
+    /* 45933 */ 03,017,070,0314,0110,0,
+    /* 45939 */ 03,017,070,0315,0110,0,
+    /* 45945 */ 03,017,070,0313,0110,0,
+    /* 45951 */ 0361,02,017,0256,0207,0,
+    /* 45957 */ 0361,02,017,0256,0206,0,
+    /* 45963 */ 0361,03,017,0256,0370,0,
+    /* 45969 */ 0310,03,017,01,0374,0,
+    /* 45975 */ 0311,03,017,01,0374,0,
+    /* 45981 */ 0313,03,017,01,0374,0,
+    /* 45987 */ 0360,02,017,034,0200,0,
+    /* 45993 */ 0360,03,017,01,0305,0,
+    /* 45999 */ 0332,02,017,0256,0206,0,
+    /* 46005 */ 0360,03,017,01,0317,0,
+    /* 46011 */ 0360,03,017,01,0327,0,
+    /* 46017 */ 0360,03,017,01,0300,0,
+    /* 46023 */ 0333,03,017,036,0373,0,
+    /* 46029 */ 0333,03,017,036,0372,0,
+    /* 46035 */ 0333,02,017,01,0205,0,
+    /* 46041 */ 0333,03,017,01,0352,0,
+    /* 46047 */ 0333,03,017,01,0350,0,
+    /* 46053 */ 0360,03,017,01,0350,0,
+    /* 46059 */ 0332,03,017,01,0351,0,
+    /* 46065 */ 0332,03,017,01,0350,0,
+    /* 46071 */ 0333,03,017,01,0356,0,
+    /* 46077 */ 0333,03,017,01,0357,0,
+    /* 46083 */ 0333,03,017,01,0355,0,
+    /* 46089 */ 0333,03,017,01,0354,0,
+    /* 46095 */ 0360,03,017,01,0306,0,
+    /* 46101 */ 0332,03,017,01,0306,0,
+    /* 46107 */ 0333,03,017,01,0306,0,
+    /* 46113 */ 0320,02,017,030,0200,0,
+    /* 46119 */ 0321,02,017,030,0200,0,
+    /* 46125 */ 0324,02,017,030,0200,0,
+    /* 46131 */ 0320,02,017,030,0201,0,
+    /* 46137 */ 0321,02,017,030,0201,0,
+    /* 46143 */ 0324,02,017,030,0201,0,
+    /* 46149 */ 0320,02,017,030,0202,0,
+    /* 46155 */ 0321,02,017,030,0202,0,
+    /* 46161 */ 0324,02,017,030,0202,0,
+    /* 46167 */ 0320,02,017,030,0203,0,
+    /* 46173 */ 0321,02,017,030,0203,0,
+    /* 46179 */ 0324,02,017,030,0203,0,
+    /* 46185 */ 0320,02,017,030,0204,0,
+    /* 46191 */ 0321,02,017,030,0204,0,
+    /* 46197 */ 0324,02,017,030,0204,0,
+    /* 46203 */ 0320,02,017,030,0205,0,
+    /* 46209 */ 0321,02,017,030,0205,0,
+    /* 46215 */ 0324,02,017,030,0205,0,
+    /* 46221 */ 0320,02,017,030,0206,0,
+    /* 46227 */ 0321,02,017,030,0206,0,
+    /* 46233 */ 0324,02,017,030,0206,0,
+    /* 46239 */ 0320,02,017,030,0207,0,
+    /* 46245 */ 0321,02,017,030,0207,0,
+    /* 46251 */ 0324,02,017,030,0207,0,
+    /* 46257 */ 0320,02,017,031,0200,0,
+    /* 46263 */ 0321,02,017,031,0200,0,
+    /* 46269 */ 0324,02,017,031,0200,0,
+    /* 46275 */ 0320,02,017,031,0201,0,
+    /* 46281 */ 0321,02,017,031,0201,0,
+    /* 46287 */ 0324,02,017,031,0201,0,
+    /* 46293 */ 0320,02,017,031,0202,0,
+    /* 46299 */ 0321,02,017,031,0202,0,
+    /* 46305 */ 0324,02,017,031,0202,0,
+    /* 46311 */ 0320,02,017,031,0203,0,
+    /* 46317 */ 0321,02,017,031,0203,0,
+    /* 46323 */ 0324,02,017,031,0203,0,
+    /* 46329 */ 0320,02,017,031,0204,0,
+    /* 46335 */ 0321,02,017,031,0204,0,
+    /* 46341 */ 0324,02,017,031,0204,0,
+    /* 46347 */ 0320,02,017,031,0205,0,
+    /* 46353 */ 0321,02,017,031,0205,0,
+    /* 46359 */ 0324,02,017,031,0205,0,
+    /* 46365 */ 0320,02,017,031,0206,0,
+    /* 46371 */ 0321,02,017,031,0206,0,
+    /* 46377 */ 0324,02,017,031,0206,0,
+    /* 46383 */ 0320,02,017,031,0207,0,
+    /* 46389 */ 0321,02,017,031,0207,0,
+    /* 46395 */ 0324,02,017,031,0207,0,
+    /* 46401 */ 0320,02,017,032,0200,0,
+    /* 46407 */ 0321,02,017,032,0200,0,
+    /* 46413 */ 0324,02,017,032,0200,0,
+    /* 46419 */ 0320,02,017,032,0201,0,
+    /* 46425 */ 0321,02,017,032,0201,0,
+    /* 46431 */ 0324,02,017,032,0201,0,
+    /* 46437 */ 0320,02,017,032,0202,0,
+    /* 46443 */ 0321,02,017,032,0202,0,
+    /* 46449 */ 0324,02,017,032,0202,0,
+    /* 46455 */ 0320,02,017,032,0203,0,
+    /* 46461 */ 0321,02,017,032,0203,0,
+    /* 46467 */ 0324,02,017,032,0203,0,
+    /* 46473 */ 0320,02,017,032,0204,0,
+    /* 46479 */ 0321,02,017,032,0204,0,
+    /* 46485 */ 0324,02,017,032,0204,0,
+    /* 46491 */ 0320,02,017,032,0205,0,
+    /* 46497 */ 0321,02,017,032,0205,0,
+    /* 46503 */ 0324,02,017,032,0205,0,
+    /* 46509 */ 0320,02,017,032,0206,0,
+    /* 46515 */ 0321,02,017,032,0206,0,
+    /* 46521 */ 0324,02,017,032,0206,0,
+    /* 46527 */ 0320,02,017,032,0207,0,
+    /* 46533 */ 0321,02,017,032,0207,0,
+    /* 46539 */ 0324,02,017,032,0207,0,
+    /* 46545 */ 0320,02,017,033,0200,0,
+    /* 46551 */ 0321,02,017,033,0200,0,
+    /* 46557 */ 0324,02,017,033,0200,0,
+    /* 46563 */ 0320,02,017,033,0201,0,
+    /* 46569 */ 0321,02,017,033,0201,0,
+    /* 46575 */ 0324,02,017,033,0201,0,
+    /* 46581 */ 0320,02,017,033,0202,0,
+    /* 46587 */ 0321,02,017,033,0202,0,
+    /* 46593 */ 0324,02,017,033,0202,0,
+    /* 46599 */ 0320,02,017,033,0203,0,
+    /* 46605 */ 0321,02,017,033,0203,0,
+    /* 46611 */ 0324,02,017,033,0203,0,
+    /* 46617 */ 0320,02,017,033,0204,0,
+    /* 46623 */ 0321,02,017,033,0204,0,
+    /* 46629 */ 0324,02,017,033,0204,0,
+    /* 46635 */ 0320,02,017,033,0205,0,
+    /* 46641 */ 0321,02,017,033,0205,0,
+    /* 46647 */ 0324,02,017,033,0205,0,
+    /* 46653 */ 0320,02,017,033,0206,0,
+    /* 46659 */ 0321,02,017,033,0206,0,
+    /* 46665 */ 0324,02,017,033,0206,0,
+    /* 46671 */ 0320,02,017,033,0207,0,
+    /* 46677 */ 0321,02,017,033,0207,0,
+    /* 46683 */ 0324,02,017,033,0207,0,
+    /* 46689 */ 0320,02,017,034,0200,0,
+    /* 46695 */ 0321,02,017,034,0200,0,
+    /* 46701 */ 0324,02,017,034,0200,0,
+    /* 46707 */ 0320,02,017,034,0201,0,
+    /* 46713 */ 0321,02,017,034,0201,0,
+    /* 46719 */ 0324,02,017,034,0201,0,
+    /* 46725 */ 0320,02,017,034,0202,0,
+    /* 46731 */ 0321,02,017,034,0202,0,
+    /* 46737 */ 0324,02,017,034,0202,0,
+    /* 46743 */ 0320,02,017,034,0203,0,
+    /* 46749 */ 0321,02,017,034,0203,0,
+    /* 46755 */ 0324,02,017,034,0203,0,
+    /* 46761 */ 0320,02,017,034,0204,0,
+    /* 46767 */ 0321,02,017,034,0204,0,
+    /* 46773 */ 0324,02,017,034,0204,0,
+    /* 46779 */ 0320,02,017,034,0205,0,
+    /* 46785 */ 0321,02,017,034,0205,0,
+    /* 46791 */ 0324,02,017,034,0205,0,
+    /* 46797 */ 0320,02,017,034,0206,0,
+    /* 46803 */ 0321,02,017,034,0206,0,
+    /* 46809 */ 0324,02,017,034,0206,0,
+    /* 46815 */ 0320,02,017,034,0207,0,
+    /* 46821 */ 0321,02,017,034,0207,0,
+    /* 46827 */ 0324,02,017,034,0207,0,
+    /* 46833 */ 0320,02,017,035,0200,0,
+    /* 46839 */ 0321,02,017,035,0200,0,
+    /* 46845 */ 0324,02,017,035,0200,0,
+    /* 46851 */ 0320,02,017,035,0201,0,
+    /* 46857 */ 0321,02,017,035,0201,0,
+    /* 46863 */ 0324,02,017,035,0201,0,
+    /* 46869 */ 0320,02,017,035,0202,0,
+    /* 46875 */ 0321,02,017,035,0202,0,
+    /* 46881 */ 0324,02,017,035,0202,0,
+    /* 46887 */ 0320,02,017,035,0203,0,
+    /* 46893 */ 0321,02,017,035,0203,0,
+    /* 46899 */ 0324,02,017,035,0203,0,
+    /* 46905 */ 0320,02,017,035,0204,0,
+    /* 46911 */ 0321,02,017,035,0204,0,
+    /* 46917 */ 0324,02,017,035,0204,0,
+    /* 46923 */ 0320,02,017,035,0205,0,
+    /* 46929 */ 0321,02,017,035,0205,0,
+    /* 46935 */ 0324,02,017,035,0205,0,
+    /* 46941 */ 0320,02,017,035,0206,0,
+    /* 46947 */ 0321,02,017,035,0206,0,
+    /* 46953 */ 0324,02,017,035,0206,0,
+    /* 46959 */ 0320,02,017,035,0207,0,
+    /* 46965 */ 0321,02,017,035,0207,0,
+    /* 46971 */ 0324,02,017,035,0207,0,
+    /* 46977 */ 0320,02,017,036,0200,0,
+    /* 46983 */ 0321,02,017,036,0200,0,
+    /* 46989 */ 0324,02,017,036,0200,0,
+    /* 46995 */ 0320,02,017,036,0201,0,
+    /* 47001 */ 0321,02,017,036,0201,0,
+    /* 47007 */ 0324,02,017,036,0201,0,
+    /* 47013 */ 0320,02,017,036,0202,0,
+    /* 47019 */ 0321,02,017,036,0202,0,
+    /* 47025 */ 0324,02,017,036,0202,0,
+    /* 47031 */ 0320,02,017,036,0203,0,
+    /* 47037 */ 0321,02,017,036,0203,0,
+    /* 47043 */ 0324,02,017,036,0203,0,
+    /* 47049 */ 0320,02,017,036,0204,0,
+    /* 47055 */ 0321,02,017,036,0204,0,
+    /* 47061 */ 0324,02,017,036,0204,0,
+    /* 47067 */ 0320,02,017,036,0205,0,
+    /* 47073 */ 0321,02,017,036,0205,0,
+    /* 47079 */ 0324,02,017,036,0205,0,
+    /* 47085 */ 0320,02,017,036,0206,0,
+    /* 47091 */ 0321,02,017,036,0206,0,
+    /* 47097 */ 0324,02,017,036,0206,0,
+    /* 47103 */ 0320,02,017,036,0207,0,
+    /* 47109 */ 0321,02,017,036,0207,0,
+    /* 47115 */ 0324,02,017,036,0207,0,
+    /* 47121 */ 0320,02,017,037,0201,0,
+    /* 47127 */ 0321,02,017,037,0201,0,
+    /* 47133 */ 0324,02,017,037,0201,0,
+    /* 47139 */ 0320,02,017,037,0202,0,
+    /* 47145 */ 0321,02,017,037,0202,0,
+    /* 47151 */ 0324,02,017,037,0202,0,
+    /* 47157 */ 0320,02,017,037,0203,0,
+    /* 47163 */ 0321,02,017,037,0203,0,
+    /* 47169 */ 0324,02,017,037,0203,0,
+    /* 47175 */ 0320,02,017,037,0204,0,
+    /* 47181 */ 0321,02,017,037,0204,0,
+    /* 47187 */ 0324,02,017,037,0204,0,
+    /* 47193 */ 0320,02,017,037,0205,0,
+    /* 47199 */ 0321,02,017,037,0205,0,
+    /* 47205 */ 0324,02,017,037,0205,0,
+    /* 47211 */ 0320,02,017,037,0206,0,
+    /* 47217 */ 0321,02,017,037,0206,0,
+    /* 47223 */ 0324,02,017,037,0206,0,
+    /* 47229 */ 0320,02,017,037,0207,0,
+    /* 47235 */ 0321,02,017,037,0207,0,
+    /* 47241 */ 0324,02,017,037,0207,0,
+    /* 47247 */ 0273,01,020,0101,0,
+    /* 47252 */ 0320,01,023,0110,0,
+    /* 47257 */ 0321,01,023,0110,0,
+    /* 47262 */ 0324,01,023,0110,0,
+    /* 47267 */ 0320,01,025,031,0,
+    /* 47272 */ 0321,01,025,041,0,
+    /* 47277 */ 0324,01,025,0255,0,
+    /* 47282 */ 0273,01,0,0101,0,
+    /* 47287 */ 0320,01,03,0110,0,
+    /* 47292 */ 0321,01,03,0110,0,
+    /* 47297 */ 0324,01,03,0110,0,
+    /* 47302 */ 0320,01,05,031,0,
+    /* 47307 */ 0321,01,05,041,0,
+    /* 47312 */ 0324,01,05,0255,0,
+    /* 47317 */ 0273,01,040,0101,0,
+    /* 47322 */ 0320,01,043,0110,0,
+    /* 47327 */ 0321,01,043,0110,0,
+    /* 47332 */ 0324,01,043,0110,0,
+    /* 47337 */ 0320,01,045,031,0,
+    /* 47342 */ 0321,01,045,041,0,
+    /* 47347 */ 0324,01,045,0255,0,
+    /* 47352 */ 0320,01,0142,0110,0,
+    /* 47357 */ 0321,01,0142,0110,0,
+    /* 47362 */ 0322,01,0350,064,0,
+    /* 47367 */ 0320,01,0350,064,0,
+    /* 47372 */ 0321,01,0350,064,0,
+    /* 47377 */ 0323,01,0350,064,0,
+    /* 47382 */ 0322,01,0377,0203,0,
+    /* 47387 */ 0324,01,0377,0203,0,
+    /* 47392 */ 0320,01,0377,0203,0,
+    /* 47397 */ 0321,01,0377,0203,0,
+    /* 47402 */ 0322,01,0377,0202,0,
+    /* 47407 */ 0320,01,0377,0202,0,
+    /* 47412 */ 0321,01,0377,0202,0,
+    /* 47417 */ 0323,01,0377,0202,0,
+    /* 47422 */ 0320,01,071,0101,0,
+    /* 47427 */ 0321,01,071,0101,0,
+    /* 47432 */ 0324,01,071,0101,0,
+    /* 47437 */ 0320,01,073,0110,0,
+    /* 47442 */ 0321,01,073,0110,0,
+    /* 47447 */ 0324,01,073,0110,0,
+    /* 47452 */ 0320,01,075,031,0,
+    /* 47457 */ 0321,01,075,041,0,
+    /* 47462 */ 0324,01,075,0255,0,
+    /* 47467 */ 01,0200,0207,021,0,
+    /* 47472 */ 01,0202,0207,021,0,
+    /* 47477 */ 0335,0321,01,0247,0,
+    /* 47482 */ 0335,0324,01,0247,0,
+    /* 47487 */ 0335,0320,01,0247,0,
+    /* 47492 */ 02,017,0246,0101,0,
+    /* 47497 */ 0273,01,0376,0201,0,
+    /* 47502 */ 0320,01,0367,0206,0,
+    /* 47507 */ 0321,01,0367,0206,0,
+    /* 47512 */ 0324,01,0367,0206,0,
+    /* 47517 */ 01,0310,030,025,0,
+    /* 47522 */ 01,0334,010,0300,0,
+    /* 47527 */ 01,0330,010,0300,0,
+    /* 47532 */ 01,0330,011,0300,0,
+    /* 47537 */ 01,0336,010,0300,0,
+    /* 47542 */ 0341,02,0333,0342,0,
+    /* 47547 */ 01,0332,010,0300,0,
+    /* 47552 */ 01,0332,011,0300,0,
+    /* 47557 */ 01,0332,010,0320,0,
+    /* 47562 */ 01,0332,011,0320,0,
+    /* 47567 */ 01,0332,010,0310,0,
+    /* 47572 */ 01,0332,011,0310,0,
+    /* 47577 */ 01,0333,010,0300,0,
+    /* 47582 */ 01,0333,011,0300,0,
+    /* 47587 */ 01,0333,010,0320,0,
+    /* 47592 */ 01,0333,011,0320,0,
+    /* 47597 */ 01,0333,010,0310,0,
+    /* 47602 */ 01,0333,011,0310,0,
+    /* 47607 */ 01,0333,010,0330,0,
+    /* 47612 */ 01,0333,011,0330,0,
+    /* 47617 */ 01,0332,010,0330,0,
+    /* 47622 */ 01,0332,011,0330,0,
+    /* 47627 */ 01,0330,010,0320,0,
+    /* 47632 */ 01,0330,011,0320,0,
+    /* 47637 */ 01,0333,010,0360,0,
+    /* 47642 */ 01,0333,011,0360,0,
+    /* 47647 */ 01,0337,010,0360,0,
+    /* 47652 */ 01,0337,011,0360,0,
+    /* 47657 */ 01,0330,010,0330,0,
+    /* 47662 */ 01,0330,011,0330,0,
+    /* 47667 */ 0341,02,0333,0341,0,
+    /* 47672 */ 01,0334,010,0370,0,
+    /* 47677 */ 01,0330,010,0360,0,
+    /* 47682 */ 01,0330,011,0360,0,
+    /* 47687 */ 01,0336,010,0370,0,
+    /* 47692 */ 01,0334,010,0360,0,
+    /* 47697 */ 01,0330,010,0370,0,
+    /* 47702 */ 01,0330,011,0370,0,
+    /* 47707 */ 01,0336,010,0360,0,
+    /* 47712 */ 0341,02,0333,0340,0,
+    /* 47717 */ 01,0335,010,0300,0,
+    /* 47722 */ 01,0337,010,0300,0,
+    /* 47727 */ 0341,02,0333,0343,0,
+    /* 47732 */ 01,0331,010,0300,0,
+    /* 47737 */ 01,0334,010,0310,0,
+    /* 47742 */ 01,0330,010,0310,0,
+    /* 47747 */ 01,0330,011,0310,0,
+    /* 47752 */ 01,0336,010,0310,0,
+    /* 47757 */ 0341,01,0335,0206,0,
+    /* 47762 */ 01,0335,010,0320,0,
+    /* 47767 */ 0341,01,0331,0207,0,
+    /* 47772 */ 0341,01,0331,0206,0,
+    /* 47777 */ 01,0335,010,0330,0,
+    /* 47782 */ 0341,01,0335,0207,0,
+    /* 47787 */ 0341,02,0337,0340,0,
+    /* 47792 */ 01,0334,010,0350,0,
+    /* 47797 */ 01,0330,010,0340,0,
+    /* 47802 */ 01,0330,011,0340,0,
+    /* 47807 */ 01,0336,010,0350,0,
+    /* 47812 */ 01,0334,010,0340,0,
+    /* 47817 */ 01,0330,010,0350,0,
+    /* 47822 */ 01,0330,011,0350,0,
+    /* 47827 */ 01,0336,010,0340,0,
+    /* 47832 */ 01,0335,010,0340,0,
+    /* 47837 */ 01,0335,011,0340,0,
+    /* 47842 */ 01,0333,010,0350,0,
+    /* 47847 */ 01,0333,011,0350,0,
+    /* 47852 */ 01,0337,010,0350,0,
+    /* 47857 */ 01,0337,011,0350,0,
+    /* 47862 */ 01,0335,010,0350,0,
+    /* 47867 */ 01,0335,011,0350,0,
+    /* 47872 */ 01,0331,010,0310,0,
+    /* 47877 */ 01,0331,011,0310,0,
+    /* 47882 */ 0320,01,0367,0207,0,
+    /* 47887 */ 0321,01,0367,0207,0,
+    /* 47892 */ 0324,01,0367,0207,0,
+    /* 47897 */ 0320,01,0367,0205,0,
+    /* 47902 */ 0321,01,0367,0205,0,
+    /* 47907 */ 0324,01,0367,0205,0,
+    /* 47912 */ 0320,01,0345,025,0,
+    /* 47917 */ 0321,01,0345,025,0,
+    /* 47922 */ 0273,01,0376,0200,0,
+    /* 47927 */ 02,017,01,0207,0,
+    /* 47932 */ 0310,01,0343,050,0,
+    /* 47937 */ 0311,01,0343,050,0,
+    /* 47942 */ 0371,01,0353,050,0,
+    /* 47947 */ 0322,01,0351,064,0,
+    /* 47952 */ 0320,01,0351,064,0,
+    /* 47957 */ 0321,01,0351,064,0,
+    /* 47962 */ 0323,01,0351,064,0,
+    /* 47967 */ 0322,01,0377,0205,0,
+    /* 47972 */ 0324,01,0377,0205,0,
+    /* 47977 */ 0320,01,0377,0205,0,
+    /* 47982 */ 0321,01,0377,0205,0,
+    /* 47987 */ 0322,01,0377,0204,0,
+    /* 47992 */ 0320,01,0377,0204,0,
+    /* 47997 */ 0321,01,0377,0204,0,
+    /* 48002 */ 0323,01,0377,0204,0,
+    /* 48007 */ 0320,01,0305,0110,0,
+    /* 48012 */ 0321,01,0305,0110,0,
+    /* 48017 */ 0320,01,0215,0110,0,
+    /* 48022 */ 0321,01,0215,0110,0,
+    /* 48027 */ 0324,01,0215,0110,0,
+    /* 48032 */ 0320,01,0304,0110,0,
+    /* 48037 */ 0321,01,0304,0110,0,
+    /* 48042 */ 02,017,01,0202,0,
+    /* 48047 */ 02,017,01,0203,0,
+    /* 48052 */ 02,017,0,0202,0,
+    /* 48057 */ 02,017,01,0206,0,
+    /* 48062 */ 0312,01,0342,050,0,
+    /* 48067 */ 0310,01,0342,050,0,
+    /* 48072 */ 0311,01,0342,050,0,
+    /* 48077 */ 0313,01,0342,050,0,
+    /* 48082 */ 0312,01,0341,050,0,
+    /* 48087 */ 0310,01,0341,050,0,
+    /* 48092 */ 0311,01,0341,050,0,
+    /* 48097 */ 0313,01,0341,050,0,
+    /* 48102 */ 0312,01,0340,050,0,
+    /* 48107 */ 0310,01,0340,050,0,
+    /* 48112 */ 0311,01,0340,050,0,
+    /* 48117 */ 0313,01,0340,050,0,
+    /* 48122 */ 02,017,0,0203,0,
+    /* 48127 */ 03,017,01,0310,0,
+    /* 48132 */ 03,017,01,0372,0,
+    /* 48137 */ 0320,01,0214,0101,0,
+    /* 48142 */ 0321,01,0214,0101,0,
+    /* 48147 */ 0323,01,0214,0101,0,
+    /* 48152 */ 0324,01,0214,0101,0,
+    /* 48157 */ 0323,01,0216,0110,0,
+    /* 48162 */ 0320,01,0216,0110,0,
+    /* 48167 */ 0321,01,0216,0110,0,
+    /* 48172 */ 0324,01,0216,0110,0,
+    /* 48177 */ 0320,01,0241,045,0,
+    /* 48182 */ 0321,01,0241,045,0,
+    /* 48187 */ 0324,01,0241,045,0,
+    /* 48192 */ 0320,01,0243,044,0,
+    /* 48197 */ 0321,01,0243,044,0,
+    /* 48202 */ 0324,01,0243,044,0,
+    /* 48207 */ 02,017,044,0101,0,
+    /* 48212 */ 02,017,046,0110,0,
+    /* 48217 */ 0271,01,0210,0101,0,
+    /* 48222 */ 0320,01,0213,0110,0,
+    /* 48227 */ 0321,01,0213,0110,0,
+    /* 48232 */ 0324,01,0213,0110,0,
+    /* 48237 */ 0320,010,0270,031,0,
+    /* 48242 */ 0321,010,0270,041,0,
+    /* 48247 */ 0323,010,0270,041,0,
+    /* 48252 */ 0324,010,0270,055,0,
+    /* 48257 */ 0324,01,0143,0110,0,
+    /* 48262 */ 0320,01,0367,0204,0,
+    /* 48267 */ 0321,01,0367,0204,0,
+    /* 48272 */ 0324,01,0367,0204,0,
+    /* 48277 */ 03,017,01,0311,0,
+    /* 48282 */ 03,017,01,0373,0,
+    /* 48287 */ 0273,01,0366,0203,0,
+    /* 48292 */ 0314,0326,01,0220,0,
+    /* 48297 */ 0273,01,0366,0202,0,
+    /* 48302 */ 0273,01,010,0101,0,
+    /* 48307 */ 0320,01,013,0110,0,
+    /* 48312 */ 0321,01,013,0110,0,
+    /* 48317 */ 0324,01,013,0110,0,
+    /* 48322 */ 0320,01,015,031,0,
+    /* 48327 */ 0321,01,015,041,0,
+    /* 48332 */ 0324,01,015,0255,0,
+    /* 48337 */ 0320,01,0347,024,0,
+    /* 48342 */ 0321,01,0347,024,0,
+    /* 48347 */ 0320,01,0217,0200,0,
+    /* 48352 */ 0321,01,0217,0200,0,
+    /* 48357 */ 0323,01,0217,0200,0,
+    /* 48362 */ 02,017,015,0200,0,
+    /* 48367 */ 02,017,015,0201,0,
+    /* 48372 */ 0320,01,0377,0206,0,
+    /* 48377 */ 0321,01,0377,0206,0,
+    /* 48382 */ 0323,01,0377,0206,0,
+    /* 48387 */ 0320,01,0152,0274,0,
+    /* 48392 */ 0320,01,0150,030,0,
+    /* 48397 */ 0321,01,0152,0274,0,
+    /* 48402 */ 0321,01,0150,040,0,
+    /* 48407 */ 0323,01,0152,0274,0,
+    /* 48412 */ 0323,01,0150,0254,0,
+    /* 48417 */ 01,0300,0202,025,0,
+    /* 48422 */ 0320,01,0321,0202,0,
+    /* 48427 */ 0320,01,0323,0202,0,
+    /* 48432 */ 0321,01,0321,0202,0,
+    /* 48437 */ 0321,01,0323,0202,0,
+    /* 48442 */ 0324,01,0321,0202,0,
+    /* 48447 */ 0324,01,0323,0202,0,
+    /* 48452 */ 01,0300,0203,025,0,
+    /* 48457 */ 0320,01,0321,0203,0,
+    /* 48462 */ 0320,01,0323,0203,0,
+    /* 48467 */ 0321,01,0321,0203,0,
+    /* 48472 */ 0321,01,0323,0203,0,
+    /* 48477 */ 0324,01,0321,0203,0,
+    /* 48482 */ 0324,01,0323,0203,0,
+    /* 48487 */ 03,017,01,0371,0,
+    /* 48492 */ 0320,01,0312,030,0,
+    /* 48497 */ 0320,01,0302,030,0,
+    /* 48502 */ 0321,01,0302,030,0,
+    /* 48507 */ 0321,01,0312,030,0,
+    /* 48512 */ 0323,01,0302,030,0,
+    /* 48517 */ 0324,01,0312,030,0,
+    /* 48522 */ 01,0300,0200,025,0,
+    /* 48527 */ 0320,01,0321,0200,0,
+    /* 48532 */ 0320,01,0323,0200,0,
+    /* 48537 */ 0321,01,0321,0200,0,
+    /* 48542 */ 0321,01,0323,0200,0,
+    /* 48547 */ 0324,01,0321,0200,0,
+    /* 48552 */ 0324,01,0323,0200,0,
+    /* 48557 */ 01,0300,0201,025,0,
+    /* 48562 */ 0320,01,0321,0201,0,
+    /* 48567 */ 0320,01,0323,0201,0,
+    /* 48572 */ 0321,01,0321,0201,0,
+    /* 48577 */ 0321,01,0323,0201,0,
+    /* 48582 */ 0324,01,0321,0201,0,
+    /* 48587 */ 0324,01,0323,0201,0,
+    /* 48592 */ 02,017,0173,0200,0,
+    /* 48597 */ 02,017,0175,0200,0,
+    /* 48602 */ 01,0300,0204,025,0,
+    /* 48607 */ 0320,01,0321,0204,0,
+    /* 48612 */ 0320,01,0323,0204,0,
+    /* 48617 */ 0321,01,0321,0204,0,
+    /* 48622 */ 0321,01,0323,0204,0,
+    /* 48627 */ 0324,01,0321,0204,0,
+    /* 48632 */ 0324,01,0323,0204,0,
+    /* 48637 */ 01,0300,0207,025,0,
+    /* 48642 */ 0320,01,0321,0207,0,
+    /* 48647 */ 0320,01,0323,0207,0,
+    /* 48652 */ 0321,01,0321,0207,0,
+    /* 48657 */ 0321,01,0323,0207,0,
+    /* 48662 */ 0324,01,0321,0207,0,
+    /* 48667 */ 0324,01,0323,0207,0,
+    /* 48672 */ 0273,01,030,0101,0,
+    /* 48677 */ 0320,01,033,0110,0,
+    /* 48682 */ 0321,01,033,0110,0,
+    /* 48687 */ 0324,01,033,0110,0,
+    /* 48692 */ 0320,01,035,031,0,
+    /* 48697 */ 0321,01,035,041,0,
+    /* 48702 */ 0324,01,035,0255,0,
+    /* 48707 */ 0335,0321,01,0257,0,
+    /* 48712 */ 0335,0324,01,0257,0,
+    /* 48717 */ 0335,0320,01,0257,0,
+    /* 48722 */ 02,017,01,0200,0,
+    /* 48727 */ 01,0300,0205,025,0,
+    /* 48732 */ 0320,01,0321,0205,0,
+    /* 48737 */ 0320,01,0323,0205,0,
+    /* 48742 */ 0321,01,0321,0205,0,
+    /* 48747 */ 0321,01,0323,0205,0,
+    /* 48752 */ 0324,01,0321,0205,0,
+    /* 48757 */ 0324,01,0323,0205,0,
+    /* 48762 */ 02,017,01,0201,0,
+    /* 48767 */ 03,017,01,0336,0,
+    /* 48772 */ 0273,01,050,0101,0,
+    /* 48777 */ 0320,01,053,0110,0,
+    /* 48782 */ 0321,01,053,0110,0,
+    /* 48787 */ 0324,01,053,0110,0,
+    /* 48792 */ 0320,01,055,031,0,
+    /* 48797 */ 0321,01,055,041,0,
+    /* 48802 */ 0324,01,055,0255,0,
+    /* 48807 */ 02,017,0172,0200,0,
+    /* 48812 */ 02,017,0174,0200,0,
+    /* 48817 */ 03,017,01,0370,0,
+    /* 48822 */ 0320,01,0205,0101,0,
+    /* 48827 */ 0321,01,0205,0101,0,
+    /* 48832 */ 0324,01,0205,0101,0,
+    /* 48837 */ 0320,01,0205,0110,0,
+    /* 48842 */ 0321,01,0205,0110,0,
+    /* 48847 */ 0324,01,0205,0110,0,
+    /* 48852 */ 0320,01,0251,031,0,
+    /* 48857 */ 0321,01,0251,041,0,
+    /* 48862 */ 0324,01,0251,0255,0,
+    /* 48867 */ 01,0366,0200,021,0,
+    /* 48872 */ 02,017,0,0204,0,
+    /* 48877 */ 02,017,0,0205,0,
+    /* 48882 */ 0272,01,0206,0110,0,
+    /* 48887 */ 0272,01,0206,0101,0,
+    /* 48892 */ 0273,01,060,0101,0,
+    /* 48897 */ 0320,01,063,0110,0,
+    /* 48902 */ 0321,01,063,0110,0,
+    /* 48907 */ 0324,01,063,0110,0,
+    /* 48912 */ 0320,01,065,031,0,
+    /* 48917 */ 0321,01,065,041,0,
+    /* 48922 */ 0324,01,065,0255,0,
+    /* 48927 */ 0370,01,0167,050,0,
+    /* 48932 */ 0370,01,0163,050,0,
+    /* 48937 */ 0370,01,0162,050,0,
+    /* 48942 */ 0370,01,0166,050,0,
+    /* 48947 */ 0370,01,0164,050,0,
+    /* 48952 */ 0370,01,0177,050,0,
+    /* 48957 */ 0370,01,0175,050,0,
+    /* 48962 */ 0370,01,0174,050,0,
+    /* 48967 */ 0370,01,0176,050,0,
+    /* 48972 */ 0370,01,0165,050,0,
+    /* 48977 */ 0370,01,0161,050,0,
+    /* 48982 */ 0370,01,0173,050,0,
+    /* 48987 */ 0370,01,0171,050,0,
+    /* 48992 */ 0370,01,0160,050,0,
+    /* 48997 */ 0370,01,0172,050,0,
+    /* 49002 */ 0370,01,0170,050,0,
+    /* 49007 */ 02,017,0227,0200,0,
+    /* 49012 */ 02,017,0223,0200,0,
+    /* 49017 */ 02,017,0222,0200,0,
+    /* 49022 */ 02,017,0226,0200,0,
+    /* 49027 */ 02,017,0224,0200,0,
+    /* 49032 */ 02,017,0237,0200,0,
+    /* 49037 */ 02,017,0235,0200,0,
+    /* 49042 */ 02,017,0234,0200,0,
+    /* 49047 */ 02,017,0236,0200,0,
+    /* 49052 */ 02,017,0225,0200,0,
+    /* 49057 */ 02,017,0221,0200,0,
+    /* 49062 */ 02,017,0233,0200,0,
+    /* 49067 */ 02,017,0231,0200,0,
+    /* 49072 */ 02,017,0220,0200,0,
+    /* 49077 */ 02,017,0232,0200,0,
+    /* 49082 */ 02,017,0230,0200,0,
+    /* 49087 */ 03,017,01,0320,0,
+    /* 49092 */ 03,017,01,0321,0,
+    /* 49097 */ 03,017,01,0335,0,
+    /* 49102 */ 03,017,01,0334,0,
+    /* 49107 */ 03,017,01,0324,0,
+    /* 49112 */ 03,017,01,0302,0,
+    /* 49117 */ 03,017,01,0332,0,
+    /* 49122 */ 03,017,01,0331,0,
+    /* 49127 */ 03,017,01,0303,0,
+    /* 49132 */ 03,017,01,0330,0,
+    /* 49137 */ 03,017,01,0333,0,
+    /* 49142 */ 03,017,01,0304,0,
+    /* 49147 */ 03,017,01,0312,0,
+    /* 49152 */ 03,017,01,0313,0,
+    /* 49157 */ 03,017,0247,0300,0,
+    /* 49162 */ 02,0306,0370,020,0,
+    /* 49167 */ 03,017,01,0325,0,
+    /* 49172 */ 03,017,01,0326,0,
+    /* 49177 */ 02,017,015,0202,0,
+    /* 49182 */ 0333,02,017,011,0,
+    /* 49187 */ 02,0325,012,0,
+    /* 49191 */ 01,0325,024,0,
+    /* 49195 */ 02,0324,012,0,
+    /* 49199 */ 01,0324,024,0,
+    /* 49203 */ 01,024,021,0,
+    /* 49207 */ 01,04,021,0,
+    /* 49211 */ 01,044,021,0,
+    /* 49215 */ 02,017,072,0,
+    /* 49219 */ 02,017,073,0,
+    /* 49223 */ 0320,01,0230,0,
+    /* 49227 */ 0321,01,0231,0,
+    /* 49231 */ 0324,01,0230,0,
+    /* 49235 */ 02,017,06,0,
+    /* 49239 */ 01,070,0101,0,
+    /* 49243 */ 01,074,021,0,
+    /* 49247 */ 0335,01,0246,0,
+    /* 49251 */ 02,017,0242,0,
+    /* 49255 */ 02,017,075,0,
+    /* 49259 */ 02,017,074,0,
+    /* 49263 */ 0324,01,0231,0,
+    /* 49267 */ 0320,01,0231,0,
+    /* 49271 */ 0321,01,0230,0,
+    /* 49275 */ 0320,010,0110,0,
+    /* 49279 */ 0321,010,0110,0,
+    /* 49283 */ 01,0366,0206,0,
+    /* 49287 */ 02,017,071,0,
+    /* 49291 */ 02,017,0167,0,
+    /* 49295 */ 02,0331,0360,0,
+    /* 49299 */ 02,0331,0341,0,
+    /* 49303 */ 01,0330,0200,0,
+    /* 49307 */ 01,0334,0200,0,
+    /* 49311 */ 02,0336,0301,0,
+    /* 49315 */ 01,0337,0204,0,
+    /* 49319 */ 01,0337,0206,0,
+    /* 49323 */ 02,0331,0340,0,
+    /* 49327 */ 02,0332,0301,0,
+    /* 49331 */ 02,0332,0321,0,
+    /* 49335 */ 02,0332,0311,0,
+    /* 49339 */ 02,0333,0301,0,
+    /* 49343 */ 02,0333,0321,0,
+    /* 49347 */ 02,0333,0311,0,
+    /* 49351 */ 02,0333,0331,0,
+    /* 49355 */ 02,0332,0331,0,
+    /* 49359 */ 01,0330,0202,0,
+    /* 49363 */ 01,0334,0202,0,
+    /* 49367 */ 02,0330,0321,0,
+    /* 49371 */ 02,0333,0361,0,
+    /* 49375 */ 02,0337,0361,0,
+    /* 49379 */ 01,0330,0203,0,
+    /* 49383 */ 01,0334,0203,0,
+    /* 49387 */ 02,0330,0331,0,
+    /* 49391 */ 02,0336,0331,0,
+    /* 49395 */ 02,0331,0377,0,
+    /* 49399 */ 02,0331,0366,0,
+    /* 49403 */ 01,0330,0206,0,
+    /* 49407 */ 01,0334,0206,0,
+    /* 49411 */ 02,0336,0371,0,
+    /* 49415 */ 01,0330,0207,0,
+    /* 49419 */ 01,0334,0207,0,
+    /* 49423 */ 02,0336,0361,0,
+    /* 49427 */ 02,017,016,0,
+    /* 49431 */ 02,0335,0301,0,
+    /* 49435 */ 02,0337,0301,0,
+    /* 49439 */ 01,0332,0200,0,
+    /* 49443 */ 01,0336,0200,0,
+    /* 49447 */ 01,0332,0202,0,
+    /* 49451 */ 01,0336,0202,0,
+    /* 49455 */ 01,0332,0203,0,
+    /* 49459 */ 01,0336,0203,0,
+    /* 49463 */ 01,0332,0206,0,
+    /* 49467 */ 01,0336,0206,0,
+    /* 49471 */ 01,0332,0207,0,
+    /* 49475 */ 01,0336,0207,0,
+    /* 49479 */ 01,0333,0200,0,
+    /* 49483 */ 01,0337,0200,0,
+    /* 49487 */ 01,0337,0205,0,
+    /* 49491 */ 01,0332,0201,0,
+    /* 49495 */ 01,0336,0201,0,
+    /* 49499 */ 02,0331,0367,0,
+    /* 49503 */ 01,0333,0202,0,
+    /* 49507 */ 01,0337,0202,0,
+    /* 49511 */ 01,0333,0203,0,
+    /* 49515 */ 01,0337,0203,0,
+    /* 49519 */ 01,0337,0207,0,
+    /* 49523 */ 01,0337,0201,0,
+    /* 49527 */ 01,0333,0201,0,
+    /* 49531 */ 01,0335,0201,0,
+    /* 49535 */ 01,0332,0204,0,
+    /* 49539 */ 01,0336,0204,0,
+    /* 49543 */ 01,0332,0205,0,
+    /* 49547 */ 01,0336,0205,0,
+    /* 49551 */ 01,0331,0200,0,
+    /* 49555 */ 01,0335,0200,0,
+    /* 49559 */ 01,0333,0205,0,
+    /* 49563 */ 02,0331,0301,0,
+    /* 49567 */ 02,0331,0350,0,
+    /* 49571 */ 01,0331,0205,0,
+    /* 49575 */ 01,0331,0204,0,
+    /* 49579 */ 02,0331,0352,0,
+    /* 49583 */ 02,0331,0351,0,
+    /* 49587 */ 02,0331,0354,0,
+    /* 49591 */ 02,0331,0355,0,
+    /* 49595 */ 02,0331,0353,0,
+    /* 49599 */ 02,0331,0356,0,
+    /* 49603 */ 01,0330,0201,0,
+    /* 49607 */ 01,0334,0201,0,
+    /* 49611 */ 02,0336,0311,0,
+    /* 49615 */ 02,0331,0320,0,
+    /* 49619 */ 02,0331,0363,0,
+    /* 49623 */ 02,0331,0370,0,
+    /* 49627 */ 02,0331,0365,0,
+    /* 49631 */ 02,0331,0362,0,
+    /* 49635 */ 02,0331,0374,0,
+    /* 49639 */ 01,0335,0204,0,
+    /* 49643 */ 02,0331,0375,0,
+    /* 49647 */ 02,0333,0344,0,
+    /* 49651 */ 02,0331,0376,0,
+    /* 49655 */ 02,0331,0373,0,
+    /* 49659 */ 02,0331,0372,0,
+    /* 49663 */ 01,0331,0202,0,
+    /* 49667 */ 01,0335,0202,0,
+    /* 49671 */ 02,0335,0321,0,
+    /* 49675 */ 01,0331,0203,0,
+    /* 49679 */ 01,0335,0203,0,
+    /* 49683 */ 01,0333,0207,0,
+    /* 49687 */ 02,0335,0331,0,
+    /* 49691 */ 01,0330,0204,0,
+    /* 49695 */ 01,0334,0204,0,
+    /* 49699 */ 02,0336,0351,0,
+    /* 49703 */ 01,0330,0205,0,
+    /* 49707 */ 01,0334,0205,0,
+    /* 49711 */ 02,0336,0341,0,
+    /* 49715 */ 02,0331,0344,0,
+    /* 49719 */ 02,0335,0341,0,
+    /* 49723 */ 02,0333,0351,0,
+    /* 49727 */ 02,0337,0351,0,
+    /* 49731 */ 02,0335,0351,0,
+    /* 49735 */ 02,0332,0351,0,
+    /* 49739 */ 02,0331,0345,0,
+    /* 49743 */ 02,0331,0311,0,
+    /* 49747 */ 02,0331,0364,0,
+    /* 49751 */ 02,0331,0361,0,
+    /* 49755 */ 02,0331,0371,0,
+    /* 49759 */ 01,0366,0207,0,
+    /* 49763 */ 01,0366,0205,0,
+    /* 49767 */ 01,0344,025,0,
+    /* 49771 */ 0320,01,0355,0,
+    /* 49775 */ 0321,01,0355,0,
+    /* 49779 */ 0320,010,0100,0,
+    /* 49783 */ 0321,010,0100,0,
+    /* 49787 */ 0321,01,0155,0,
+    /* 49791 */ 0320,01,0155,0,
+    /* 49795 */ 01,0315,024,0,
+    /* 49799 */ 02,017,010,0,
+    /* 49803 */ 0322,01,0317,0,
+    /* 49807 */ 0321,01,0317,0,
+    /* 49811 */ 0324,01,0317,0,
+    /* 49815 */ 0320,01,0317,0,
+    /* 49819 */ 02,017,07,0,
+    /* 49823 */ 02,017,05,0,
+    /* 49827 */ 0321,01,0255,0,
+    /* 49831 */ 0324,01,0255,0,
+    /* 49835 */ 0320,01,0255,0,
+    /* 49839 */ 01,0240,045,0,
+    /* 49843 */ 01,0242,044,0,
+    /* 49847 */ 01,0212,0110,0,
+    /* 49851 */ 010,0260,021,0,
+    /* 49855 */ 0321,01,0245,0,
+    /* 49859 */ 0324,01,0245,0,
+    /* 49863 */ 0320,01,0245,0,
+    /* 49867 */ 01,0366,0204,0,
+    /* 49871 */ 01,014,021,0,
+    /* 49875 */ 01,0346,024,0,
+    /* 49879 */ 0320,01,0357,0,
+    /* 49883 */ 0321,01,0357,0,
+    /* 49887 */ 0321,01,0157,0,
+    /* 49891 */ 0320,01,0157,0,
+    /* 49895 */ 0333,01,0220,0,
+    /* 49899 */ 0320,010,0130,0,
+    /* 49903 */ 0321,010,0130,0,
+    /* 49907 */ 0323,010,0130,0,
+    /* 49911 */ 02,017,0241,0,
+    /* 49915 */ 02,017,0251,0,
+    /* 49919 */ 0322,01,0141,0,
+    /* 49923 */ 0321,01,0141,0,
+    /* 49927 */ 0320,01,0141,0,
+    /* 49931 */ 0322,01,0235,0,
+    /* 49935 */ 0321,01,0235,0,
+    /* 49939 */ 0320,01,0235,0,
+    /* 49943 */ 0320,010,0120,0,
+    /* 49947 */ 0321,010,0120,0,
+    /* 49951 */ 0323,010,0120,0,
+    /* 49955 */ 02,017,0240,0,
+    /* 49959 */ 02,017,0250,0,
+    /* 49963 */ 0322,01,0140,0,
+    /* 49967 */ 0321,01,0140,0,
+    /* 49971 */ 0320,01,0140,0,
+    /* 49975 */ 0322,01,0234,0,
+    /* 49979 */ 0321,01,0234,0,
+    /* 49983 */ 0320,01,0234,0,
+    /* 49987 */ 01,0320,0202,0,
+    /* 49991 */ 01,0322,0202,0,
+    /* 49995 */ 01,0320,0203,0,
+    /* 49999 */ 01,0322,0203,0,
+    /* 50003 */ 02,017,062,0,
+    /* 50007 */ 02,017,063,0,
+    /* 50011 */ 02,017,061,0,
+    /* 50015 */ 0320,01,0303,0,
+    /* 50019 */ 0320,01,0313,0,
+    /* 50023 */ 0321,01,0303,0,
+    /* 50027 */ 0321,01,0313,0,
+    /* 50031 */ 0323,01,0303,0,
+    /* 50035 */ 0324,01,0313,0,
+    /* 50039 */ 01,0320,0200,0,
+    /* 50043 */ 01,0322,0200,0,
+    /* 50047 */ 01,0320,0201,0,
+    /* 50051 */ 01,0322,0201,0,
+    /* 50055 */ 02,017,0252,0,
+    /* 50059 */ 01,0320,0204,0,
+    /* 50063 */ 01,0322,0204,0,
+    /* 50067 */ 01,0320,0207,0,
+    /* 50071 */ 01,0322,0207,0,
+    /* 50075 */ 01,034,021,0,
+    /* 50079 */ 0335,01,0256,0,
+    /* 50083 */ 01,0320,0205,0,
+    /* 50087 */ 01,0322,0205,0,
+    /* 50091 */ 02,017,070,0,
+    /* 50095 */ 02,017,0176,0,
+    /* 50099 */ 0321,01,0253,0,
+    /* 50103 */ 0324,01,0253,0,
+    /* 50107 */ 0320,01,0253,0,
+    /* 50111 */ 01,054,021,0,
+    /* 50115 */ 02,017,064,0,
+    /* 50119 */ 02,017,065,0,
+    /* 50123 */ 01,0204,0101,0,
+    /* 50127 */ 01,0204,0110,0,
+    /* 50131 */ 01,0250,021,0,
+    /* 50135 */ 02,017,0377,0,
+    /* 50139 */ 02,017,0271,0,
+    /* 50143 */ 02,017,013,0,
+    /* 50147 */ 02,017,060,0,
+    /* 50151 */ 0320,011,0220,0,
+    /* 50155 */ 0321,011,0220,0,
+    /* 50159 */ 0324,011,0220,0,
+    /* 50163 */ 0320,010,0220,0,
+    /* 50167 */ 0321,010,0220,0,
+    /* 50171 */ 0324,010,0220,0,
+    /* 50175 */ 0321,01,0220,0,
+    /* 50179 */ 01,064,021,0,
+    /* 50183 */ 02,017,067,0,
+    /* 50187 */ 01,067,0,
+    /* 50190 */ 01,077,0,
+    /* 50193 */ 01,0365,0,
+    /* 50196 */ 01,047,0,
+    /* 50199 */ 01,057,0,
+    /* 50202 */ 01,0364,0,
+    /* 50205 */ 01,0361,0,
+    /* 50208 */ 01,0154,0,
+    /* 50211 */ 01,0314,0,
+    /* 50214 */ 01,0316,0,
+    /* 50217 */ 01,0237,0,
+    /* 50220 */ 01,0254,0,
+    /* 50223 */ 01,0156,0,
+    /* 50226 */ 01,0375,0,
+};
+
+/*
+ * Bytecode frequencies (including reuse):
+ *
+ *   0:8285 |  40:   2 | 100:  50 | 140:   0 | 200: 180 | 240: 768 | 300:   1 | 340:   8
+ *   1:7845 |  41:  37 | 101: 645 | 141:   0 | 201:  94 | 241:1569 | 301:   0 | 341:  10
+ *   2:1432 |  42:  12 | 102:  14 | 142:   0 | 202: 110 | 242:   1 | 302:   0 | 342:   0
+ *   3: 242 |  43:   0 | 103:   0 | 143:   0 | 203:  89 | 243:   0 | 303:   0 | 343:   0
+ *   4:   2 |  44:   4 | 104:   0 | 144:   0 | 204: 121 | 244:   0 | 304:   0 | 344:   0
+ *   5:   0 |  45:   4 | 105:   0 | 145:   0 | 205:  88 | 245:   0 | 305:   0 | 345:   0
+ *   6:   0 |  46:   0 | 106:   0 | 146:   0 | 206: 112 | 246:   0 | 306:   0 | 346:   0
+ *   7:   0 |  47:   0 | 107:   0 | 147:   0 | 207:  89 | 247:   0 | 307:   0 | 347:   0
+ *  10:  73 |  50: 115 | 110:3168 | 150:   0 | 210:   8 | 250: 863 | 310:  14 | 350:   0
+ *  11:  26 |  51:   0 | 111:   0 | 151:   0 | 211:  14 | 251:   0 | 311:  12 | 351:   0
+ *  12:   0 |  52:   0 | 112:   0 | 152:   0 | 212:  19 | 252:   0 | 312:   5 | 352:   0
+ *  13:   0 |  53:   0 | 113:   0 | 153:   0 | 213:   9 | 253:   0 | 313:  12 | 353:   0
+ *  14:   0 |  54:   0 | 114:   0 | 154:   0 | 214:  15 | 254:   2 | 314:   1 | 354:   0
+ *  15:   2 |  55:   1 | 115:   0 | 155:   0 | 215:   2 | 255:  23 | 315:   0 | 355:   0
+ *  16:   4 |  56:   0 | 116:   0 | 156:   0 | 216:  19 | 256:   2 | 316:   0 | 356:   0
+ *  17:   0 |  57:   0 | 117:   0 | 157:   0 | 217:   7 | 257:   0 | 317:  21 | 357:   0
+ *  20:   4 |  60:   0 | 120:2566 | 160:   0 | 220:   0 | 260: 800 | 320: 435 | 360: 198
+ *  21: 107 |  61:   0 | 121:   0 | 161:   0 | 221:   0 | 261:1022 | 321: 448 | 361: 255
+ *  22: 408 |  62:   0 | 122:   0 | 162:   0 | 222:   0 | 262: 103 | 322:  52 | 362:   0
+ *  23: 195 |  63:   0 | 123:   0 | 163:   0 | 223:   0 | 263:   0 | 323: 165 | 363:   0
+ *  24:   6 |  64: 207 | 124:   0 | 164:   0 | 224:   0 | 264:   0 | 324: 389 | 364:   0
+ *  25:  67 |  65:   0 | 125:   0 | 165:   0 | 225:   0 | 265:   0 | 325:   2 | 365:   0
+ *  26:  63 |  66:   0 | 126:   0 | 166:   0 | 226:   0 | 266:   0 | 326:  13 | 366:   0
+ *  27:   1 |  67:   0 | 127:   0 | 167:   0 | 227:   0 | 267:   0 | 327:   0 | 367:   0
+ *  30:  24 |  70:   0 | 130:  35 | 170:   0 | 230:   0 | 270: 386 | 330:   0 | 370:  30
+ *  31:  36 |  71:   0 | 131:   0 | 171:   1 | 231:   0 | 271:  12 | 331:   6 | 371:   1
+ *  32:   4 |  72:   0 | 132:   0 | 172:   0 | 232:   0 | 272:   8 | 332:  64 | 372:   0
+ *  33:   0 |  73:   0 | 133:   0 | 173:   0 | 233:   0 | 273: 183 | 333: 101 | 373:  30
+ *  34:   6 |  74:   6 | 134:   0 | 174:   0 | 234:   0 | 274:   6 | 334:   2 | 374:  30
+ *  35:   2 |  75:   0 | 135:   0 | 175:  35 | 235:   0 | 275:  94 | 335:   8 | 375:  26
+ *  36:   0 |  76:   0 | 136:   0 | 176:  88 | 236:   0 | 276:  12 | 336:   8 | 376:  24
+ *  37:   0 |  77:   0 | 137:   0 | 177:  53 | 237:   0 | 277:   0 | 337:   0 | 377:   0
+ */
diff --git a/vere/ext/nasm/x86/insnsd.c b/vere/ext/nasm/x86/insnsd.c
new file mode 100644
index 0000000..53aff50
--- /dev/null
+++ b/vere/ext/nasm/x86/insnsd.c
@@ -0,0 +1,29941 @@
+/* This file auto-generated from insns.dat by insns.pl - don't edit it */
+
+#include "nasm.h"
+#include "insns.h"
+
+static const struct itemplate instrux[] = {
+    /*    0 */ {I_RESB, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    1 */ {I_RESW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    2 */ {I_RESD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    3 */ {I_RESQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    4 */ {I_REST, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    5 */ {I_RESO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    6 */ {I_RESY, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    7 */ {I_RESZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49325, 0},
+    /*    8 */ {I_AAA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50187, 1},
+    /*    9 */ {I_AAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49187, 1},
+    /*   10 */ {I_AAD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49191, 2},
+    /*   11 */ {I_AAM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49195, 1},
+    /*   12 */ {I_AAM, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49199, 2},
+    /*   13 */ {I_AAS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50190, 1},
+    /*   14 */ {I_ADC, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47247, 3},
+    /*   15 */ {I_ADC, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47248, 0},
+    /*   16 */ {I_ADC, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42741, 3},
+    /*   17 */ {I_ADC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42742, 0},
+    /*   18 */ {I_ADC, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42747, 4},
+    /*   19 */ {I_ADC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42748, 5},
+    /*   20 */ {I_ADC, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42753, 6},
+    /*   21 */ {I_ADC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42754, 7},
+    /*   22 */ {I_ADC, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+36381, 8},
+    /*   23 */ {I_ADC, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+36381, 0},
+    /*   24 */ {I_ADC, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47252, 8},
+    /*   25 */ {I_ADC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47252, 0},
+    /*   26 */ {I_ADC, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47257, 9},
+    /*   27 */ {I_ADC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47257, 5},
+    /*   28 */ {I_ADC, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47262, 10},
+    /*   29 */ {I_ADC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47262, 7},
+    /*   30 */ {I_ADC, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32864, 11},
+    /*   31 */ {I_ADC, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32871, 12},
+    /*   32 */ {I_ADC, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32878, 13},
+    /*   33 */ {I_ADC, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49203, 8},
+    /*   34 */ {I_ADC, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47267, 8},
+    /*   35 */ {I_ADC, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47272, 9},
+    /*   36 */ {I_ADC, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47277, 10},
+    /*   37 */ {I_ADC, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42759, 3},
+    /*   38 */ {I_ADC, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32885, 3},
+    /*   39 */ {I_ADC, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32892, 4},
+    /*   40 */ {I_ADC, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32899, 6},
+    /*   41 */ {I_ADC, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32885, 3},
+    /*   42 */ {I_ADC, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32892, 4},
+    /*   43 */ {I_ADD, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47282, 3},
+    /*   44 */ {I_ADD, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47283, 0},
+    /*   45 */ {I_ADD, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42771, 3},
+    /*   46 */ {I_ADD, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42772, 0},
+    /*   47 */ {I_ADD, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42777, 4},
+    /*   48 */ {I_ADD, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42778, 5},
+    /*   49 */ {I_ADD, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42783, 6},
+    /*   50 */ {I_ADD, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42784, 7},
+    /*   51 */ {I_ADD, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40154, 8},
+    /*   52 */ {I_ADD, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40154, 0},
+    /*   53 */ {I_ADD, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47287, 8},
+    /*   54 */ {I_ADD, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47287, 0},
+    /*   55 */ {I_ADD, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47292, 9},
+    /*   56 */ {I_ADD, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47292, 5},
+    /*   57 */ {I_ADD, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47297, 10},
+    /*   58 */ {I_ADD, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47297, 7},
+    /*   59 */ {I_ADD, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32906, 11},
+    /*   60 */ {I_ADD, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32913, 12},
+    /*   61 */ {I_ADD, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32920, 13},
+    /*   62 */ {I_ADD, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49207, 8},
+    /*   63 */ {I_ADD, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47302, 8},
+    /*   64 */ {I_ADD, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47307, 9},
+    /*   65 */ {I_ADD, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47312, 10},
+    /*   66 */ {I_ADD, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42789, 3},
+    /*   67 */ {I_ADD, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32927, 3},
+    /*   68 */ {I_ADD, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32934, 4},
+    /*   69 */ {I_ADD, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32941, 6},
+    /*   70 */ {I_ADD, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42789, 3},
+    /*   71 */ {I_ADD, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32927, 3},
+    /*   72 */ {I_ADD, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32934, 4},
+    /*   73 */ {I_AND, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47317, 3},
+    /*   74 */ {I_AND, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47318, 0},
+    /*   75 */ {I_AND, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42801, 3},
+    /*   76 */ {I_AND, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42802, 0},
+    /*   77 */ {I_AND, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42807, 4},
+    /*   78 */ {I_AND, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42808, 5},
+    /*   79 */ {I_AND, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42813, 6},
+    /*   80 */ {I_AND, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42814, 7},
+    /*   81 */ {I_AND, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40434, 8},
+    /*   82 */ {I_AND, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40434, 0},
+    /*   83 */ {I_AND, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47322, 8},
+    /*   84 */ {I_AND, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47322, 0},
+    /*   85 */ {I_AND, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47327, 9},
+    /*   86 */ {I_AND, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47327, 5},
+    /*   87 */ {I_AND, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47332, 10},
+    /*   88 */ {I_AND, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47332, 7},
+    /*   89 */ {I_AND, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32948, 11},
+    /*   90 */ {I_AND, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32955, 12},
+    /*   91 */ {I_AND, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+32962, 13},
+    /*   92 */ {I_AND, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49211, 8},
+    /*   93 */ {I_AND, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47337, 8},
+    /*   94 */ {I_AND, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47342, 9},
+    /*   95 */ {I_AND, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47347, 10},
+    /*   96 */ {I_AND, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42819, 3},
+    /*   97 */ {I_AND, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32969, 3},
+    /*   98 */ {I_AND, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32976, 4},
+    /*   99 */ {I_AND, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+32983, 6},
+    /*  100 */ {I_AND, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42819, 3},
+    /*  101 */ {I_AND, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32969, 3},
+    /*  102 */ {I_AND, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32976, 4},
+    /*  103 */ {I_ARPL, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+29252, 15},
+    /*  104 */ {I_ARPL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+29252, 16},
+    /*  105 */ {I_BOUND, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47352, 18},
+    /*  106 */ {I_BOUND, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47357, 19},
+    /*  107 */ {I_BSF, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+32990, 9},
+    /*  108 */ {I_BSF, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+32990, 5},
+    /*  109 */ {I_BSF, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+32997, 9},
+    /*  110 */ {I_BSF, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32997, 5},
+    /*  111 */ {I_BSF, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33004, 10},
+    /*  112 */ {I_BSF, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33004, 7},
+    /*  113 */ {I_BSR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33011, 9},
+    /*  114 */ {I_BSR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33011, 5},
+    /*  115 */ {I_BSR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33018, 9},
+    /*  116 */ {I_BSR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33018, 5},
+    /*  117 */ {I_BSR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33025, 10},
+    /*  118 */ {I_BSR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33025, 7},
+    /*  119 */ {I_BSWAP, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42831, 20},
+    /*  120 */ {I_BSWAP, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42837, 7},
+    /*  121 */ {I_BT, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42843, 9},
+    /*  122 */ {I_BT, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42843, 5},
+    /*  123 */ {I_BT, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42849, 9},
+    /*  124 */ {I_BT, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42849, 5},
+    /*  125 */ {I_BT, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42855, 10},
+    /*  126 */ {I_BT, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42855, 7},
+    /*  127 */ {I_BT, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33032, 5},
+    /*  128 */ {I_BT, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33039, 5},
+    /*  129 */ {I_BT, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33046, 7},
+    /*  130 */ {I_BTC, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33053, 4},
+    /*  131 */ {I_BTC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33054, 5},
+    /*  132 */ {I_BTC, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33060, 4},
+    /*  133 */ {I_BTC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33061, 5},
+    /*  134 */ {I_BTC, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33067, 6},
+    /*  135 */ {I_BTC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33068, 7},
+    /*  136 */ {I_BTC, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12304, 12},
+    /*  137 */ {I_BTC, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12312, 12},
+    /*  138 */ {I_BTC, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12320, 13},
+    /*  139 */ {I_BTR, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33074, 4},
+    /*  140 */ {I_BTR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33075, 5},
+    /*  141 */ {I_BTR, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33081, 4},
+    /*  142 */ {I_BTR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33082, 5},
+    /*  143 */ {I_BTR, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33088, 6},
+    /*  144 */ {I_BTR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33089, 7},
+    /*  145 */ {I_BTR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12328, 12},
+    /*  146 */ {I_BTR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12336, 12},
+    /*  147 */ {I_BTR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12344, 13},
+    /*  148 */ {I_BTS, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33095, 4},
+    /*  149 */ {I_BTS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33096, 5},
+    /*  150 */ {I_BTS, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33102, 4},
+    /*  151 */ {I_BTS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33103, 5},
+    /*  152 */ {I_BTS, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33109, 6},
+    /*  153 */ {I_BTS, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33110, 7},
+    /*  154 */ {I_BTS, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12352, 12},
+    /*  155 */ {I_BTS, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12360, 12},
+    /*  156 */ {I_BTS, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12368, 13},
+    /*  157 */ {I_CALL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47362, 21},
+    /*  158 */ {I_CALL, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47367, 22},
+    /*  159 */ {I_CALL, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47372, 23},
+    /*  160 */ {I_CALL, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47377, 24},
+    /*  161 */ {I_CALL, 2, {IMMEDIATE|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42879, 1},
+    /*  162 */ {I_CALL, 2, {IMMEDIATE|BITS16|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42885, 1},
+    /*  163 */ {I_CALL, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42885, 1},
+    /*  164 */ {I_CALL, 2, {IMMEDIATE|BITS32|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42891, 19},
+    /*  165 */ {I_CALL, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42891, 19},
+    /*  166 */ {I_CALL, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47382, 1},
+    /*  167 */ {I_CALL, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47387, 7},
+    /*  168 */ {I_CALL, 1, {MEMORY|BITS16|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47392, 0},
+    /*  169 */ {I_CALL, 1, {MEMORY|BITS32|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47397, 5},
+    /*  170 */ {I_CALL, 1, {MEMORY|BITS64|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47387, 7},
+    /*  171 */ {I_CALL, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47402, 21},
+    /*  172 */ {I_CALL, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47407, 22},
+    /*  173 */ {I_CALL, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47412, 23},
+    /*  174 */ {I_CALL, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47417, 24},
+    /*  175 */ {I_CBW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49223, 0},
+    /*  176 */ {I_CDQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49227, 5},
+    /*  177 */ {I_CDQE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49231, 7},
+    /*  178 */ {I_CLC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48819, 0},
+    /*  179 */ {I_CLD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45984, 0},
+    /*  180 */ {I_CLI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48134, 0},
+    /*  181 */ {I_CLTS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49235, 25},
+    /*  182 */ {I_CMC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50193, 0},
+    /*  183 */ {I_CMP, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+49239, 8},
+    /*  184 */ {I_CMP, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+49239, 0},
+    /*  185 */ {I_CMP, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47422, 8},
+    /*  186 */ {I_CMP, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47422, 0},
+    /*  187 */ {I_CMP, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47427, 9},
+    /*  188 */ {I_CMP, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47427, 5},
+    /*  189 */ {I_CMP, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47432, 10},
+    /*  190 */ {I_CMP, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47432, 7},
+    /*  191 */ {I_CMP, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40392, 8},
+    /*  192 */ {I_CMP, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40392, 0},
+    /*  193 */ {I_CMP, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47437, 8},
+    /*  194 */ {I_CMP, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+47437, 0},
+    /*  195 */ {I_CMP, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47442, 9},
+    /*  196 */ {I_CMP, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+47442, 5},
+    /*  197 */ {I_CMP, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+47447, 10},
+    /*  198 */ {I_CMP, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+47447, 7},
+    /*  199 */ {I_CMP, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42897, 0},
+    /*  200 */ {I_CMP, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42903, 5},
+    /*  201 */ {I_CMP, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42909, 7},
+    /*  202 */ {I_CMP, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49243, 8},
+    /*  203 */ {I_CMP, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47452, 8},
+    /*  204 */ {I_CMP, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47457, 9},
+    /*  205 */ {I_CMP, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47462, 10},
+    /*  206 */ {I_CMP, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47467, 8},
+    /*  207 */ {I_CMP, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42915, 8},
+    /*  208 */ {I_CMP, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42921, 9},
+    /*  209 */ {I_CMP, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+42927, 10},
+    /*  210 */ {I_CMP, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+47467, 8},
+    /*  211 */ {I_CMP, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42915, 8},
+    /*  212 */ {I_CMP, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42921, 9},
+    /*  213 */ {I_CMPSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49247, 0},
+    /*  214 */ {I_CMPSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47477, 5},
+    /*  215 */ {I_CMPSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47482, 7},
+    /*  216 */ {I_CMPSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47487, 0},
+    /*  217 */ {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42933, 27},
+    /*  218 */ {I_CMPXCHG, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42934, 28},
+    /*  219 */ {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33116, 27},
+    /*  220 */ {I_CMPXCHG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33117, 28},
+    /*  221 */ {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33123, 27},
+    /*  222 */ {I_CMPXCHG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33124, 28},
+    /*  223 */ {I_CMPXCHG, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33130, 6},
+    /*  224 */ {I_CMPXCHG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33131, 7},
+    /*  225 */ {I_CMPXCHG8B, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+33137, 31},
+    /*  226 */ {I_CMPXCHG16B, 1, {MEMORY|BITS128,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42951, 13},
+    /*  227 */ {I_CPUID, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49251, 28},
+    /*  228 */ {I_CPU_READ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49255, 32},
+    /*  229 */ {I_CPU_WRITE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49259, 32},
+    /*  230 */ {I_CQO, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49263, 7},
+    /*  231 */ {I_CWD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49267, 0},
+    /*  232 */ {I_CWDE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49271, 5},
+    /*  233 */ {I_DAA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50196, 1},
+    /*  234 */ {I_DAS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50199, 1},
+    /*  235 */ {I_DEC, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49275, 1},
+    /*  236 */ {I_DEC, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49279, 19},
+    /*  237 */ {I_DEC, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47497, 11},
+    /*  238 */ {I_DEC, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42957, 11},
+    /*  239 */ {I_DEC, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42963, 12},
+    /*  240 */ {I_DEC, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42969, 13},
+    /*  241 */ {I_DIV, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49283, 0},
+    /*  242 */ {I_DIV, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47502, 0},
+    /*  243 */ {I_DIV, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47507, 5},
+    /*  244 */ {I_DIV, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47512, 7},
+    /*  245 */ {I_DMINT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49287, 33},
+    /*  246 */ {I_EMMS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49291, 34},
+    /*  247 */ {I_ENTER, 2, {IMMEDIATE,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47517, 35},
+    /*  248 */ {I_EQU, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50228, 0},
+    /*  249 */ {I_EQU, 2, {IMMEDIATE|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50228, 0},
+    /*  250 */ {I_F2XM1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49295, 36},
+    /*  251 */ {I_FABS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49299, 36},
+    /*  252 */ {I_FADD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49303, 36},
+    /*  253 */ {I_FADD, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49307, 36},
+    /*  254 */ {I_FADD, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47522, 36},
+    /*  255 */ {I_FADD, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47527, 36},
+    /*  256 */ {I_FADD, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47522, 36},
+    /*  257 */ {I_FADD, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47532, 36},
+    /*  258 */ {I_FADDP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47537, 36},
+    /*  259 */ {I_FADDP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47537, 36},
+    /*  260 */ {I_FBLD, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49315, 36},
+    /*  261 */ {I_FBLD, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49315, 36},
+    /*  262 */ {I_FBSTP, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49319, 36},
+    /*  263 */ {I_FBSTP, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49319, 36},
+    /*  264 */ {I_FCHS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49323, 36},
+    /*  265 */ {I_FCLEX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47542, 36},
+    /*  266 */ {I_FCMOVB, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47547, 37},
+    /*  267 */ {I_FCMOVB, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47552, 37},
+    /*  268 */ {I_FCMOVBE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47557, 37},
+    /*  269 */ {I_FCMOVBE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47562, 37},
+    /*  270 */ {I_FCMOVE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47567, 37},
+    /*  271 */ {I_FCMOVE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47572, 37},
+    /*  272 */ {I_FCMOVNB, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47577, 37},
+    /*  273 */ {I_FCMOVNB, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47582, 37},
+    /*  274 */ {I_FCMOVNBE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47587, 37},
+    /*  275 */ {I_FCMOVNBE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47592, 37},
+    /*  276 */ {I_FCMOVNE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47597, 37},
+    /*  277 */ {I_FCMOVNE, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47602, 37},
+    /*  278 */ {I_FCMOVNU, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47607, 37},
+    /*  279 */ {I_FCMOVNU, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47612, 37},
+    /*  280 */ {I_FCMOVU, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47617, 37},
+    /*  281 */ {I_FCMOVU, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47622, 37},
+    /*  282 */ {I_FCOM, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49359, 36},
+    /*  283 */ {I_FCOM, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49363, 36},
+    /*  284 */ {I_FCOM, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47627, 36},
+    /*  285 */ {I_FCOM, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47632, 36},
+    /*  286 */ {I_FCOMI, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47637, 37},
+    /*  287 */ {I_FCOMI, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47642, 37},
+    /*  288 */ {I_FCOMIP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47647, 37},
+    /*  289 */ {I_FCOMIP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47652, 37},
+    /*  290 */ {I_FCOMP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49379, 36},
+    /*  291 */ {I_FCOMP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49383, 36},
+    /*  292 */ {I_FCOMP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47657, 36},
+    /*  293 */ {I_FCOMP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47662, 36},
+    /*  294 */ {I_FCOMPP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49391, 36},
+    /*  295 */ {I_FCOS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49395, 38},
+    /*  296 */ {I_FDECSTP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49399, 36},
+    /*  297 */ {I_FDISI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47667, 36},
+    /*  298 */ {I_FDIV, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49403, 36},
+    /*  299 */ {I_FDIV, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49407, 36},
+    /*  300 */ {I_FDIV, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47672, 36},
+    /*  301 */ {I_FDIV, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47677, 36},
+    /*  302 */ {I_FDIV, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47672, 36},
+    /*  303 */ {I_FDIV, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47682, 36},
+    /*  304 */ {I_FDIVP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47687, 36},
+    /*  305 */ {I_FDIVP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47687, 36},
+    /*  306 */ {I_FDIVR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49415, 36},
+    /*  307 */ {I_FDIVR, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49419, 36},
+    /*  308 */ {I_FDIVR, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47692, 36},
+    /*  309 */ {I_FDIVR, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47692, 36},
+    /*  310 */ {I_FDIVR, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47697, 36},
+    /*  311 */ {I_FDIVR, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47702, 36},
+    /*  312 */ {I_FDIVRP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47707, 36},
+    /*  313 */ {I_FDIVRP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47707, 36},
+    /*  314 */ {I_FEMMS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49427, 39},
+    /*  315 */ {I_FENI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47712, 36},
+    /*  316 */ {I_FFREE, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47717, 36},
+    /*  317 */ {I_FFREE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49431, 36},
+    /*  318 */ {I_FFREEP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47722, 40},
+    /*  319 */ {I_FFREEP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49435, 40},
+    /*  320 */ {I_FIADD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49439, 36},
+    /*  321 */ {I_FIADD, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49443, 36},
+    /*  322 */ {I_FICOM, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49447, 36},
+    /*  323 */ {I_FICOM, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49451, 36},
+    /*  324 */ {I_FICOMP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49455, 36},
+    /*  325 */ {I_FICOMP, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49459, 36},
+    /*  326 */ {I_FIDIV, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49463, 36},
+    /*  327 */ {I_FIDIV, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49467, 36},
+    /*  328 */ {I_FIDIVR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49471, 36},
+    /*  329 */ {I_FIDIVR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49475, 36},
+    /*  330 */ {I_FILD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49479, 36},
+    /*  331 */ {I_FILD, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49483, 36},
+    /*  332 */ {I_FILD, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49487, 36},
+    /*  333 */ {I_FIMUL, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49491, 36},
+    /*  334 */ {I_FIMUL, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49495, 36},
+    /*  335 */ {I_FINCSTP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49499, 36},
+    /*  336 */ {I_FINIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47727, 36},
+    /*  337 */ {I_FIST, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49503, 36},
+    /*  338 */ {I_FIST, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49507, 36},
+    /*  339 */ {I_FISTP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49511, 36},
+    /*  340 */ {I_FISTP, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49515, 36},
+    /*  341 */ {I_FISTP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49519, 36},
+    /*  342 */ {I_FISTTP, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49523, 41},
+    /*  343 */ {I_FISTTP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49527, 41},
+    /*  344 */ {I_FISTTP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49531, 41},
+    /*  345 */ {I_FISUB, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49535, 36},
+    /*  346 */ {I_FISUB, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49539, 36},
+    /*  347 */ {I_FISUBR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49543, 36},
+    /*  348 */ {I_FISUBR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49547, 36},
+    /*  349 */ {I_FLD, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49551, 36},
+    /*  350 */ {I_FLD, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49555, 36},
+    /*  351 */ {I_FLD, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49559, 36},
+    /*  352 */ {I_FLD, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47732, 36},
+    /*  353 */ {I_FLD1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49567, 36},
+    /*  354 */ {I_FLDCW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49571, 42},
+    /*  355 */ {I_FLDENV, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49575, 36},
+    /*  356 */ {I_FLDL2E, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49579, 36},
+    /*  357 */ {I_FLDL2T, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49583, 36},
+    /*  358 */ {I_FLDLG2, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49587, 36},
+    /*  359 */ {I_FLDLN2, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49591, 36},
+    /*  360 */ {I_FLDPI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49595, 36},
+    /*  361 */ {I_FLDZ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49599, 36},
+    /*  362 */ {I_FMUL, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49603, 36},
+    /*  363 */ {I_FMUL, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49607, 36},
+    /*  364 */ {I_FMUL, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47737, 36},
+    /*  365 */ {I_FMUL, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47737, 36},
+    /*  366 */ {I_FMUL, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47742, 36},
+    /*  367 */ {I_FMUL, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47747, 36},
+    /*  368 */ {I_FMULP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47752, 36},
+    /*  369 */ {I_FMULP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47752, 36},
+    /*  370 */ {I_FNCLEX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47543, 36},
+    /*  371 */ {I_FNDISI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47668, 36},
+    /*  372 */ {I_FNENI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47713, 36},
+    /*  373 */ {I_FNINIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47728, 36},
+    /*  374 */ {I_FNOP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49615, 36},
+    /*  375 */ {I_FNSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47758, 36},
+    /*  376 */ {I_FNSTCW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47768, 42},
+    /*  377 */ {I_FNSTENV, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47773, 36},
+    /*  378 */ {I_FNSTSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47783, 42},
+    /*  379 */ {I_FNSTSW, 1, {REG_AX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47788, 43},
+    /*  380 */ {I_FPATAN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49619, 36},
+    /*  381 */ {I_FPREM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49623, 36},
+    /*  382 */ {I_FPREM1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49627, 38},
+    /*  383 */ {I_FPTAN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49631, 36},
+    /*  384 */ {I_FRNDINT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49635, 36},
+    /*  385 */ {I_FRSTOR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49639, 36},
+    /*  386 */ {I_FSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47757, 36},
+    /*  387 */ {I_FSCALE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49643, 36},
+    /*  388 */ {I_FSETPM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49647, 43},
+    /*  389 */ {I_FSIN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49651, 38},
+    /*  390 */ {I_FSINCOS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49655, 38},
+    /*  391 */ {I_FSQRT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49659, 36},
+    /*  392 */ {I_FST, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49663, 36},
+    /*  393 */ {I_FST, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49667, 36},
+    /*  394 */ {I_FST, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47762, 36},
+    /*  395 */ {I_FSTCW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47767, 42},
+    /*  396 */ {I_FSTENV, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47772, 36},
+    /*  397 */ {I_FSTP, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49675, 36},
+    /*  398 */ {I_FSTP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49679, 36},
+    /*  399 */ {I_FSTP, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49683, 36},
+    /*  400 */ {I_FSTP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47777, 36},
+    /*  401 */ {I_FSTSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47782, 42},
+    /*  402 */ {I_FSTSW, 1, {REG_AX,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47787, 43},
+    /*  403 */ {I_FSUB, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49691, 36},
+    /*  404 */ {I_FSUB, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49695, 36},
+    /*  405 */ {I_FSUB, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47792, 36},
+    /*  406 */ {I_FSUB, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47792, 36},
+    /*  407 */ {I_FSUB, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47797, 36},
+    /*  408 */ {I_FSUB, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47802, 36},
+    /*  409 */ {I_FSUBP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47807, 36},
+    /*  410 */ {I_FSUBP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47807, 36},
+    /*  411 */ {I_FSUBR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49703, 36},
+    /*  412 */ {I_FSUBR, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49707, 36},
+    /*  413 */ {I_FSUBR, 1, {FPUREG|TO,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47812, 36},
+    /*  414 */ {I_FSUBR, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47812, 36},
+    /*  415 */ {I_FSUBR, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47817, 36},
+    /*  416 */ {I_FSUBR, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47822, 36},
+    /*  417 */ {I_FSUBRP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47827, 36},
+    /*  418 */ {I_FSUBRP, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47827, 36},
+    /*  419 */ {I_FTST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49715, 36},
+    /*  420 */ {I_FUCOM, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47832, 38},
+    /*  421 */ {I_FUCOM, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47837, 38},
+    /*  422 */ {I_FUCOMI, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47842, 37},
+    /*  423 */ {I_FUCOMI, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47847, 37},
+    /*  424 */ {I_FUCOMIP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47852, 37},
+    /*  425 */ {I_FUCOMIP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47857, 37},
+    /*  426 */ {I_FUCOMP, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47862, 38},
+    /*  427 */ {I_FUCOMP, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47867, 38},
+    /*  428 */ {I_FUCOMPP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49735, 38},
+    /*  429 */ {I_FXAM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49739, 36},
+    /*  430 */ {I_FXCH, 1, {FPUREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47872, 36},
+    /*  431 */ {I_FXCH, 2, {FPUREG,FPU0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47872, 36},
+    /*  432 */ {I_FXCH, 2, {FPU0,FPUREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+47877, 36},
+    /*  433 */ {I_FXTRACT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49747, 36},
+    /*  434 */ {I_FYL2X, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49751, 36},
+    /*  435 */ {I_FYL2XP1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49755, 36},
+    /*  436 */ {I_HLT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50202, 44},
+    /*  437 */ {I_IDIV, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49759, 0},
+    /*  438 */ {I_IDIV, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47882, 0},
+    /*  439 */ {I_IDIV, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47887, 5},
+    /*  440 */ {I_IDIV, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47892, 7},
+    /*  441 */ {I_IMUL, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49763, 0},
+    /*  442 */ {I_IMUL, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47897, 0},
+    /*  443 */ {I_IMUL, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47902, 5},
+    /*  444 */ {I_IMUL, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47907, 7},
+    /*  445 */ {I_IMUL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42975, 9},
+    /*  446 */ {I_IMUL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42975, 5},
+    /*  447 */ {I_IMUL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42981, 9},
+    /*  448 */ {I_IMUL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42981, 5},
+    /*  449 */ {I_IMUL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42987, 10},
+    /*  450 */ {I_IMUL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42987, 7},
+    /*  451 */ {I_IMUL, 3, {REG_GPR|BITS16,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+42993, 48},
+    /*  452 */ {I_IMUL, 3, {REG_GPR|BITS16,MEMORY,IMMEDIATE|BITS16,0,0}, NO_DECORATOR, nasm_bytecodes+42999, 49},
+    /*  453 */ {I_IMUL, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+42993, 35},
+    /*  454 */ {I_IMUL, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE|BITS16,0,0}, NO_DECORATOR, nasm_bytecodes+42999, 35},
+    /*  455 */ {I_IMUL, 3, {REG_GPR|BITS32,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43005, 50},
+    /*  456 */ {I_IMUL, 3, {REG_GPR|BITS32,MEMORY,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43011, 9},
+    /*  457 */ {I_IMUL, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43005, 5},
+    /*  458 */ {I_IMUL, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43011, 5},
+    /*  459 */ {I_IMUL, 3, {REG_GPR|BITS64,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43017, 51},
+    /*  460 */ {I_IMUL, 3, {REG_GPR|BITS64,MEMORY,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43023, 51},
+    /*  461 */ {I_IMUL, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+43017, 7},
+    /*  462 */ {I_IMUL, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+43023, 7},
+    /*  463 */ {I_IMUL, 2, {REG_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43035, 35},
+    /*  464 */ {I_IMUL, 2, {REG_GPR|BITS16,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43041, 35},
+    /*  465 */ {I_IMUL, 2, {REG_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43047, 5},
+    /*  466 */ {I_IMUL, 2, {REG_GPR|BITS32,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43053, 5},
+    /*  467 */ {I_IMUL, 2, {REG_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43059, 7},
+    /*  468 */ {I_IMUL, 2, {REG_GPR|BITS64,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43065, 7},
+    /*  469 */ {I_IN, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49767, 52},
+    /*  470 */ {I_IN, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47912, 52},
+    /*  471 */ {I_IN, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+47917, 53},
+    /*  472 */ {I_IN, 2, {REG_AL,REG_DX,0,0,0}, NO_DECORATOR, nasm_bytecodes+46092, 0},
+    /*  473 */ {I_IN, 2, {REG_AX,REG_DX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49771, 0},
+    /*  474 */ {I_IN, 2, {REG_EAX,REG_DX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49775, 5},
+    /*  475 */ {I_INC, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49779, 1},
+    /*  476 */ {I_INC, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49783, 19},
+    /*  477 */ {I_INC, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47922, 11},
+    /*  478 */ {I_INC, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43071, 11},
+    /*  479 */ {I_INC, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43077, 12},
+    /*  480 */ {I_INC, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43083, 13},
+    /*  481 */ {I_INSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50208, 35},
+    /*  482 */ {I_INSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49787, 5},
+    /*  483 */ {I_INSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49791, 35},
+    /*  484 */ {I_INT, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49795, 52},
+    /*  485 */ {I_INT1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50205, 5},
+    /*  486 */ {I_INT3, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50211, 0},
+    /*  487 */ {I_INTO, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50214, 1},
+    /*  488 */ {I_INVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49799, 54},
+    /*  489 */ {I_INVPCID, 2, {REG_GPR|BITS32,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+33144, 55},
+    /*  490 */ {I_INVPCID, 2, {REG_GPR|BITS64,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+33144, 56},
+    /*  491 */ {I_INVLPG, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47927, 54},
+    /*  492 */ {I_INVLPGA, 2, {REG_AX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43089, 57},
+    /*  493 */ {I_INVLPGA, 2, {REG_EAX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43095, 58},
+    /*  494 */ {I_INVLPGA, 2, {REG_RAX,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33151, 59},
+    /*  495 */ {I_INVLPGA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43096, 58},
+    /*  496 */ {I_IRET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49803, 0},
+    /*  497 */ {I_IRETD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49807, 5},
+    /*  498 */ {I_IRETQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49811, 7},
+    /*  499 */ {I_IRETW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49815, 0},
+    /*  500 */ {I_JCXZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47932, 1},
+    /*  501 */ {I_JECXZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47937, 5},
+    /*  502 */ {I_JRCXZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43101, 7},
+    /*  503 */ {I_JMP, 1, {IMMEDIATE|SHORT,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47943, 0},
+    /*  504 */ {I_JMP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47947, 21},
+    /*  505 */ {I_JMP, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47952, 22},
+    /*  506 */ {I_JMP, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47957, 23},
+    /*  507 */ {I_JMP, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47962, 24},
+    /*  508 */ {I_JMP, 2, {IMMEDIATE|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43125, 1},
+    /*  509 */ {I_JMP, 2, {IMMEDIATE|BITS16|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43131, 1},
+    /*  510 */ {I_JMP, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43131, 1},
+    /*  511 */ {I_JMP, 2, {IMMEDIATE|BITS32|COLON,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43137, 19},
+    /*  512 */ {I_JMP, 2, {IMMEDIATE|COLON,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43137, 19},
+    /*  513 */ {I_JMP, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47967, 1},
+    /*  514 */ {I_JMP, 1, {MEMORY|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47972, 7},
+    /*  515 */ {I_JMP, 1, {MEMORY|BITS16|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47977, 0},
+    /*  516 */ {I_JMP, 1, {MEMORY|BITS32|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47982, 5},
+    /*  517 */ {I_JMP, 1, {MEMORY|BITS64|FAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47972, 7},
+    /*  518 */ {I_JMP, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47987, 21},
+    /*  519 */ {I_JMP, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47992, 22},
+    /*  520 */ {I_JMP, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47997, 23},
+    /*  521 */ {I_JMP, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48002, 24},
+    /*  522 */ {I_JMPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43143, 60},
+    /*  523 */ {I_JMPE, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43149, 60},
+    /*  524 */ {I_JMPE, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43155, 60},
+    /*  525 */ {I_JMPE, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43161, 60},
+    /*  526 */ {I_JMPE, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43167, 60},
+    /*  527 */ {I_LAHF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50217, 0},
+    /*  528 */ {I_LAR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43173, 61},
+    /*  529 */ {I_LAR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43173, 62},
+    /*  530 */ {I_LAR, 2, {REG_GPR|BITS16,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43173, 63},
+    /*  531 */ {I_LAR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43179, 65},
+    /*  532 */ {I_LAR, 2, {REG_GPR|BITS32,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43179, 63},
+    /*  533 */ {I_LAR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43179, 63},
+    /*  534 */ {I_LAR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 66},
+    /*  535 */ {I_LAR, 2, {REG_GPR|BITS64,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 64},
+    /*  536 */ {I_LAR, 2, {REG_GPR|BITS64,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 64},
+    /*  537 */ {I_LAR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43185, 64},
+    /*  538 */ {I_LDS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48007, 1},
+    /*  539 */ {I_LDS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48012, 19},
+    /*  540 */ {I_LEA, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48017, 67},
+    /*  541 */ {I_LEA, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48022, 68},
+    /*  542 */ {I_LEA, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48027, 69},
+    /*  543 */ {I_LEAVE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48279, 35},
+    /*  544 */ {I_LES, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48032, 1},
+    /*  545 */ {I_LES, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48037, 19},
+    /*  546 */ {I_LFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43191, 59},
+    /*  547 */ {I_LFS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43197, 5},
+    /*  548 */ {I_LFS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43203, 5},
+    /*  549 */ {I_LFS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43209, 7},
+    /*  550 */ {I_LGDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48042, 25},
+    /*  551 */ {I_LGS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43215, 5},
+    /*  552 */ {I_LGS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43221, 5},
+    /*  553 */ {I_LGS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43227, 7},
+    /*  554 */ {I_LIDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48047, 25},
+    /*  555 */ {I_LLDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48052, 70},
+    /*  556 */ {I_LLDT, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48052, 70},
+    /*  557 */ {I_LLDT, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48052, 70},
+    /*  558 */ {I_LMSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48057, 25},
+    /*  559 */ {I_LMSW, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48057, 25},
+    /*  560 */ {I_LMSW, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48057, 25},
+    /*  561 */ {I_LODSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50220, 0},
+    /*  562 */ {I_LODSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49827, 5},
+    /*  563 */ {I_LODSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49831, 7},
+    /*  564 */ {I_LODSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49835, 0},
+    /*  565 */ {I_LOOP, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48062, 0},
+    /*  566 */ {I_LOOP, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48067, 1},
+    /*  567 */ {I_LOOP, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48072, 5},
+    /*  568 */ {I_LOOP, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48077, 7},
+    /*  569 */ {I_LOOPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48082, 0},
+    /*  570 */ {I_LOOPE, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48087, 1},
+    /*  571 */ {I_LOOPE, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48092, 5},
+    /*  572 */ {I_LOOPE, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48097, 7},
+    /*  573 */ {I_LOOPNE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48102, 0},
+    /*  574 */ {I_LOOPNE, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48107, 1},
+    /*  575 */ {I_LOOPNE, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48112, 5},
+    /*  576 */ {I_LOOPNE, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48117, 7},
+    /*  577 */ {I_LOOPNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48102, 0},
+    /*  578 */ {I_LOOPNZ, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48107, 1},
+    /*  579 */ {I_LOOPNZ, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48112, 5},
+    /*  580 */ {I_LOOPNZ, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48117, 7},
+    /*  581 */ {I_LOOPZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48082, 0},
+    /*  582 */ {I_LOOPZ, 2, {IMMEDIATE,REG_CX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48087, 1},
+    /*  583 */ {I_LOOPZ, 2, {IMMEDIATE,REG_ECX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48092, 5},
+    /*  584 */ {I_LOOPZ, 2, {IMMEDIATE,REG_RCX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48097, 7},
+    /*  585 */ {I_LSL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43233, 61},
+    /*  586 */ {I_LSL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43233, 62},
+    /*  587 */ {I_LSL, 2, {REG_GPR|BITS16,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43233, 63},
+    /*  588 */ {I_LSL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43239, 65},
+    /*  589 */ {I_LSL, 2, {REG_GPR|BITS32,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43239, 63},
+    /*  590 */ {I_LSL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43239, 63},
+    /*  591 */ {I_LSL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 66},
+    /*  592 */ {I_LSL, 2, {REG_GPR|BITS64,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 64},
+    /*  593 */ {I_LSL, 2, {REG_GPR|BITS64,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 64},
+    /*  594 */ {I_LSL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43245, 64},
+    /*  595 */ {I_LSS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43251, 5},
+    /*  596 */ {I_LSS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43257, 5},
+    /*  597 */ {I_LSS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43263, 7},
+    /*  598 */ {I_LTR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48122, 70},
+    /*  599 */ {I_LTR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48122, 70},
+    /*  600 */ {I_LTR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48122, 70},
+    /*  601 */ {I_MFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43269, 59},
+    /*  602 */ {I_MONITOR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48127, 72},
+    /*  603 */ {I_MONITORX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48132, 74},
+    /*  604 */ {I_MOV, 2, {MEMORY,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48153, 75},
+    /*  605 */ {I_MOV, 2, {REG_GPR|BITS16,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48137, 0},
+    /*  606 */ {I_MOV, 2, {REG_GPR|BITS32,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48142, 5},
+    /*  607 */ {I_MOV, 2, {RM_GPR|BITS64,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+48152, 7},
+    /*  608 */ {I_MOV, 2, {REG_SREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48173, 75},
+    /*  609 */ {I_MOV, 2, {REG_SREG,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48162, 0},
+    /*  610 */ {I_MOV, 2, {REG_SREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48167, 5},
+    /*  611 */ {I_MOV, 2, {REG_SREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48172, 7},
+    /*  612 */ {I_MOV, 2, {REG_AL,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+49839, 8},
+    /*  613 */ {I_MOV, 2, {REG_AX,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+48177, 8},
+    /*  614 */ {I_MOV, 2, {REG_EAX,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+48182, 9},
+    /*  615 */ {I_MOV, 2, {REG_RAX,MEM_OFFS,0,0,0}, NO_DECORATOR, nasm_bytecodes+48187, 10},
+    /*  616 */ {I_MOV, 2, {MEM_OFFS,REG_AL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49843, 79},
+    /*  617 */ {I_MOV, 2, {MEM_OFFS,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48192, 79},
+    /*  618 */ {I_MOV, 2, {MEM_OFFS,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48197, 80},
+    /*  619 */ {I_MOV, 2, {MEM_OFFS,REG_RAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48202, 81},
+    /*  620 */ {I_MOV, 2, {REG_GPR|BITS32,REG_CREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43275, 82},
+    /*  621 */ {I_MOV, 2, {REG_GPR|BITS64,REG_CREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43281, 83},
+    /*  622 */ {I_MOV, 2, {REG_CREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43287, 82},
+    /*  623 */ {I_MOV, 2, {REG_CREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43293, 83},
+    /*  624 */ {I_MOV, 2, {REG_GPR|BITS32,REG_DREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43300, 82},
+    /*  625 */ {I_MOV, 2, {REG_GPR|BITS64,REG_DREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43299, 83},
+    /*  626 */ {I_MOV, 2, {REG_DREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43306, 82},
+    /*  627 */ {I_MOV, 2, {REG_DREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43305, 83},
+    /*  628 */ {I_MOV, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48217, 8},
+    /*  629 */ {I_MOV, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48218, 0},
+    /*  630 */ {I_MOV, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43311, 8},
+    /*  631 */ {I_MOV, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43312, 0},
+    /*  632 */ {I_MOV, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43317, 9},
+    /*  633 */ {I_MOV, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43318, 5},
+    /*  634 */ {I_MOV, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43323, 10},
+    /*  635 */ {I_MOV, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43324, 7},
+    /*  636 */ {I_MOV, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+49847, 8},
+    /*  637 */ {I_MOV, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+49847, 0},
+    /*  638 */ {I_MOV, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48222, 8},
+    /*  639 */ {I_MOV, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48222, 0},
+    /*  640 */ {I_MOV, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48227, 9},
+    /*  641 */ {I_MOV, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48227, 5},
+    /*  642 */ {I_MOV, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48232, 10},
+    /*  643 */ {I_MOV, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48232, 7},
+    /*  644 */ {I_MOV, 2, {REG_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49851, 8},
+    /*  645 */ {I_MOV, 2, {REG_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48237, 8},
+    /*  646 */ {I_MOV, 2, {REG_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48242, 9},
+    /*  647 */ {I_MOV, 2, {REG_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48252, 10},
+    /*  648 */ {I_MOV, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43329, 8},
+    /*  649 */ {I_MOV, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33186, 8},
+    /*  650 */ {I_MOV, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33193, 9},
+    /*  651 */ {I_MOV, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33200, 10},
+    /*  652 */ {I_MOV, 2, {RM_GPR|BITS64,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33200, 7},
+    /*  653 */ {I_MOV, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43329, 8},
+    /*  654 */ {I_MOV, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33186, 8},
+    /*  655 */ {I_MOV, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33193, 9},
+    /*  656 */ {I_MOVD, 2, {MMXREG,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43335, 85},
+    /*  657 */ {I_MOVD, 2, {RM_GPR|BITS32,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43341, 85},
+    /*  658 */ {I_MOVQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43347, 87},
+    /*  659 */ {I_MOVQ, 2, {RM_MMX,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+43353, 87},
+    /*  660 */ {I_MOVQ, 2, {MMXREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33207, 88},
+    /*  661 */ {I_MOVQ, 2, {RM_GPR|BITS64,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+33214, 88},
+    /*  662 */ {I_MOVSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12437, 0},
+    /*  663 */ {I_MOVSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49855, 5},
+    /*  664 */ {I_MOVSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49859, 7},
+    /*  665 */ {I_MOVSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49863, 0},
+    /*  666 */ {I_MOVSX, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43359, 53},
+    /*  667 */ {I_MOVSX, 2, {REG_GPR|BITS16,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43359, 5},
+    /*  668 */ {I_MOVSX, 2, {REG_GPR|BITS32,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43365, 5},
+    /*  669 */ {I_MOVSX, 2, {REG_GPR|BITS32,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43371, 5},
+    /*  670 */ {I_MOVSX, 2, {REG_GPR|BITS64,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43377, 7},
+    /*  671 */ {I_MOVSX, 2, {REG_GPR|BITS64,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43383, 7},
+    /*  672 */ {I_MOVSXD, 2, {REG_GPR|BITS64,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48257, 7},
+    /*  673 */ {I_MOVZX, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43389, 53},
+    /*  674 */ {I_MOVZX, 2, {REG_GPR|BITS16,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43389, 5},
+    /*  675 */ {I_MOVZX, 2, {REG_GPR|BITS32,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43395, 5},
+    /*  676 */ {I_MOVZX, 2, {REG_GPR|BITS32,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43401, 5},
+    /*  677 */ {I_MOVZX, 2, {REG_GPR|BITS64,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43407, 7},
+    /*  678 */ {I_MOVZX, 2, {REG_GPR|BITS64,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43413, 7},
+    /*  679 */ {I_MUL, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49867, 0},
+    /*  680 */ {I_MUL, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48262, 0},
+    /*  681 */ {I_MUL, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48267, 5},
+    /*  682 */ {I_MUL, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48272, 7},
+    /*  683 */ {I_MWAIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48277, 72},
+    /*  684 */ {I_MWAITX, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48282, 74},
+    /*  685 */ {I_NEG, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48287, 11},
+    /*  686 */ {I_NEG, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43419, 11},
+    /*  687 */ {I_NEG, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43425, 12},
+    /*  688 */ {I_NEG, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43431, 13},
+    /*  689 */ {I_NOP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48292, 0},
+    /*  690 */ {I_NOP, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43437, 89},
+    /*  691 */ {I_NOP, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43443, 89},
+    /*  692 */ {I_NOP, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43449, 7},
+    /*  693 */ {I_NOT, 1, {RM_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48297, 11},
+    /*  694 */ {I_NOT, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43455, 11},
+    /*  695 */ {I_NOT, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43461, 12},
+    /*  696 */ {I_NOT, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43467, 13},
+    /*  697 */ {I_OR, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48302, 3},
+    /*  698 */ {I_OR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48303, 0},
+    /*  699 */ {I_OR, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43473, 3},
+    /*  700 */ {I_OR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43474, 0},
+    /*  701 */ {I_OR, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43479, 4},
+    /*  702 */ {I_OR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43480, 5},
+    /*  703 */ {I_OR, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43485, 6},
+    /*  704 */ {I_OR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43486, 7},
+    /*  705 */ {I_OR, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40679, 8},
+    /*  706 */ {I_OR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40679, 0},
+    /*  707 */ {I_OR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48307, 8},
+    /*  708 */ {I_OR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48307, 0},
+    /*  709 */ {I_OR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48312, 9},
+    /*  710 */ {I_OR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48312, 5},
+    /*  711 */ {I_OR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48317, 10},
+    /*  712 */ {I_OR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48317, 7},
+    /*  713 */ {I_OR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33221, 11},
+    /*  714 */ {I_OR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33228, 12},
+    /*  715 */ {I_OR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33235, 13},
+    /*  716 */ {I_OR, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+49871, 8},
+    /*  717 */ {I_OR, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48322, 8},
+    /*  718 */ {I_OR, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48327, 9},
+    /*  719 */ {I_OR, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48332, 10},
+    /*  720 */ {I_OR, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43491, 3},
+    /*  721 */ {I_OR, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33242, 3},
+    /*  722 */ {I_OR, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33249, 4},
+    /*  723 */ {I_OR, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33256, 6},
+    /*  724 */ {I_OR, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43491, 3},
+    /*  725 */ {I_OR, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33242, 3},
+    /*  726 */ {I_OR, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33249, 4},
+    /*  727 */ {I_OUT, 2, {IMMEDIATE,REG_AL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49875, 52},
+    /*  728 */ {I_OUT, 2, {IMMEDIATE,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48337, 52},
+    /*  729 */ {I_OUT, 2, {IMMEDIATE,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+48342, 53},
+    /*  730 */ {I_OUT, 2, {REG_DX,REG_AL,0,0,0}, NO_DECORATOR, nasm_bytecodes+46074, 0},
+    /*  731 */ {I_OUT, 2, {REG_DX,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49879, 0},
+    /*  732 */ {I_OUT, 2, {REG_DX,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+49883, 5},
+    /*  733 */ {I_OUTSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50223, 35},
+    /*  734 */ {I_OUTSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49887, 5},
+    /*  735 */ {I_OUTSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49891, 35},
+    /*  736 */ {I_PACKSSDW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33263, 87},
+    /*  737 */ {I_PACKSSWB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33270, 87},
+    /*  738 */ {I_PACKUSWB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33277, 87},
+    /*  739 */ {I_PADDB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33284, 87},
+    /*  740 */ {I_PADDD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33291, 87},
+    /*  741 */ {I_PADDSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33298, 87},
+    /*  742 */ {I_PADDSIW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43503, 90},
+    /*  743 */ {I_PADDSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33305, 87},
+    /*  744 */ {I_PADDUSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33312, 87},
+    /*  745 */ {I_PADDUSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33319, 87},
+    /*  746 */ {I_PADDW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33326, 87},
+    /*  747 */ {I_PAND, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33333, 87},
+    /*  748 */ {I_PANDN, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33340, 87},
+    /*  749 */ {I_PAUSE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49895, 0},
+    /*  750 */ {I_PAVEB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43509, 90},
+    /*  751 */ {I_PAVGUSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12376, 91},
+    /*  752 */ {I_PCMPEQB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33347, 87},
+    /*  753 */ {I_PCMPEQD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33354, 87},
+    /*  754 */ {I_PCMPEQW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33361, 87},
+    /*  755 */ {I_PCMPGTB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33368, 87},
+    /*  756 */ {I_PCMPGTD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33375, 87},
+    /*  757 */ {I_PCMPGTW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33382, 87},
+    /*  758 */ {I_PDISTIB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45376, 92},
+    /*  759 */ {I_PF2ID, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12384, 91},
+    /*  760 */ {I_PFACC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12392, 91},
+    /*  761 */ {I_PFADD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12400, 91},
+    /*  762 */ {I_PFCMPEQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12408, 91},
+    /*  763 */ {I_PFCMPGE, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12416, 91},
+    /*  764 */ {I_PFCMPGT, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12424, 91},
+    /*  765 */ {I_PFMAX, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12432, 91},
+    /*  766 */ {I_PFMIN, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12440, 91},
+    /*  767 */ {I_PFMUL, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12448, 91},
+    /*  768 */ {I_PFRCP, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12456, 91},
+    /*  769 */ {I_PFRCPIT1, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12464, 91},
+    /*  770 */ {I_PFRCPIT2, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12472, 91},
+    /*  771 */ {I_PFRSQIT1, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12480, 91},
+    /*  772 */ {I_PFRSQRT, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12488, 91},
+    /*  773 */ {I_PFSUB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12496, 91},
+    /*  774 */ {I_PFSUBR, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12504, 91},
+    /*  775 */ {I_PI2FD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12512, 91},
+    /*  776 */ {I_PMACHRIW, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45472, 92},
+    /*  777 */ {I_PMADDWD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33389, 87},
+    /*  778 */ {I_PMAGW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43515, 90},
+    /*  779 */ {I_PMULHRIW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43521, 90},
+    /*  780 */ {I_PMULHRWA, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12520, 91},
+    /*  781 */ {I_PMULHRWC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43527, 90},
+    /*  782 */ {I_PMULHW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33396, 87},
+    /*  783 */ {I_PMULLW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33403, 87},
+    /*  784 */ {I_PMVGEZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45604, 90},
+    /*  785 */ {I_PMVLZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45460, 90},
+    /*  786 */ {I_PMVNZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45442, 90},
+    /*  787 */ {I_PMVZB, 2, {MMXREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45364, 90},
+    /*  788 */ {I_POP, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49899, 0},
+    /*  789 */ {I_POP, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49903, 19},
+    /*  790 */ {I_POP, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49907, 7},
+    /*  791 */ {I_POP, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48347, 0},
+    /*  792 */ {I_POP, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48352, 19},
+    /*  793 */ {I_POP, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48357, 7},
+    /*  794 */ {I_POP, 1, {REG_ES,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12813, 1},
+    /*  795 */ {I_POP, 1, {REG_SS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7621, 1},
+    /*  796 */ {I_POP, 1, {REG_DS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7765, 1},
+    /*  797 */ {I_POP, 1, {REG_FS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49911, 5},
+    /*  798 */ {I_POP, 1, {REG_GS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49915, 5},
+    /*  799 */ {I_POPA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49919, 18},
+    /*  800 */ {I_POPAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49923, 19},
+    /*  801 */ {I_POPAW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49927, 18},
+    /*  802 */ {I_POPF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49931, 0},
+    /*  803 */ {I_POPFD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49935, 19},
+    /*  804 */ {I_POPFQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49935, 7},
+    /*  805 */ {I_POPFW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49939, 0},
+    /*  806 */ {I_POR, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33410, 87},
+    /*  807 */ {I_PREFETCH, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48362, 91},
+    /*  808 */ {I_PREFETCHW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48367, 91},
+    /*  809 */ {I_PSLLD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33417, 87},
+    /*  810 */ {I_PSLLD, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33424, 34},
+    /*  811 */ {I_PSLLQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33431, 87},
+    /*  812 */ {I_PSLLQ, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33438, 34},
+    /*  813 */ {I_PSLLW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33445, 87},
+    /*  814 */ {I_PSLLW, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33452, 34},
+    /*  815 */ {I_PSRAD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33459, 87},
+    /*  816 */ {I_PSRAD, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33466, 34},
+    /*  817 */ {I_PSRAW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33473, 87},
+    /*  818 */ {I_PSRAW, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33480, 34},
+    /*  819 */ {I_PSRLD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33487, 87},
+    /*  820 */ {I_PSRLD, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33494, 34},
+    /*  821 */ {I_PSRLQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33501, 87},
+    /*  822 */ {I_PSRLQ, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33508, 34},
+    /*  823 */ {I_PSRLW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33515, 87},
+    /*  824 */ {I_PSRLW, 2, {MMXREG,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33522, 34},
+    /*  825 */ {I_PSUBB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33529, 87},
+    /*  826 */ {I_PSUBD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33536, 87},
+    /*  827 */ {I_PSUBSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33543, 87},
+    /*  828 */ {I_PSUBSIW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+43533, 90},
+    /*  829 */ {I_PSUBSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33550, 87},
+    /*  830 */ {I_PSUBUSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33557, 87},
+    /*  831 */ {I_PSUBUSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33564, 87},
+    /*  832 */ {I_PSUBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33571, 87},
+    /*  833 */ {I_PUNPCKHBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33578, 87},
+    /*  834 */ {I_PUNPCKHDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33585, 87},
+    /*  835 */ {I_PUNPCKHWD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33592, 87},
+    /*  836 */ {I_PUNPCKLBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33599, 87},
+    /*  837 */ {I_PUNPCKLDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33606, 87},
+    /*  838 */ {I_PUNPCKLWD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33613, 87},
+    /*  839 */ {I_PUSH, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49943, 0},
+    /*  840 */ {I_PUSH, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49947, 19},
+    /*  841 */ {I_PUSH, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49951, 7},
+    /*  842 */ {I_PUSH, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48372, 0},
+    /*  843 */ {I_PUSH, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48377, 19},
+    /*  844 */ {I_PUSH, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48382, 7},
+    /*  845 */ {I_PUSH, 1, {REG_ES,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12781, 1},
+    /*  846 */ {I_PUSH, 1, {REG_CS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7477, 1},
+    /*  847 */ {I_PUSH, 1, {REG_SS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7603, 1},
+    /*  848 */ {I_PUSH, 1, {REG_DS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+7747, 1},
+    /*  849 */ {I_PUSH, 1, {REG_FS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49955, 5},
+    /*  850 */ {I_PUSH, 1, {REG_GS,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49959, 5},
+    /*  851 */ {I_PUSH, 1, {IMMEDIATE|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48408, 35},
+    /*  852 */ {I_PUSH, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48392, 94},
+    /*  853 */ {I_PUSH, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48402, 95},
+    /*  854 */ {I_PUSH, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48402, 96},
+    /*  855 */ {I_PUSH, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48412, 97},
+    /*  856 */ {I_PUSH, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48412, 97},
+    /*  857 */ {I_PUSHA, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49963, 18},
+    /*  858 */ {I_PUSHAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49967, 19},
+    /*  859 */ {I_PUSHAW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49971, 18},
+    /*  860 */ {I_PUSHF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49975, 0},
+    /*  861 */ {I_PUSHFD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49979, 19},
+    /*  862 */ {I_PUSHFQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49979, 7},
+    /*  863 */ {I_PUSHFW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49983, 0},
+    /*  864 */ {I_PXOR, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+33620, 87},
+    /*  865 */ {I_RCL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+49987, 0},
+    /*  866 */ {I_RCL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49991, 0},
+    /*  867 */ {I_RCL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48417, 35},
+    /*  868 */ {I_RCL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48422, 0},
+    /*  869 */ {I_RCL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48427, 0},
+    /*  870 */ {I_RCL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43539, 35},
+    /*  871 */ {I_RCL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48432, 5},
+    /*  872 */ {I_RCL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48437, 5},
+    /*  873 */ {I_RCL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43545, 5},
+    /*  874 */ {I_RCL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48442, 7},
+    /*  875 */ {I_RCL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48447, 7},
+    /*  876 */ {I_RCL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43551, 7},
+    /*  877 */ {I_RCR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+49995, 0},
+    /*  878 */ {I_RCR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+49999, 0},
+    /*  879 */ {I_RCR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48452, 35},
+    /*  880 */ {I_RCR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48457, 0},
+    /*  881 */ {I_RCR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48462, 0},
+    /*  882 */ {I_RCR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43557, 35},
+    /*  883 */ {I_RCR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48467, 5},
+    /*  884 */ {I_RCR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48472, 5},
+    /*  885 */ {I_RCR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43563, 5},
+    /*  886 */ {I_RCR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48477, 7},
+    /*  887 */ {I_RCR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48482, 7},
+    /*  888 */ {I_RCR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43569, 7},
+    /*  889 */ {I_RDSHR, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43575, 98},
+    /*  890 */ {I_RDMSR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50003, 99},
+    /*  891 */ {I_RDPMC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50007, 89},
+    /*  892 */ {I_RDTSC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50011, 28},
+    /*  893 */ {I_RDTSCP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48487, 100},
+    /*  894 */ {I_RET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50032, 21},
+    /*  895 */ {I_RET, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48513, 101},
+    /*  896 */ {I_RETF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50036, 0},
+    /*  897 */ {I_RETF, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48518, 75},
+    /*  898 */ {I_RETN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50032, 21},
+    /*  899 */ {I_RETN, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48513, 101},
+    /*  900 */ {I_RETW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50015, 21},
+    /*  901 */ {I_RETW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48513, 101},
+    /*  902 */ {I_RETFW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50019, 0},
+    /*  903 */ {I_RETFW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48492, 75},
+    /*  904 */ {I_RETNW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50015, 21},
+    /*  905 */ {I_RETNW, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48497, 101},
+    /*  906 */ {I_RETD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50023, 22},
+    /*  907 */ {I_RETD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48502, 102},
+    /*  908 */ {I_RETFD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50027, 0},
+    /*  909 */ {I_RETFD, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48507, 75},
+    /*  910 */ {I_RETND, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50023, 22},
+    /*  911 */ {I_RETND, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48502, 102},
+    /*  912 */ {I_RETQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50031, 24},
+    /*  913 */ {I_RETQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48512, 103},
+    /*  914 */ {I_RETFQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50035, 7},
+    /*  915 */ {I_RETFQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48517, 104},
+    /*  916 */ {I_RETNQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50031, 24},
+    /*  917 */ {I_RETNQ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48512, 103},
+    /*  918 */ {I_ROL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50039, 0},
+    /*  919 */ {I_ROL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50043, 0},
+    /*  920 */ {I_ROL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48522, 35},
+    /*  921 */ {I_ROL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48527, 0},
+    /*  922 */ {I_ROL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48532, 0},
+    /*  923 */ {I_ROL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43581, 35},
+    /*  924 */ {I_ROL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48537, 5},
+    /*  925 */ {I_ROL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48542, 5},
+    /*  926 */ {I_ROL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43587, 5},
+    /*  927 */ {I_ROL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48547, 7},
+    /*  928 */ {I_ROL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48552, 7},
+    /*  929 */ {I_ROL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43593, 7},
+    /*  930 */ {I_ROR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50047, 0},
+    /*  931 */ {I_ROR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50051, 0},
+    /*  932 */ {I_ROR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48557, 35},
+    /*  933 */ {I_ROR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48562, 0},
+    /*  934 */ {I_ROR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48567, 0},
+    /*  935 */ {I_ROR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43599, 35},
+    /*  936 */ {I_ROR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48572, 5},
+    /*  937 */ {I_ROR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48577, 5},
+    /*  938 */ {I_ROR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43605, 5},
+    /*  939 */ {I_ROR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48582, 7},
+    /*  940 */ {I_ROR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48587, 7},
+    /*  941 */ {I_ROR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43611, 7},
+    /*  942 */ {I_RSDC, 2, {REG_SREG,MEMORY|BITS80,0,0,0}, NO_DECORATOR, nasm_bytecodes+45742, 105},
+    /*  943 */ {I_RSLDT, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48592, 105},
+    /*  944 */ {I_RSM, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50055, 106},
+    /*  945 */ {I_RSTS, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48597, 105},
+    /*  946 */ {I_SAHF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12405, 0},
+    /*  947 */ {I_SALC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49174, 107},
+    /*  948 */ {I_SAR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50067, 0},
+    /*  949 */ {I_SAR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50071, 0},
+    /*  950 */ {I_SAR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48637, 35},
+    /*  951 */ {I_SAR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48642, 0},
+    /*  952 */ {I_SAR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48647, 0},
+    /*  953 */ {I_SAR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43635, 35},
+    /*  954 */ {I_SAR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48652, 5},
+    /*  955 */ {I_SAR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48657, 5},
+    /*  956 */ {I_SAR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43641, 5},
+    /*  957 */ {I_SAR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48662, 7},
+    /*  958 */ {I_SAR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48667, 7},
+    /*  959 */ {I_SAR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43647, 7},
+    /*  960 */ {I_SBB, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48672, 3},
+    /*  961 */ {I_SBB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48673, 0},
+    /*  962 */ {I_SBB, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43653, 3},
+    /*  963 */ {I_SBB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43654, 0},
+    /*  964 */ {I_SBB, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43659, 4},
+    /*  965 */ {I_SBB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43660, 5},
+    /*  966 */ {I_SBB, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43665, 6},
+    /*  967 */ {I_SBB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43666, 7},
+    /*  968 */ {I_SBB, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+35268, 8},
+    /*  969 */ {I_SBB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+35268, 0},
+    /*  970 */ {I_SBB, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48677, 8},
+    /*  971 */ {I_SBB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48677, 0},
+    /*  972 */ {I_SBB, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48682, 9},
+    /*  973 */ {I_SBB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48682, 5},
+    /*  974 */ {I_SBB, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48687, 10},
+    /*  975 */ {I_SBB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48687, 7},
+    /*  976 */ {I_SBB, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33627, 11},
+    /*  977 */ {I_SBB, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33634, 12},
+    /*  978 */ {I_SBB, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33641, 13},
+    /*  979 */ {I_SBB, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50075, 8},
+    /*  980 */ {I_SBB, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48692, 8},
+    /*  981 */ {I_SBB, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48697, 9},
+    /*  982 */ {I_SBB, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48702, 10},
+    /*  983 */ {I_SBB, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43671, 3},
+    /*  984 */ {I_SBB, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33648, 3},
+    /*  985 */ {I_SBB, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33655, 4},
+    /*  986 */ {I_SBB, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33662, 6},
+    /*  987 */ {I_SBB, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43671, 3},
+    /*  988 */ {I_SBB, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33648, 3},
+    /*  989 */ {I_SBB, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33655, 4},
+    /*  990 */ {I_SCASB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50079, 0},
+    /*  991 */ {I_SCASD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48707, 5},
+    /*  992 */ {I_SCASQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48712, 7},
+    /*  993 */ {I_SCASW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48717, 0},
+    /*  994 */ {I_SFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43683, 59},
+    /*  995 */ {I_SGDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48722, 108},
+    /*  996 */ {I_SHL, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50059, 0},
+    /*  997 */ {I_SHL, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50063, 0},
+    /*  998 */ {I_SHL, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48602, 35},
+    /*  999 */ {I_SHL, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48607, 0},
+    /* 1000 */ {I_SHL, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48612, 0},
+    /* 1001 */ {I_SHL, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43617, 35},
+    /* 1002 */ {I_SHL, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48617, 5},
+    /* 1003 */ {I_SHL, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48622, 5},
+    /* 1004 */ {I_SHL, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43623, 5},
+    /* 1005 */ {I_SHL, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48627, 7},
+    /* 1006 */ {I_SHL, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48632, 7},
+    /* 1007 */ {I_SHL, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43629, 7},
+    /* 1008 */ {I_SHLD, 3, {MEMORY,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33669, 109},
+    /* 1009 */ {I_SHLD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33669, 109},
+    /* 1010 */ {I_SHLD, 3, {MEMORY,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33676, 109},
+    /* 1011 */ {I_SHLD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33676, 109},
+    /* 1012 */ {I_SHLD, 3, {MEMORY,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33683, 110},
+    /* 1013 */ {I_SHLD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33683, 110},
+    /* 1014 */ {I_SHLD, 3, {MEMORY,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43689, 9},
+    /* 1015 */ {I_SHLD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43689, 5},
+    /* 1016 */ {I_SHLD, 3, {MEMORY,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43695, 9},
+    /* 1017 */ {I_SHLD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43695, 5},
+    /* 1018 */ {I_SHLD, 3, {MEMORY,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43701, 10},
+    /* 1019 */ {I_SHLD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43701, 7},
+    /* 1020 */ {I_SHR, 2, {RM_GPR|BITS8,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50083, 0},
+    /* 1021 */ {I_SHR, 2, {RM_GPR|BITS8,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+50087, 0},
+    /* 1022 */ {I_SHR, 2, {RM_GPR|BITS8,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48727, 35},
+    /* 1023 */ {I_SHR, 2, {RM_GPR|BITS16,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48732, 0},
+    /* 1024 */ {I_SHR, 2, {RM_GPR|BITS16,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48737, 0},
+    /* 1025 */ {I_SHR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43707, 35},
+    /* 1026 */ {I_SHR, 2, {RM_GPR|BITS32,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48742, 5},
+    /* 1027 */ {I_SHR, 2, {RM_GPR|BITS32,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48747, 5},
+    /* 1028 */ {I_SHR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43713, 5},
+    /* 1029 */ {I_SHR, 2, {RM_GPR|BITS64,UNITY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48752, 7},
+    /* 1030 */ {I_SHR, 2, {RM_GPR|BITS64,REG_CL,0,0,0}, NO_DECORATOR, nasm_bytecodes+48757, 7},
+    /* 1031 */ {I_SHR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43719, 7},
+    /* 1032 */ {I_SHRD, 3, {MEMORY,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33690, 109},
+    /* 1033 */ {I_SHRD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33690, 109},
+    /* 1034 */ {I_SHRD, 3, {MEMORY,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33697, 109},
+    /* 1035 */ {I_SHRD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33697, 109},
+    /* 1036 */ {I_SHRD, 3, {MEMORY,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33704, 110},
+    /* 1037 */ {I_SHRD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+33704, 110},
+    /* 1038 */ {I_SHRD, 3, {MEMORY,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43725, 9},
+    /* 1039 */ {I_SHRD, 3, {REG_GPR|BITS16,REG_GPR|BITS16,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43725, 5},
+    /* 1040 */ {I_SHRD, 3, {MEMORY,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43731, 9},
+    /* 1041 */ {I_SHRD, 3, {REG_GPR|BITS32,REG_GPR|BITS32,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43731, 5},
+    /* 1042 */ {I_SHRD, 3, {MEMORY,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43737, 10},
+    /* 1043 */ {I_SHRD, 3, {REG_GPR|BITS64,REG_GPR|BITS64,REG_CL,0,0}, NO_DECORATOR, nasm_bytecodes+43737, 7},
+    /* 1044 */ {I_SIDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48762, 108},
+    /* 1045 */ {I_SLDT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43762, 108},
+    /* 1046 */ {I_SLDT, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43762, 108},
+    /* 1047 */ {I_SLDT, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43743, 108},
+    /* 1048 */ {I_SLDT, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43749, 5},
+    /* 1049 */ {I_SLDT, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43761, 7},
+    /* 1050 */ {I_SKINIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48767, 7},
+    /* 1051 */ {I_SMI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50205, 111},
+    /* 1052 */ {I_SMSW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43780, 108},
+    /* 1053 */ {I_SMSW, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43780, 108},
+    /* 1054 */ {I_SMSW, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43767, 108},
+    /* 1055 */ {I_SMSW, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43773, 5},
+    /* 1056 */ {I_SMSW, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43779, 7},
+    /* 1057 */ {I_STC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48489, 0},
+    /* 1058 */ {I_STD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50226, 0},
+    /* 1059 */ {I_STI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48284, 0},
+    /* 1060 */ {I_STOSB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+12509, 0},
+    /* 1061 */ {I_STOSD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50099, 5},
+    /* 1062 */ {I_STOSQ, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50103, 7},
+    /* 1063 */ {I_STOSW, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50107, 0},
+    /* 1064 */ {I_STR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43798, 62},
+    /* 1065 */ {I_STR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43798, 62},
+    /* 1066 */ {I_STR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43785, 62},
+    /* 1067 */ {I_STR, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43791, 63},
+    /* 1068 */ {I_STR, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43797, 7},
+    /* 1069 */ {I_SUB, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48772, 3},
+    /* 1070 */ {I_SUB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48773, 0},
+    /* 1071 */ {I_SUB, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43803, 3},
+    /* 1072 */ {I_SUB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43804, 0},
+    /* 1073 */ {I_SUB, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43809, 4},
+    /* 1074 */ {I_SUB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43810, 5},
+    /* 1075 */ {I_SUB, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43815, 6},
+    /* 1076 */ {I_SUB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43816, 7},
+    /* 1077 */ {I_SUB, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41036, 8},
+    /* 1078 */ {I_SUB, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+41036, 0},
+    /* 1079 */ {I_SUB, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48777, 8},
+    /* 1080 */ {I_SUB, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48777, 0},
+    /* 1081 */ {I_SUB, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48782, 9},
+    /* 1082 */ {I_SUB, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48782, 5},
+    /* 1083 */ {I_SUB, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48787, 10},
+    /* 1084 */ {I_SUB, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48787, 7},
+    /* 1085 */ {I_SUB, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33711, 11},
+    /* 1086 */ {I_SUB, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33718, 12},
+    /* 1087 */ {I_SUB, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33725, 13},
+    /* 1088 */ {I_SUB, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50111, 8},
+    /* 1089 */ {I_SUB, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48792, 8},
+    /* 1090 */ {I_SUB, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48797, 9},
+    /* 1091 */ {I_SUB, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48802, 10},
+    /* 1092 */ {I_SUB, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43821, 3},
+    /* 1093 */ {I_SUB, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33732, 3},
+    /* 1094 */ {I_SUB, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33739, 4},
+    /* 1095 */ {I_SUB, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33746, 6},
+    /* 1096 */ {I_SUB, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43821, 3},
+    /* 1097 */ {I_SUB, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33732, 3},
+    /* 1098 */ {I_SUB, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33739, 4},
+    /* 1099 */ {I_SVDC, 2, {MEMORY|BITS80,REG_SREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+34357, 105},
+    /* 1100 */ {I_SVTS, 1, {MEMORY|BITS80,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48812, 105},
+    /* 1101 */ {I_SWAPGS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48817, 7},
+    /* 1102 */ {I_SYSCALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49823, 113},
+    /* 1103 */ {I_SYSENTER, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50115, 89},
+    /* 1104 */ {I_SYSEXIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50119, 114},
+    /* 1105 */ {I_SYSRET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49819, 115},
+    /* 1106 */ {I_TEST, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+50123, 8},
+    /* 1107 */ {I_TEST, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+50123, 0},
+    /* 1108 */ {I_TEST, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48822, 8},
+    /* 1109 */ {I_TEST, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48822, 0},
+    /* 1110 */ {I_TEST, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48827, 9},
+    /* 1111 */ {I_TEST, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48827, 5},
+    /* 1112 */ {I_TEST, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48832, 10},
+    /* 1113 */ {I_TEST, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48832, 7},
+    /* 1114 */ {I_TEST, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+50127, 8},
+    /* 1115 */ {I_TEST, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48837, 8},
+    /* 1116 */ {I_TEST, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48842, 9},
+    /* 1117 */ {I_TEST, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48847, 10},
+    /* 1118 */ {I_TEST, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50131, 8},
+    /* 1119 */ {I_TEST, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48852, 8},
+    /* 1120 */ {I_TEST, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48857, 9},
+    /* 1121 */ {I_TEST, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48862, 10},
+    /* 1122 */ {I_TEST, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48867, 8},
+    /* 1123 */ {I_TEST, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43833, 8},
+    /* 1124 */ {I_TEST, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43839, 9},
+    /* 1125 */ {I_TEST, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43845, 10},
+    /* 1126 */ {I_TEST, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48867, 8},
+    /* 1127 */ {I_TEST, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43833, 8},
+    /* 1128 */ {I_TEST, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43839, 9},
+    /* 1129 */ {I_UD0, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50135, 116},
+    /* 1130 */ {I_UD0, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43851, 35},
+    /* 1131 */ {I_UD0, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43857, 35},
+    /* 1132 */ {I_UD0, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43863, 35},
+    /* 1133 */ {I_UD1, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43869, 35},
+    /* 1134 */ {I_UD1, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43875, 35},
+    /* 1135 */ {I_UD1, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43881, 35},
+    /* 1136 */ {I_UD2, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50143, 35},
+    /* 1137 */ {I_VERR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48872, 62},
+    /* 1138 */ {I_VERR, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48872, 62},
+    /* 1139 */ {I_VERR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48872, 62},
+    /* 1140 */ {I_VERW, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48877, 62},
+    /* 1141 */ {I_VERW, 1, {MEMORY|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48877, 62},
+    /* 1142 */ {I_VERW, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48877, 62},
+    /* 1143 */ {I_FWAIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49721, 0},
+    /* 1144 */ {I_WBINVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49183, 54},
+    /* 1145 */ {I_WRSHR, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43899, 98},
+    /* 1146 */ {I_WRMSR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50147, 99},
+    /* 1147 */ {I_XADD, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43905, 118},
+    /* 1148 */ {I_XADD, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43906, 20},
+    /* 1149 */ {I_XADD, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33781, 118},
+    /* 1150 */ {I_XADD, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33782, 20},
+    /* 1151 */ {I_XADD, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33788, 118},
+    /* 1152 */ {I_XADD, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33789, 20},
+    /* 1153 */ {I_XADD, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33795, 6},
+    /* 1154 */ {I_XADD, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33796, 7},
+    /* 1155 */ {I_XCHG, 2, {REG_AX,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+50151, 0},
+    /* 1156 */ {I_XCHG, 2, {REG_EAX,REG32NA,0,0,0}, NO_DECORATOR, nasm_bytecodes+50155, 5},
+    /* 1157 */ {I_XCHG, 2, {REG_RAX,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+50159, 7},
+    /* 1158 */ {I_XCHG, 2, {REG_GPR|BITS16,REG_AX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50163, 0},
+    /* 1159 */ {I_XCHG, 2, {REG32NA,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50167, 5},
+    /* 1160 */ {I_XCHG, 2, {REG_GPR|BITS64,REG_RAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50171, 7},
+    /* 1161 */ {I_XCHG, 2, {REG_EAX,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+50175, 19},
+    /* 1162 */ {I_XCHG, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48882, 3},
+    /* 1163 */ {I_XCHG, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48883, 0},
+    /* 1164 */ {I_XCHG, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43923, 3},
+    /* 1165 */ {I_XCHG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43924, 0},
+    /* 1166 */ {I_XCHG, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43929, 4},
+    /* 1167 */ {I_XCHG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43930, 5},
+    /* 1168 */ {I_XCHG, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43935, 6},
+    /* 1169 */ {I_XCHG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43936, 7},
+    /* 1170 */ {I_XCHG, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48887, 3},
+    /* 1171 */ {I_XCHG, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48888, 0},
+    /* 1172 */ {I_XCHG, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43941, 3},
+    /* 1173 */ {I_XCHG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43942, 0},
+    /* 1174 */ {I_XCHG, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43947, 4},
+    /* 1175 */ {I_XCHG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43948, 5},
+    /* 1176 */ {I_XCHG, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43953, 6},
+    /* 1177 */ {I_XCHG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43954, 7},
+    /* 1178 */ {I_XLATB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46014, 0},
+    /* 1179 */ {I_XLAT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46014, 0},
+    /* 1180 */ {I_XOR, 2, {MEMORY,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48892, 3},
+    /* 1181 */ {I_XOR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+48893, 0},
+    /* 1182 */ {I_XOR, 2, {MEMORY,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43959, 3},
+    /* 1183 */ {I_XOR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43960, 0},
+    /* 1184 */ {I_XOR, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43965, 4},
+    /* 1185 */ {I_XOR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+43966, 5},
+    /* 1186 */ {I_XOR, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43971, 6},
+    /* 1187 */ {I_XOR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43972, 7},
+    /* 1188 */ {I_XOR, 2, {REG_GPR|BITS8,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+40476, 8},
+    /* 1189 */ {I_XOR, 2, {REG_GPR|BITS8,REG_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+40476, 0},
+    /* 1190 */ {I_XOR, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48897, 8},
+    /* 1191 */ {I_XOR, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+48897, 0},
+    /* 1192 */ {I_XOR, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48902, 9},
+    /* 1193 */ {I_XOR, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+48902, 5},
+    /* 1194 */ {I_XOR, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+48907, 10},
+    /* 1195 */ {I_XOR, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+48907, 7},
+    /* 1196 */ {I_XOR, 2, {RM_GPR|BITS16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33802, 11},
+    /* 1197 */ {I_XOR, 2, {RM_GPR|BITS32,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33809, 12},
+    /* 1198 */ {I_XOR, 2, {RM_GPR|BITS64,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+33816, 13},
+    /* 1199 */ {I_XOR, 2, {REG_AL,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+50179, 8},
+    /* 1200 */ {I_XOR, 2, {REG_AX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48912, 8},
+    /* 1201 */ {I_XOR, 2, {REG_EAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48917, 9},
+    /* 1202 */ {I_XOR, 2, {REG_RAX,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+48922, 10},
+    /* 1203 */ {I_XOR, 2, {RM_GPR|BITS8,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+43977, 3},
+    /* 1204 */ {I_XOR, 2, {RM_GPR|BITS16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33823, 3},
+    /* 1205 */ {I_XOR, 2, {RM_GPR|BITS32,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33830, 4},
+    /* 1206 */ {I_XOR, 2, {RM_GPR|BITS64,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+33837, 6},
+    /* 1207 */ {I_XOR, 2, {MEMORY,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+43977, 3},
+    /* 1208 */ {I_XOR, 2, {MEMORY,IMMEDIATE|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33823, 3},
+    /* 1209 */ {I_XOR, 2, {MEMORY,IMMEDIATE|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33830, 4},
+    /* 1210 */ {I_CMOVA, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43989, 121},
+    /* 1211 */ {I_CMOVC, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 121},
+    /* 1212 */ {I_CMOVG, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44019, 121},
+    /* 1213 */ {I_CMOVL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44031, 121},
+    /* 1214 */ {I_CMOVNA, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44007, 121},
+    /* 1215 */ {I_CMOVNC, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 121},
+    /* 1216 */ {I_CMOVNG, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44037, 121},
+    /* 1217 */ {I_CMOVNL, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44025, 121},
+    /* 1218 */ {I_CMOVNO, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44049, 121},
+    /* 1219 */ {I_CMOVNS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44061, 121},
+    /* 1220 */ {I_CMOVNZ, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44043, 121},
+    /* 1221 */ {I_CMOVO, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44067, 121},
+    /* 1222 */ {I_CMOVPE, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44073, 121},
+    /* 1223 */ {I_CMOVPO, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44055, 121},
+    /* 1224 */ {I_CMOVS, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44079, 121},
+    /* 1225 */ {I_CMOVZ, 2, {REG_GPR|BITS16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44013, 121},
+    /* 1226 */ {I_CMOVA, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43989, 89},
+    /* 1227 */ {I_CMOVC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44001, 89},
+    /* 1228 */ {I_CMOVG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44019, 89},
+    /* 1229 */ {I_CMOVL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44031, 89},
+    /* 1230 */ {I_CMOVNA, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44007, 89},
+    /* 1231 */ {I_CMOVNC, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43995, 89},
+    /* 1232 */ {I_CMOVNG, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44037, 89},
+    /* 1233 */ {I_CMOVNL, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44025, 89},
+    /* 1234 */ {I_CMOVNO, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44049, 89},
+    /* 1235 */ {I_CMOVNS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44061, 89},
+    /* 1236 */ {I_CMOVNZ, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44043, 89},
+    /* 1237 */ {I_CMOVO, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44067, 89},
+    /* 1238 */ {I_CMOVPE, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44073, 89},
+    /* 1239 */ {I_CMOVPO, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44055, 89},
+    /* 1240 */ {I_CMOVS, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44079, 89},
+    /* 1241 */ {I_CMOVZ, 2, {REG_GPR|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44013, 89},
+    /* 1242 */ {I_CMOVA, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44085, 121},
+    /* 1243 */ {I_CMOVC, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 121},
+    /* 1244 */ {I_CMOVG, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44115, 121},
+    /* 1245 */ {I_CMOVL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44127, 121},
+    /* 1246 */ {I_CMOVNA, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44103, 121},
+    /* 1247 */ {I_CMOVNC, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 121},
+    /* 1248 */ {I_CMOVNG, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44133, 121},
+    /* 1249 */ {I_CMOVNL, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44121, 121},
+    /* 1250 */ {I_CMOVNO, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44145, 121},
+    /* 1251 */ {I_CMOVNS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44157, 121},
+    /* 1252 */ {I_CMOVNZ, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44139, 121},
+    /* 1253 */ {I_CMOVO, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44163, 121},
+    /* 1254 */ {I_CMOVPE, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44169, 121},
+    /* 1255 */ {I_CMOVPO, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44151, 121},
+    /* 1256 */ {I_CMOVS, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44175, 121},
+    /* 1257 */ {I_CMOVZ, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44109, 121},
+    /* 1258 */ {I_CMOVA, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44085, 89},
+    /* 1259 */ {I_CMOVC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44097, 89},
+    /* 1260 */ {I_CMOVG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44115, 89},
+    /* 1261 */ {I_CMOVL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44127, 89},
+    /* 1262 */ {I_CMOVNA, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44103, 89},
+    /* 1263 */ {I_CMOVNC, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44091, 89},
+    /* 1264 */ {I_CMOVNG, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44133, 89},
+    /* 1265 */ {I_CMOVNL, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44121, 89},
+    /* 1266 */ {I_CMOVNO, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44145, 89},
+    /* 1267 */ {I_CMOVNS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44157, 89},
+    /* 1268 */ {I_CMOVNZ, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44139, 89},
+    /* 1269 */ {I_CMOVO, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44163, 89},
+    /* 1270 */ {I_CMOVPE, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44169, 89},
+    /* 1271 */ {I_CMOVPO, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44151, 89},
+    /* 1272 */ {I_CMOVS, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44175, 89},
+    /* 1273 */ {I_CMOVZ, 2, {REG_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44109, 89},
+    /* 1274 */ {I_CMOVA, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44181, 10},
+    /* 1275 */ {I_CMOVC, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 10},
+    /* 1276 */ {I_CMOVG, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44211, 10},
+    /* 1277 */ {I_CMOVL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44223, 10},
+    /* 1278 */ {I_CMOVNA, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44199, 10},
+    /* 1279 */ {I_CMOVNC, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 10},
+    /* 1280 */ {I_CMOVNG, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44229, 10},
+    /* 1281 */ {I_CMOVNL, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44217, 10},
+    /* 1282 */ {I_CMOVNO, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44241, 10},
+    /* 1283 */ {I_CMOVNS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44253, 10},
+    /* 1284 */ {I_CMOVNZ, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44235, 10},
+    /* 1285 */ {I_CMOVO, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44259, 10},
+    /* 1286 */ {I_CMOVPE, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44265, 10},
+    /* 1287 */ {I_CMOVPO, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44247, 10},
+    /* 1288 */ {I_CMOVS, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44271, 10},
+    /* 1289 */ {I_CMOVZ, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44205, 10},
+    /* 1290 */ {I_CMOVA, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44181, 7},
+    /* 1291 */ {I_CMOVC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44193, 7},
+    /* 1292 */ {I_CMOVG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44211, 7},
+    /* 1293 */ {I_CMOVL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44223, 7},
+    /* 1294 */ {I_CMOVNA, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44199, 7},
+    /* 1295 */ {I_CMOVNC, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44187, 7},
+    /* 1296 */ {I_CMOVNG, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44229, 7},
+    /* 1297 */ {I_CMOVNL, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44217, 7},
+    /* 1298 */ {I_CMOVNO, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44241, 7},
+    /* 1299 */ {I_CMOVNS, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44253, 7},
+    /* 1300 */ {I_CMOVNZ, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44235, 7},
+    /* 1301 */ {I_CMOVO, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44259, 7},
+    /* 1302 */ {I_CMOVPE, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44265, 7},
+    /* 1303 */ {I_CMOVPO, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44247, 7},
+    /* 1304 */ {I_CMOVS, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44271, 7},
+    /* 1305 */ {I_CMOVZ, 2, {REG_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44205, 7},
+    /* 1306 */ {I_JA, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44277, 122},
+    /* 1307 */ {I_JC, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44289, 122},
+    /* 1308 */ {I_JG, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44307, 122},
+    /* 1309 */ {I_JL, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44319, 122},
+    /* 1310 */ {I_JNA, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44295, 122},
+    /* 1311 */ {I_JNC, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44283, 122},
+    /* 1312 */ {I_JNG, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44325, 122},
+    /* 1313 */ {I_JNL, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44313, 122},
+    /* 1314 */ {I_JNO, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44337, 122},
+    /* 1315 */ {I_JNS, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44349, 122},
+    /* 1316 */ {I_JNZ, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44331, 122},
+    /* 1317 */ {I_JO, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44355, 122},
+    /* 1318 */ {I_JPE, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44361, 122},
+    /* 1319 */ {I_JPO, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44343, 122},
+    /* 1320 */ {I_JS, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44367, 122},
+    /* 1321 */ {I_JZ, 1, {IMMEDIATE|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44301, 122},
+    /* 1322 */ {I_JA, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44373, 23},
+    /* 1323 */ {I_JC, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44385, 23},
+    /* 1324 */ {I_JG, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44403, 23},
+    /* 1325 */ {I_JL, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44415, 23},
+    /* 1326 */ {I_JNA, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44391, 23},
+    /* 1327 */ {I_JNC, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44379, 23},
+    /* 1328 */ {I_JNG, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44421, 23},
+    /* 1329 */ {I_JNL, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44409, 23},
+    /* 1330 */ {I_JNO, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44433, 23},
+    /* 1331 */ {I_JNS, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44445, 23},
+    /* 1332 */ {I_JNZ, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44427, 23},
+    /* 1333 */ {I_JO, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44451, 23},
+    /* 1334 */ {I_JPE, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44457, 23},
+    /* 1335 */ {I_JPO, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44439, 23},
+    /* 1336 */ {I_JS, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44463, 23},
+    /* 1337 */ {I_JZ, 1, {IMMEDIATE|BITS16|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44397, 23},
+    /* 1338 */ {I_JA, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44469, 23},
+    /* 1339 */ {I_JC, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44481, 23},
+    /* 1340 */ {I_JG, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44499, 23},
+    /* 1341 */ {I_JL, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44511, 23},
+    /* 1342 */ {I_JNA, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44487, 23},
+    /* 1343 */ {I_JNC, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44475, 23},
+    /* 1344 */ {I_JNG, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44517, 23},
+    /* 1345 */ {I_JNL, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44505, 23},
+    /* 1346 */ {I_JNO, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44529, 23},
+    /* 1347 */ {I_JNS, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44541, 23},
+    /* 1348 */ {I_JNZ, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44523, 23},
+    /* 1349 */ {I_JO, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44547, 23},
+    /* 1350 */ {I_JPE, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44553, 23},
+    /* 1351 */ {I_JPO, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44535, 23},
+    /* 1352 */ {I_JS, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44559, 23},
+    /* 1353 */ {I_JZ, 1, {IMMEDIATE|BITS32|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44493, 23},
+    /* 1354 */ {I_JA, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44565, 24},
+    /* 1355 */ {I_JC, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44577, 24},
+    /* 1356 */ {I_JG, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44595, 24},
+    /* 1357 */ {I_JL, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44607, 24},
+    /* 1358 */ {I_JNA, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44583, 24},
+    /* 1359 */ {I_JNC, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44571, 24},
+    /* 1360 */ {I_JNG, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44613, 24},
+    /* 1361 */ {I_JNL, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44601, 24},
+    /* 1362 */ {I_JNO, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44625, 24},
+    /* 1363 */ {I_JNS, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44637, 24},
+    /* 1364 */ {I_JNZ, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44619, 24},
+    /* 1365 */ {I_JO, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44643, 24},
+    /* 1366 */ {I_JPE, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44649, 24},
+    /* 1367 */ {I_JPO, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44631, 24},
+    /* 1368 */ {I_JS, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44655, 24},
+    /* 1369 */ {I_JZ, 1, {IMMEDIATE|BITS64|NEAR,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44589, 24},
+    /* 1370 */ {I_JA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48928, 21},
+    /* 1371 */ {I_JC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48938, 21},
+    /* 1372 */ {I_JG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48953, 21},
+    /* 1373 */ {I_JL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48963, 21},
+    /* 1374 */ {I_JNA, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48943, 21},
+    /* 1375 */ {I_JNC, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48933, 21},
+    /* 1376 */ {I_JNG, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48968, 21},
+    /* 1377 */ {I_JNL, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48958, 21},
+    /* 1378 */ {I_JNO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48978, 21},
+    /* 1379 */ {I_JNS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48988, 21},
+    /* 1380 */ {I_JNZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48973, 21},
+    /* 1381 */ {I_JO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48993, 21},
+    /* 1382 */ {I_JPE, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48998, 21},
+    /* 1383 */ {I_JPO, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48983, 21},
+    /* 1384 */ {I_JS, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49003, 21},
+    /* 1385 */ {I_JZ, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+48948, 21},
+    /* 1386 */ {I_SETA, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49007, 53},
+    /* 1387 */ {I_SETC, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 53},
+    /* 1388 */ {I_SETG, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49032, 53},
+    /* 1389 */ {I_SETL, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49042, 53},
+    /* 1390 */ {I_SETNA, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49022, 53},
+    /* 1391 */ {I_SETNC, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 53},
+    /* 1392 */ {I_SETNG, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49047, 53},
+    /* 1393 */ {I_SETNL, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49037, 53},
+    /* 1394 */ {I_SETNO, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49057, 53},
+    /* 1395 */ {I_SETNS, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49067, 53},
+    /* 1396 */ {I_SETNZ, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49052, 53},
+    /* 1397 */ {I_SETO, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49072, 53},
+    /* 1398 */ {I_SETPE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49077, 53},
+    /* 1399 */ {I_SETPO, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49062, 53},
+    /* 1400 */ {I_SETS, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49082, 53},
+    /* 1401 */ {I_SETZ, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49027, 53},
+    /* 1402 */ {I_SETA, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49007, 5},
+    /* 1403 */ {I_SETC, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49017, 5},
+    /* 1404 */ {I_SETG, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49032, 5},
+    /* 1405 */ {I_SETL, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49042, 5},
+    /* 1406 */ {I_SETNA, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49022, 5},
+    /* 1407 */ {I_SETNC, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49012, 5},
+    /* 1408 */ {I_SETNG, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49047, 5},
+    /* 1409 */ {I_SETNL, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49037, 5},
+    /* 1410 */ {I_SETNO, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49057, 5},
+    /* 1411 */ {I_SETNS, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49067, 5},
+    /* 1412 */ {I_SETNZ, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49052, 5},
+    /* 1413 */ {I_SETO, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49072, 5},
+    /* 1414 */ {I_SETPE, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49077, 5},
+    /* 1415 */ {I_SETPO, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49062, 5},
+    /* 1416 */ {I_SETS, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49082, 5},
+    /* 1417 */ {I_SETZ, 1, {REG_GPR|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49027, 5},
+    /* 1418 */ {I_ADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44661, 123},
+    /* 1419 */ {I_ADDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44667, 123},
+    /* 1420 */ {I_ANDNPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44673, 123},
+    /* 1421 */ {I_ANDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44679, 123},
+    /* 1422 */ {I_CMPEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12528, 123},
+    /* 1423 */ {I_CMPEQSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12536, 123},
+    /* 1424 */ {I_CMPLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12544, 123},
+    /* 1425 */ {I_CMPLESS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12552, 123},
+    /* 1426 */ {I_CMPLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12560, 123},
+    /* 1427 */ {I_CMPLTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12568, 123},
+    /* 1428 */ {I_CMPNEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12576, 123},
+    /* 1429 */ {I_CMPNEQSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12584, 123},
+    /* 1430 */ {I_CMPNLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12592, 123},
+    /* 1431 */ {I_CMPNLESS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12600, 123},
+    /* 1432 */ {I_CMPNLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12608, 123},
+    /* 1433 */ {I_CMPNLTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12616, 123},
+    /* 1434 */ {I_CMPORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12624, 123},
+    /* 1435 */ {I_CMPORDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12632, 123},
+    /* 1436 */ {I_CMPUNORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+12640, 123},
+    /* 1437 */ {I_CMPUNORDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12648, 123},
+    /* 1438 */ {I_CMPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+33956, 123},
+    /* 1439 */ {I_CMPSS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+33963, 123},
+    /* 1440 */ {I_COMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44685, 123},
+    /* 1441 */ {I_CVTPI2PS, 2, {XMM_L16,RM_MMX|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44691, 124},
+    /* 1442 */ {I_CVTPS2PI, 2, {MMXREG,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44697, 124},
+    /* 1443 */ {I_CVTSI2SS, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+33971, 125},
+    /* 1444 */ {I_CVTSI2SS, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+33970, 126},
+    /* 1445 */ {I_CVTSS2SI, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33978, 125},
+    /* 1446 */ {I_CVTSS2SI, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33978, 125},
+    /* 1447 */ {I_CVTSS2SI, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33977, 127},
+    /* 1448 */ {I_CVTSS2SI, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+33977, 127},
+    /* 1449 */ {I_CVTTPS2PI, 2, {MMXREG,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44703, 128},
+    /* 1450 */ {I_CVTTSS2SI, 2, {REG_GPR|BITS32,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33985, 125},
+    /* 1451 */ {I_CVTTSS2SI, 2, {REG_GPR|BITS64,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33984, 127},
+    /* 1452 */ {I_DIVPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44709, 123},
+    /* 1453 */ {I_DIVSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44715, 123},
+    /* 1454 */ {I_LDMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44721, 123},
+    /* 1455 */ {I_MAXPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44727, 123},
+    /* 1456 */ {I_MAXSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44733, 123},
+    /* 1457 */ {I_MINPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44739, 123},
+    /* 1458 */ {I_MINSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44745, 123},
+    /* 1459 */ {I_MOVAPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44751, 123},
+    /* 1460 */ {I_MOVAPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44757, 123},
+    /* 1461 */ {I_MOVHPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+44763, 123},
+    /* 1462 */ {I_MOVHPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44769, 123},
+    /* 1463 */ {I_MOVLHPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44763, 123},
+    /* 1464 */ {I_MOVLPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+43893, 123},
+    /* 1465 */ {I_MOVLPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44775, 123},
+    /* 1466 */ {I_MOVHLPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+43893, 123},
+    /* 1467 */ {I_MOVMSKPS, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44781, 123},
+    /* 1468 */ {I_MOVMSKPS, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+33991, 129},
+    /* 1469 */ {I_MOVNTPS, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44787, 123},
+    /* 1470 */ {I_MOVSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44793, 123},
+    /* 1471 */ {I_MOVSS, 2, {RM_XMM_L16|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44799, 123},
+    /* 1472 */ {I_MOVUPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44805, 123},
+    /* 1473 */ {I_MOVUPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44811, 123},
+    /* 1474 */ {I_MULPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44817, 123},
+    /* 1475 */ {I_MULSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44823, 123},
+    /* 1476 */ {I_ORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44829, 123},
+    /* 1477 */ {I_RCPPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44835, 123},
+    /* 1478 */ {I_RCPSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44841, 123},
+    /* 1479 */ {I_RSQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44847, 123},
+    /* 1480 */ {I_RSQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44853, 123},
+    /* 1481 */ {I_SHUFPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+33998, 123},
+    /* 1482 */ {I_SQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44859, 123},
+    /* 1483 */ {I_SQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44865, 123},
+    /* 1484 */ {I_STMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44871, 123},
+    /* 1485 */ {I_SUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44877, 123},
+    /* 1486 */ {I_SUBSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44883, 123},
+    /* 1487 */ {I_UCOMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+44889, 123},
+    /* 1488 */ {I_UNPCKHPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44895, 123},
+    /* 1489 */ {I_UNPCKLPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44901, 123},
+    /* 1490 */ {I_XORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44907, 123},
+    /* 1491 */ {I_FXRSTOR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34006, 130},
+    /* 1492 */ {I_FXRSTOR64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34005, 131},
+    /* 1493 */ {I_FXSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34013, 130},
+    /* 1494 */ {I_FXSAVE64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34012, 131},
+    /* 1495 */ {I_XGETBV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49087, 132},
+    /* 1496 */ {I_XSETBV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49092, 133},
+    /* 1497 */ {I_XSAVE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34020, 132},
+    /* 1498 */ {I_XSAVE64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34019, 134},
+    /* 1499 */ {I_XSAVEC, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34027, 135},
+    /* 1500 */ {I_XSAVEC64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34026, 136},
+    /* 1501 */ {I_XSAVEOPT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34034, 135},
+    /* 1502 */ {I_XSAVEOPT64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34033, 136},
+    /* 1503 */ {I_XSAVES, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34041, 135},
+    /* 1504 */ {I_XSAVES64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34040, 136},
+    /* 1505 */ {I_XRSTOR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34048, 132},
+    /* 1506 */ {I_XRSTOR64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34047, 134},
+    /* 1507 */ {I_XRSTORS, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34055, 135},
+    /* 1508 */ {I_XRSTORS64, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34054, 136},
+    /* 1509 */ {I_PREFETCHNTA, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46126, 137},
+    /* 1510 */ {I_PREFETCHT0, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46144, 137},
+    /* 1511 */ {I_PREFETCHT1, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46162, 137},
+    /* 1512 */ {I_PREFETCHT2, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46180, 137},
+    /* 1513 */ {I_PREFETCHIT0, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46252, 138},
+    /* 1514 */ {I_PREFETCHIT1, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46234, 138},
+    /* 1515 */ {I_SFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43683, 139},
+    /* 1516 */ {I_MASKMOVQ, 2, {MMXREG,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44913, 140},
+    /* 1517 */ {I_MOVNTQ, 2, {MEMORY,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44919, 141},
+    /* 1518 */ {I_PAVGB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34061, 141},
+    /* 1519 */ {I_PAVGW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34068, 141},
+    /* 1520 */ {I_PEXTRW, 3, {REG_GPR|BITS32,MMXREG,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34075, 142},
+    /* 1521 */ {I_PINSRW, 3, {MMXREG,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34082, 142},
+    /* 1522 */ {I_PINSRW, 3, {MMXREG,RM_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34082, 142},
+    /* 1523 */ {I_PINSRW, 3, {MMXREG,REG_GPR|BITS32,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34082, 142},
+    /* 1524 */ {I_PMAXSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34089, 141},
+    /* 1525 */ {I_PMAXUB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34096, 141},
+    /* 1526 */ {I_PMINSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34103, 141},
+    /* 1527 */ {I_PMINUB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34110, 141},
+    /* 1528 */ {I_PMOVMSKB, 2, {REG_GPR|BITS32,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44925, 140},
+    /* 1529 */ {I_PMULHUW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34117, 141},
+    /* 1530 */ {I_PSADBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34124, 141},
+    /* 1531 */ {I_PSHUFW, 3, {MMXREG,RM_MMX,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12656, 143},
+    /* 1532 */ {I_PF2IW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12664, 91},
+    /* 1533 */ {I_PFNACC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12672, 91},
+    /* 1534 */ {I_PFPNACC, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12680, 91},
+    /* 1535 */ {I_PI2FW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12688, 91},
+    /* 1536 */ {I_PSWAPD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+12696, 91},
+    /* 1537 */ {I_MASKMOVDQU, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44931, 144},
+    /* 1538 */ {I_CLFLUSH, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+44937, 144},
+    /* 1539 */ {I_MOVNTDQ, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44943, 145},
+    /* 1540 */ {I_MOVNTI, 2, {MEMORY,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34132, 146},
+    /* 1541 */ {I_MOVNTI, 2, {MEMORY,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34131, 147},
+    /* 1542 */ {I_MOVNTPD, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44949, 145},
+    /* 1543 */ {I_LFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43191, 144},
+    /* 1544 */ {I_MFENCE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43269, 144},
+    /* 1545 */ {I_MOVD, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34138, 148},
+    /* 1546 */ {I_MOVD, 2, {XMM_L16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34145, 148},
+    /* 1547 */ {I_MOVD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34145, 144},
+    /* 1548 */ {I_MOVD, 2, {RM_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34138, 144},
+    /* 1549 */ {I_MOVDQA, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44955, 145},
+    /* 1550 */ {I_MOVDQA, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44961, 145},
+    /* 1551 */ {I_MOVDQU, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+44967, 145},
+    /* 1552 */ {I_MOVDQU, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44973, 145},
+    /* 1553 */ {I_MOVDQ2Q, 2, {MMXREG,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44979, 144},
+    /* 1554 */ {I_MOVQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44985, 144},
+    /* 1555 */ {I_MOVQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44991, 144},
+    /* 1556 */ {I_MOVQ, 2, {MEMORY,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+44991, 149},
+    /* 1557 */ {I_MOVQ, 2, {XMM_L16,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+44985, 149},
+    /* 1558 */ {I_MOVQ, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34152, 150},
+    /* 1559 */ {I_MOVQ, 2, {RM_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34159, 150},
+    /* 1560 */ {I_MOVQ2DQ, 2, {XMM_L16,MMXREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+44997, 144},
+    /* 1561 */ {I_PACKSSWB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45003, 145},
+    /* 1562 */ {I_PACKSSDW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45009, 145},
+    /* 1563 */ {I_PACKUSWB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45015, 145},
+    /* 1564 */ {I_PADDB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45021, 145},
+    /* 1565 */ {I_PADDW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45027, 145},
+    /* 1566 */ {I_PADDD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45033, 145},
+    /* 1567 */ {I_PADDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+45039, 151},
+    /* 1568 */ {I_PADDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45045, 145},
+    /* 1569 */ {I_PADDSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45051, 145},
+    /* 1570 */ {I_PADDSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45057, 145},
+    /* 1571 */ {I_PADDUSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45063, 145},
+    /* 1572 */ {I_PADDUSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45069, 145},
+    /* 1573 */ {I_PAND, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45075, 145},
+    /* 1574 */ {I_PANDN, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45081, 145},
+    /* 1575 */ {I_PAVGB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45087, 145},
+    /* 1576 */ {I_PAVGW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45093, 145},
+    /* 1577 */ {I_PCMPEQB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45099, 145},
+    /* 1578 */ {I_PCMPEQW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45105, 145},
+    /* 1579 */ {I_PCMPEQD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45111, 145},
+    /* 1580 */ {I_PCMPGTB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45117, 145},
+    /* 1581 */ {I_PCMPGTW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45123, 145},
+    /* 1582 */ {I_PCMPGTD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45129, 145},
+    /* 1583 */ {I_PEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34166, 152},
+    /* 1584 */ {I_PINSRW, 3, {XMM_L16,REG_GPR|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    /* 1585 */ {I_PINSRW, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    /* 1586 */ {I_PINSRW, 3, {XMM_L16,MEMORY|BITS16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34173, 152},
+    /* 1587 */ {I_PMADDWD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45135, 145},
+    /* 1588 */ {I_PMAXSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45141, 145},
+    /* 1589 */ {I_PMAXUB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45147, 145},
+    /* 1590 */ {I_PMINSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45153, 145},
+    /* 1591 */ {I_PMINUB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45159, 145},
+    /* 1592 */ {I_PMOVMSKB, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45165, 144},
+    /* 1593 */ {I_PMULHUW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45171, 145},
+    /* 1594 */ {I_PMULHW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45177, 145},
+    /* 1595 */ {I_PMULLW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45183, 145},
+    /* 1596 */ {I_PMULUDQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34180, 145},
+    /* 1597 */ {I_PMULUDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45189, 145},
+    /* 1598 */ {I_POR, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45195, 145},
+    /* 1599 */ {I_PSADBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45201, 145},
+    /* 1600 */ {I_PSHUFD, 3, {XMM_L16,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34187, 152},
+    /* 1601 */ {I_PSHUFD, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34187, 154},
+    /* 1602 */ {I_PSHUFHW, 3, {XMM_L16,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34194, 152},
+    /* 1603 */ {I_PSHUFHW, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34194, 154},
+    /* 1604 */ {I_PSHUFLW, 3, {XMM_L16,XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34201, 152},
+    /* 1605 */ {I_PSHUFLW, 3, {XMM_L16,MEMORY,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+34201, 154},
+    /* 1606 */ {I_PSLLDQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34208, 155},
+    /* 1607 */ {I_PSLLW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45207, 145},
+    /* 1608 */ {I_PSLLW, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34215, 155},
+    /* 1609 */ {I_PSLLD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45213, 145},
+    /* 1610 */ {I_PSLLD, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34222, 155},
+    /* 1611 */ {I_PSLLQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45219, 145},
+    /* 1612 */ {I_PSLLQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34229, 155},
+    /* 1613 */ {I_PSRAW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45225, 145},
+    /* 1614 */ {I_PSRAW, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34236, 155},
+    /* 1615 */ {I_PSRAD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45231, 145},
+    /* 1616 */ {I_PSRAD, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34243, 155},
+    /* 1617 */ {I_PSRLDQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34250, 155},
+    /* 1618 */ {I_PSRLW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45237, 145},
+    /* 1619 */ {I_PSRLW, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34257, 155},
+    /* 1620 */ {I_PSRLD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45243, 145},
+    /* 1621 */ {I_PSRLD, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34264, 155},
+    /* 1622 */ {I_PSRLQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45249, 145},
+    /* 1623 */ {I_PSRLQ, 2, {XMM_L16,IMMEDIATE,0,0,0}, NO_DECORATOR, nasm_bytecodes+34271, 155},
+    /* 1624 */ {I_PSUBB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45255, 145},
+    /* 1625 */ {I_PSUBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45261, 145},
+    /* 1626 */ {I_PSUBD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45267, 145},
+    /* 1627 */ {I_PSUBQ, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34278, 145},
+    /* 1628 */ {I_PSUBQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45273, 145},
+    /* 1629 */ {I_PSUBSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45279, 145},
+    /* 1630 */ {I_PSUBSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45285, 145},
+    /* 1631 */ {I_PSUBUSB, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45291, 145},
+    /* 1632 */ {I_PSUBUSW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45297, 145},
+    /* 1633 */ {I_PUNPCKHBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45303, 145},
+    /* 1634 */ {I_PUNPCKHWD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45309, 145},
+    /* 1635 */ {I_PUNPCKHDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45315, 145},
+    /* 1636 */ {I_PUNPCKHQDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45321, 145},
+    /* 1637 */ {I_PUNPCKLBW, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45327, 145},
+    /* 1638 */ {I_PUNPCKLWD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45333, 145},
+    /* 1639 */ {I_PUNPCKLDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45339, 145},
+    /* 1640 */ {I_PUNPCKLQDQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45345, 145},
+    /* 1641 */ {I_PXOR, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45351, 145},
+    /* 1642 */ {I_ADDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45357, 145},
+    /* 1643 */ {I_ADDSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45363, 149},
+    /* 1644 */ {I_ANDNPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45369, 145},
+    /* 1645 */ {I_ANDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45375, 145},
+    /* 1646 */ {I_CMPEQPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12704, 145},
+    /* 1647 */ {I_CMPEQSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12712, 149},
+    /* 1648 */ {I_CMPLEPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12720, 145},
+    /* 1649 */ {I_CMPLESD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12728, 149},
+    /* 1650 */ {I_CMPLTPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12736, 145},
+    /* 1651 */ {I_CMPLTSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12744, 149},
+    /* 1652 */ {I_CMPNEQPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12752, 145},
+    /* 1653 */ {I_CMPNEQSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12760, 149},
+    /* 1654 */ {I_CMPNLEPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12768, 145},
+    /* 1655 */ {I_CMPNLESD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12776, 149},
+    /* 1656 */ {I_CMPNLTPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12784, 145},
+    /* 1657 */ {I_CMPNLTSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12792, 149},
+    /* 1658 */ {I_CMPORDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12800, 145},
+    /* 1659 */ {I_CMPORDSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12808, 149},
+    /* 1660 */ {I_CMPUNORDPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12816, 145},
+    /* 1661 */ {I_CMPUNORDSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12824, 149},
+    /* 1662 */ {I_CMPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+34285, 144},
+    /* 1663 */ {I_CMPSD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+34292, 144},
+    /* 1664 */ {I_COMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45381, 144},
+    /* 1665 */ {I_CVTDQ2PD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45387, 149},
+    /* 1666 */ {I_CVTDQ2PS, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45393, 145},
+    /* 1667 */ {I_CVTPD2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45399, 145},
+    /* 1668 */ {I_CVTPD2PI, 2, {MMXREG,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45405, 145},
+    /* 1669 */ {I_CVTPD2PS, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45411, 145},
+    /* 1670 */ {I_CVTPI2PD, 2, {XMM_L16,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+45417, 149},
+    /* 1671 */ {I_CVTPS2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45423, 145},
+    /* 1672 */ {I_CVTPS2PD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45429, 149},
+    /* 1673 */ {I_CVTSD2SI, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34299, 156},
+    /* 1674 */ {I_CVTSD2SI, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34299, 156},
+    /* 1675 */ {I_CVTSD2SI, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34306, 157},
+    /* 1676 */ {I_CVTSD2SI, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34306, 157},
+    /* 1677 */ {I_CVTSD2SS, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45435, 149},
+    /* 1678 */ {I_CVTSI2SD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34313, 158},
+    /* 1679 */ {I_CVTSI2SD, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34320, 157},
+    /* 1680 */ {I_CVTSS2SD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45441, 148},
+    /* 1681 */ {I_CVTTPD2PI, 2, {MMXREG,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45447, 145},
+    /* 1682 */ {I_CVTTPD2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45453, 145},
+    /* 1683 */ {I_CVTTPS2DQ, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45459, 145},
+    /* 1684 */ {I_CVTTSD2SI, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34327, 156},
+    /* 1685 */ {I_CVTTSD2SI, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34327, 156},
+    /* 1686 */ {I_CVTTSD2SI, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34334, 157},
+    /* 1687 */ {I_CVTTSD2SI, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+34334, 157},
+    /* 1688 */ {I_DIVPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45465, 145},
+    /* 1689 */ {I_DIVSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45471, 149},
+    /* 1690 */ {I_MAXPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45477, 145},
+    /* 1691 */ {I_MAXSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45483, 149},
+    /* 1692 */ {I_MINPD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45489, 145},
+    /* 1693 */ {I_MINSD, 2, {XMM_L16,RM_XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45495, 149},
+    /* 1694 */ {I_MOVAPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45501, 144},
+    /* 1695 */ {I_MOVAPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45507, 144},
+    /* 1696 */ {I_MOVHPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45513, 144},
+    /* 1697 */ {I_MOVHPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45519, 144},
+    /* 1698 */ {I_MOVLPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45525, 144},
+    /* 1699 */ {I_MOVLPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45531, 144},
+    /* 1700 */ {I_MOVMSKPD, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45537, 144},
+    /* 1701 */ {I_MOVMSKPD, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34341, 150},
+    /* 1702 */ {I_MOVSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45543, 144},
+    /* 1703 */ {I_MOVSD, 2, {RM_XMM_L16|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45549, 144},
+    /* 1704 */ {I_MOVUPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45555, 144},
+    /* 1705 */ {I_MOVUPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45561, 144},
+    /* 1706 */ {I_MULPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45567, 145},
+    /* 1707 */ {I_MULSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45573, 149},
+    /* 1708 */ {I_ORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45579, 145},
+    /* 1709 */ {I_SHUFPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+34348, 144},
+    /* 1710 */ {I_SQRTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45585, 145},
+    /* 1711 */ {I_SQRTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45591, 144},
+    /* 1712 */ {I_SUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45597, 145},
+    /* 1713 */ {I_SUBSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45603, 144},
+    /* 1714 */ {I_UCOMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45609, 144},
+    /* 1715 */ {I_UNPCKHPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45615, 144},
+    /* 1716 */ {I_UNPCKLPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45621, 144},
+    /* 1717 */ {I_XORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45627, 144},
+    /* 1718 */ {I_ADDSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45633, 159},
+    /* 1719 */ {I_ADDSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45639, 159},
+    /* 1720 */ {I_HADDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45645, 159},
+    /* 1721 */ {I_HADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45651, 159},
+    /* 1722 */ {I_HSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45657, 159},
+    /* 1723 */ {I_HSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45663, 159},
+    /* 1724 */ {I_LDDQU, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45669, 159},
+    /* 1725 */ {I_MOVDDUP, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+45675, 160},
+    /* 1726 */ {I_MOVSHDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45681, 161},
+    /* 1727 */ {I_MOVSLDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45687, 161},
+    /* 1728 */ {I_CLGI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49097, 162},
+    /* 1729 */ {I_STGI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49102, 162},
+    /* 1730 */ {I_VMCALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45730, 163},
+    /* 1731 */ {I_VMCLEAR, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45693, 163},
+    /* 1732 */ {I_VMFUNC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49107, 163},
+    /* 1733 */ {I_VMLAUNCH, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49112, 163},
+    /* 1734 */ {I_VMLOAD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49117, 162},
+    /* 1735 */ {I_VMMCALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49122, 162},
+    /* 1736 */ {I_VMPTRLD, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45699, 163},
+    /* 1737 */ {I_VMPTRST, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45705, 163},
+    /* 1738 */ {I_VMREAD, 2, {RM_GPR|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34356, 164},
+    /* 1739 */ {I_VMREAD, 2, {RM_GPR|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34355, 165},
+    /* 1740 */ {I_VMRESUME, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49127, 163},
+    /* 1741 */ {I_VMRUN, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49132, 162},
+    /* 1742 */ {I_VMSAVE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49137, 162},
+    /* 1743 */ {I_VMWRITE, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34363, 164},
+    /* 1744 */ {I_VMWRITE, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34362, 165},
+    /* 1745 */ {I_VMXOFF, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49142, 163},
+    /* 1746 */ {I_VMXON, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42511, 163},
+    /* 1747 */ {I_INVEPT, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12833, 166},
+    /* 1748 */ {I_INVEPT, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12832, 167},
+    /* 1749 */ {I_INVVPID, 2, {REG_GPR|BITS32,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12841, 166},
+    /* 1750 */ {I_INVVPID, 2, {REG_GPR|BITS64,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+12840, 167},
+    /* 1751 */ {I_PVALIDATE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45711, 162},
+    /* 1752 */ {I_RMPADJUST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45717, 162},
+    /* 1753 */ {I_VMGEXIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45723, 162},
+    /* 1754 */ {I_VMGEXIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45729, 162},
+    /* 1755 */ {I_PABSB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34369, 168},
+    /* 1756 */ {I_PABSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34376, 169},
+    /* 1757 */ {I_PABSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34383, 168},
+    /* 1758 */ {I_PABSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34390, 169},
+    /* 1759 */ {I_PABSD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34397, 168},
+    /* 1760 */ {I_PABSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34404, 169},
+    /* 1761 */ {I_PALIGNR, 3, {MMXREG,RM_MMX,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12848, 168},
+    /* 1762 */ {I_PALIGNR, 3, {XMM_L16,RM_XMM_L16,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12856, 169},
+    /* 1763 */ {I_PHADDW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34411, 168},
+    /* 1764 */ {I_PHADDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34418, 169},
+    /* 1765 */ {I_PHADDD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34425, 168},
+    /* 1766 */ {I_PHADDD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34432, 169},
+    /* 1767 */ {I_PHADDSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34439, 168},
+    /* 1768 */ {I_PHADDSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34446, 169},
+    /* 1769 */ {I_PHSUBW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34453, 168},
+    /* 1770 */ {I_PHSUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34460, 169},
+    /* 1771 */ {I_PHSUBD, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34467, 168},
+    /* 1772 */ {I_PHSUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34474, 169},
+    /* 1773 */ {I_PHSUBSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34481, 168},
+    /* 1774 */ {I_PHSUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34488, 169},
+    /* 1775 */ {I_PMADDUBSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34495, 168},
+    /* 1776 */ {I_PMADDUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34502, 169},
+    /* 1777 */ {I_PMULHRSW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34509, 168},
+    /* 1778 */ {I_PMULHRSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34516, 169},
+    /* 1779 */ {I_PSHUFB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34523, 168},
+    /* 1780 */ {I_PSHUFB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34530, 169},
+    /* 1781 */ {I_PSIGNB, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34537, 168},
+    /* 1782 */ {I_PSIGNB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34544, 169},
+    /* 1783 */ {I_PSIGNW, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34551, 168},
+    /* 1784 */ {I_PSIGNW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34558, 169},
+    /* 1785 */ {I_PSIGND, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+34565, 168},
+    /* 1786 */ {I_PSIGND, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34572, 169},
+    /* 1787 */ {I_EXTRQ, 3, {XMM_L16,IMMEDIATE,IMMEDIATE,0,0}, NO_DECORATOR, nasm_bytecodes+12864, 170},
+    /* 1788 */ {I_EXTRQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45735, 170},
+    /* 1789 */ {I_INSERTQ, 4, {XMM_L16,XMM_L16,IMMEDIATE,IMMEDIATE,0}, NO_DECORATOR, nasm_bytecodes+12872, 170},
+    /* 1790 */ {I_INSERTQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45741, 170},
+    /* 1791 */ {I_MOVNTSD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45747, 171},
+    /* 1792 */ {I_MOVNTSS, 2, {MEMORY|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+45753, 172},
+    /* 1793 */ {I_LZCNT, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34579, 113},
+    /* 1794 */ {I_LZCNT, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34586, 113},
+    /* 1795 */ {I_LZCNT, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34593, 59},
+    /* 1796 */ {I_BLENDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12880, 173},
+    /* 1797 */ {I_BLENDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12888, 173},
+    /* 1798 */ {I_BLENDVPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+34600, 173},
+    /* 1799 */ {I_BLENDVPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34600, 173},
+    /* 1800 */ {I_BLENDVPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+34607, 173},
+    /* 1801 */ {I_BLENDVPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34607, 173},
+    /* 1802 */ {I_DPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12896, 173},
+    /* 1803 */ {I_DPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12904, 173},
+    /* 1804 */ {I_EXTRACTPS, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4241, 173},
+    /* 1805 */ {I_EXTRACTPS, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4240, 174},
+    /* 1806 */ {I_INSERTPS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12912, 173},
+    /* 1807 */ {I_MOVNTDQA, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34614, 173},
+    /* 1808 */ {I_MPSADBW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12920, 173},
+    /* 1809 */ {I_PACKUSDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34621, 173},
+    /* 1810 */ {I_PBLENDVB, 3, {XMM_L16,RM_XMM_L16,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+34628, 173},
+    /* 1811 */ {I_PBLENDVB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34628, 173},
+    /* 1812 */ {I_PBLENDW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12928, 173},
+    /* 1813 */ {I_PCMPEQQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34635, 173},
+    /* 1814 */ {I_PEXTRB, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4250, 173},
+    /* 1815 */ {I_PEXTRB, 3, {MEMORY|BITS8,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4250, 173},
+    /* 1816 */ {I_PEXTRB, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4249, 174},
+    /* 1817 */ {I_PEXTRD, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4258, 173},
+    /* 1818 */ {I_PEXTRQ, 3, {RM_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4267, 174},
+    /* 1819 */ {I_PEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4277, 173},
+    /* 1820 */ {I_PEXTRW, 3, {MEMORY|BITS16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4277, 173},
+    /* 1821 */ {I_PEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4276, 174},
+    /* 1822 */ {I_PHMINPOSUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34642, 173},
+    /* 1823 */ {I_PINSRB, 3, {XMM_L16,MEMORY,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4286, 175},
+    /* 1824 */ {I_PINSRB, 3, {XMM_L16,RM_GPR|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4285, 175},
+    /* 1825 */ {I_PINSRB, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4286, 175},
+    /* 1826 */ {I_PINSRD, 3, {XMM_L16,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4294, 175},
+    /* 1827 */ {I_PINSRQ, 3, {XMM_L16,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+4303, 176},
+    /* 1828 */ {I_PMAXSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34649, 173},
+    /* 1829 */ {I_PMAXSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34656, 173},
+    /* 1830 */ {I_PMAXUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34663, 173},
+    /* 1831 */ {I_PMAXUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34670, 173},
+    /* 1832 */ {I_PMINSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34677, 173},
+    /* 1833 */ {I_PMINSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34684, 173},
+    /* 1834 */ {I_PMINUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34691, 173},
+    /* 1835 */ {I_PMINUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34698, 173},
+    /* 1836 */ {I_PMOVSXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34705, 177},
+    /* 1837 */ {I_PMOVSXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34712, 178},
+    /* 1838 */ {I_PMOVSXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34719, 179},
+    /* 1839 */ {I_PMOVSXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34726, 177},
+    /* 1840 */ {I_PMOVSXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34733, 178},
+    /* 1841 */ {I_PMOVSXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34740, 177},
+    /* 1842 */ {I_PMOVZXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34747, 177},
+    /* 1843 */ {I_PMOVZXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34754, 178},
+    /* 1844 */ {I_PMOVZXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34761, 179},
+    /* 1845 */ {I_PMOVZXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34768, 177},
+    /* 1846 */ {I_PMOVZXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34775, 178},
+    /* 1847 */ {I_PMOVZXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34782, 177},
+    /* 1848 */ {I_PMULDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34789, 173},
+    /* 1849 */ {I_PMULLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34796, 173},
+    /* 1850 */ {I_PTEST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34803, 173},
+    /* 1851 */ {I_ROUNDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12936, 173},
+    /* 1852 */ {I_ROUNDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12944, 173},
+    /* 1853 */ {I_ROUNDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12952, 173},
+    /* 1854 */ {I_ROUNDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+12960, 173},
+    /* 1855 */ {I_CRC32, 2, {REG_GPR|BITS32,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12985, 180},
+    /* 1856 */ {I_CRC32, 2, {REG_GPR|BITS32,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+12968, 180},
+    /* 1857 */ {I_CRC32, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+12976, 180},
+    /* 1858 */ {I_CRC32, 2, {REG_GPR|BITS64,RM_GPR|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+12984, 181},
+    /* 1859 */ {I_CRC32, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+12992, 181},
+    /* 1860 */ {I_PCMPESTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13000, 180},
+    /* 1861 */ {I_PCMPESTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13008, 180},
+    /* 1862 */ {I_PCMPISTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13016, 180},
+    /* 1863 */ {I_PCMPISTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13024, 180},
+    /* 1864 */ {I_PCMPGTQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34810, 180},
+    /* 1865 */ {I_POPCNT, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+34817, 182},
+    /* 1866 */ {I_POPCNT, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+34824, 183},
+    /* 1867 */ {I_POPCNT, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+34831, 184},
+    /* 1868 */ {I_GETSEC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+50183, 139},
+    /* 1869 */ {I_PFRCPV, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+13032, 185},
+    /* 1870 */ {I_PFRSQRTV, 2, {MMXREG,RM_MMX,0,0,0}, NO_DECORATOR, nasm_bytecodes+13040, 185},
+    /* 1871 */ {I_MOVBE, 2, {REG_GPR|BITS16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+13048, 186},
+    /* 1872 */ {I_MOVBE, 2, {REG_GPR|BITS32,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+13056, 186},
+    /* 1873 */ {I_MOVBE, 2, {REG_GPR|BITS64,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+13064, 186},
+    /* 1874 */ {I_MOVBE, 2, {MEMORY|BITS16,REG_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+13072, 186},
+    /* 1875 */ {I_MOVBE, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+13080, 186},
+    /* 1876 */ {I_MOVBE, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+13088, 186},
+    /* 1877 */ {I_AESENC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34838, 187},
+    /* 1878 */ {I_AESENCLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34845, 187},
+    /* 1879 */ {I_AESDEC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34852, 187},
+    /* 1880 */ {I_AESDECLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34859, 187},
+    /* 1881 */ {I_AESIMC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34866, 187},
+    /* 1882 */ {I_AESKEYGENASSIST, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13096, 187},
+    /* 1883 */ {I_VAESENC, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34873, 188},
+    /* 1884 */ {I_VAESENC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34880, 188},
+    /* 1885 */ {I_VAESENCLAST, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34887, 188},
+    /* 1886 */ {I_VAESENCLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34894, 188},
+    /* 1887 */ {I_VAESDEC, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34901, 188},
+    /* 1888 */ {I_VAESDEC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34908, 188},
+    /* 1889 */ {I_VAESDECLAST, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34915, 188},
+    /* 1890 */ {I_VAESDECLAST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34922, 188},
+    /* 1891 */ {I_VAESIMC, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34929, 188},
+    /* 1892 */ {I_VAESKEYGENASSIST, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13104, 188},
+    /* 1893 */ {I_VAESENC, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34936, 189},
+    /* 1894 */ {I_VAESENC, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34943, 189},
+    /* 1895 */ {I_VAESENCLAST, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34950, 189},
+    /* 1896 */ {I_VAESENCLAST, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34957, 189},
+    /* 1897 */ {I_VAESDEC, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34964, 189},
+    /* 1898 */ {I_VAESDEC, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34971, 189},
+    /* 1899 */ {I_VAESDECLAST, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+34978, 189},
+    /* 1900 */ {I_VAESDECLAST, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+34985, 189},
+    /* 1901 */ {I_VAESENC, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13112, 190},
+    /* 1902 */ {I_VAESENC, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13120, 190},
+    /* 1903 */ {I_VAESENC, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13128, 190},
+    /* 1904 */ {I_VAESENC, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13136, 190},
+    /* 1905 */ {I_VAESENCLAST, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13144, 190},
+    /* 1906 */ {I_VAESENCLAST, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13152, 190},
+    /* 1907 */ {I_VAESENCLAST, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13160, 190},
+    /* 1908 */ {I_VAESENCLAST, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13168, 190},
+    /* 1909 */ {I_VAESDEC, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13176, 190},
+    /* 1910 */ {I_VAESDEC, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13184, 190},
+    /* 1911 */ {I_VAESDEC, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13192, 190},
+    /* 1912 */ {I_VAESDEC, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13200, 190},
+    /* 1913 */ {I_VAESDECLAST, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+13208, 190},
+    /* 1914 */ {I_VAESDECLAST, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+13216, 190},
+    /* 1915 */ {I_VAESDECLAST, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+13224, 190},
+    /* 1916 */ {I_VAESDECLAST, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+13232, 190},
+    /* 1917 */ {I_VAESENC, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13240, 191},
+    /* 1918 */ {I_VAESENC, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13248, 191},
+    /* 1919 */ {I_VAESENCLAST, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13256, 191},
+    /* 1920 */ {I_VAESENCLAST, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13264, 191},
+    /* 1921 */ {I_VAESDEC, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13272, 191},
+    /* 1922 */ {I_VAESDEC, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13280, 191},
+    /* 1923 */ {I_VAESDECLAST, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+13288, 191},
+    /* 1924 */ {I_VAESDECLAST, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+13296, 191},
+    /* 1925 */ {I_VADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+34992, 188},
+    /* 1926 */ {I_VADDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+34999, 188},
+    /* 1927 */ {I_VADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35006, 188},
+    /* 1928 */ {I_VADDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35013, 188},
+    /* 1929 */ {I_VADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35020, 188},
+    /* 1930 */ {I_VADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35027, 188},
+    /* 1931 */ {I_VADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35034, 188},
+    /* 1932 */ {I_VADDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35041, 188},
+    /* 1933 */ {I_VADDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35048, 188},
+    /* 1934 */ {I_VADDSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35055, 188},
+    /* 1935 */ {I_VADDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35062, 188},
+    /* 1936 */ {I_VADDSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35069, 188},
+    /* 1937 */ {I_VADDSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35076, 188},
+    /* 1938 */ {I_VADDSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35083, 188},
+    /* 1939 */ {I_VADDSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35090, 188},
+    /* 1940 */ {I_VADDSUBPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35097, 188},
+    /* 1941 */ {I_VADDSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35104, 188},
+    /* 1942 */ {I_VADDSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35111, 188},
+    /* 1943 */ {I_VADDSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35118, 188},
+    /* 1944 */ {I_VADDSUBPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35125, 188},
+    /* 1945 */ {I_VANDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35132, 188},
+    /* 1946 */ {I_VANDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35139, 188},
+    /* 1947 */ {I_VANDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35146, 188},
+    /* 1948 */ {I_VANDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35153, 188},
+    /* 1949 */ {I_VANDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35160, 188},
+    /* 1950 */ {I_VANDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35167, 188},
+    /* 1951 */ {I_VANDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35174, 188},
+    /* 1952 */ {I_VANDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35181, 188},
+    /* 1953 */ {I_VANDNPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35188, 188},
+    /* 1954 */ {I_VANDNPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35195, 188},
+    /* 1955 */ {I_VANDNPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35202, 188},
+    /* 1956 */ {I_VANDNPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35209, 188},
+    /* 1957 */ {I_VANDNPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35216, 188},
+    /* 1958 */ {I_VANDNPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35223, 188},
+    /* 1959 */ {I_VANDNPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35230, 188},
+    /* 1960 */ {I_VANDNPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35237, 188},
+    /* 1961 */ {I_VBLENDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13304, 188},
+    /* 1962 */ {I_VBLENDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13312, 188},
+    /* 1963 */ {I_VBLENDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13320, 188},
+    /* 1964 */ {I_VBLENDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13328, 188},
+    /* 1965 */ {I_VBLENDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13336, 188},
+    /* 1966 */ {I_VBLENDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13344, 188},
+    /* 1967 */ {I_VBLENDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13352, 188},
+    /* 1968 */ {I_VBLENDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13360, 188},
+    /* 1969 */ {I_VBLENDVPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13368, 188},
+    /* 1970 */ {I_VBLENDVPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13376, 188},
+    /* 1971 */ {I_VBLENDVPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13384, 188},
+    /* 1972 */ {I_VBLENDVPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13392, 188},
+    /* 1973 */ {I_VBLENDVPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13400, 188},
+    /* 1974 */ {I_VBLENDVPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13408, 188},
+    /* 1975 */ {I_VBLENDVPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13416, 188},
+    /* 1976 */ {I_VBLENDVPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13424, 188},
+    /* 1977 */ {I_VBROADCASTSS, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35244, 188},
+    /* 1978 */ {I_VBROADCASTSS, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35251, 188},
+    /* 1979 */ {I_VBROADCASTSD, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35258, 188},
+    /* 1980 */ {I_VBROADCASTF128, 2, {YMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35265, 188},
+    /* 1981 */ {I_VCMPEQ_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4312, 188},
+    /* 1982 */ {I_VCMPEQ_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4321, 188},
+    /* 1983 */ {I_VCMPEQ_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4330, 188},
+    /* 1984 */ {I_VCMPEQ_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4339, 188},
+    /* 1985 */ {I_VCMPEQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4348, 188},
+    /* 1986 */ {I_VCMPEQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4357, 188},
+    /* 1987 */ {I_VCMPEQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4366, 188},
+    /* 1988 */ {I_VCMPEQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4375, 188},
+    /* 1989 */ {I_VCMPLT_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4384, 188},
+    /* 1990 */ {I_VCMPLT_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4393, 188},
+    /* 1991 */ {I_VCMPLT_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4402, 188},
+    /* 1992 */ {I_VCMPLT_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4411, 188},
+    /* 1993 */ {I_VCMPLTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4384, 188},
+    /* 1994 */ {I_VCMPLTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4393, 188},
+    /* 1995 */ {I_VCMPLTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4402, 188},
+    /* 1996 */ {I_VCMPLTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4411, 188},
+    /* 1997 */ {I_VCMPLE_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4420, 188},
+    /* 1998 */ {I_VCMPLE_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4429, 188},
+    /* 1999 */ {I_VCMPLE_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4438, 188},
+    /* 2000 */ {I_VCMPLE_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4447, 188},
+    /* 2001 */ {I_VCMPLEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4420, 188},
+    /* 2002 */ {I_VCMPLEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4429, 188},
+    /* 2003 */ {I_VCMPLEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4438, 188},
+    /* 2004 */ {I_VCMPLEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4447, 188},
+    /* 2005 */ {I_VCMPUNORD_QPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4456, 188},
+    /* 2006 */ {I_VCMPUNORD_QPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4465, 188},
+    /* 2007 */ {I_VCMPUNORD_QPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4474, 188},
+    /* 2008 */ {I_VCMPUNORD_QPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4483, 188},
+    /* 2009 */ {I_VCMPUNORDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4456, 188},
+    /* 2010 */ {I_VCMPUNORDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4465, 188},
+    /* 2011 */ {I_VCMPUNORDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4474, 188},
+    /* 2012 */ {I_VCMPUNORDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4483, 188},
+    /* 2013 */ {I_VCMPNEQ_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4492, 188},
+    /* 2014 */ {I_VCMPNEQ_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4501, 188},
+    /* 2015 */ {I_VCMPNEQ_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4510, 188},
+    /* 2016 */ {I_VCMPNEQ_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4519, 188},
+    /* 2017 */ {I_VCMPNEQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4492, 188},
+    /* 2018 */ {I_VCMPNEQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4501, 188},
+    /* 2019 */ {I_VCMPNEQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4510, 188},
+    /* 2020 */ {I_VCMPNEQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4519, 188},
+    /* 2021 */ {I_VCMPNLT_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4528, 188},
+    /* 2022 */ {I_VCMPNLT_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4537, 188},
+    /* 2023 */ {I_VCMPNLT_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4546, 188},
+    /* 2024 */ {I_VCMPNLT_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4555, 188},
+    /* 2025 */ {I_VCMPNLTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4528, 188},
+    /* 2026 */ {I_VCMPNLTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4537, 188},
+    /* 2027 */ {I_VCMPNLTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4546, 188},
+    /* 2028 */ {I_VCMPNLTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4555, 188},
+    /* 2029 */ {I_VCMPNLE_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4564, 188},
+    /* 2030 */ {I_VCMPNLE_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4573, 188},
+    /* 2031 */ {I_VCMPNLE_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4582, 188},
+    /* 2032 */ {I_VCMPNLE_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4591, 188},
+    /* 2033 */ {I_VCMPNLEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4564, 188},
+    /* 2034 */ {I_VCMPNLEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4573, 188},
+    /* 2035 */ {I_VCMPNLEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4582, 188},
+    /* 2036 */ {I_VCMPNLEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4591, 188},
+    /* 2037 */ {I_VCMPORD_QPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4600, 188},
+    /* 2038 */ {I_VCMPORD_QPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4609, 188},
+    /* 2039 */ {I_VCMPORD_QPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4618, 188},
+    /* 2040 */ {I_VCMPORD_QPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4627, 188},
+    /* 2041 */ {I_VCMPORDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4600, 188},
+    /* 2042 */ {I_VCMPORDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4609, 188},
+    /* 2043 */ {I_VCMPORDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4618, 188},
+    /* 2044 */ {I_VCMPORDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4627, 188},
+    /* 2045 */ {I_VCMPEQ_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4636, 188},
+    /* 2046 */ {I_VCMPEQ_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4645, 188},
+    /* 2047 */ {I_VCMPEQ_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4654, 188},
+    /* 2048 */ {I_VCMPEQ_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4663, 188},
+    /* 2049 */ {I_VCMPNGE_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4672, 188},
+    /* 2050 */ {I_VCMPNGE_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4681, 188},
+    /* 2051 */ {I_VCMPNGE_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4690, 188},
+    /* 2052 */ {I_VCMPNGE_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4699, 188},
+    /* 2053 */ {I_VCMPNGEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4672, 188},
+    /* 2054 */ {I_VCMPNGEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4681, 188},
+    /* 2055 */ {I_VCMPNGEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4690, 188},
+    /* 2056 */ {I_VCMPNGEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4699, 188},
+    /* 2057 */ {I_VCMPNGT_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4708, 188},
+    /* 2058 */ {I_VCMPNGT_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4717, 188},
+    /* 2059 */ {I_VCMPNGT_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4726, 188},
+    /* 2060 */ {I_VCMPNGT_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4735, 188},
+    /* 2061 */ {I_VCMPNGTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4708, 188},
+    /* 2062 */ {I_VCMPNGTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4717, 188},
+    /* 2063 */ {I_VCMPNGTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4726, 188},
+    /* 2064 */ {I_VCMPNGTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4735, 188},
+    /* 2065 */ {I_VCMPFALSE_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4744, 188},
+    /* 2066 */ {I_VCMPFALSE_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4753, 188},
+    /* 2067 */ {I_VCMPFALSE_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4762, 188},
+    /* 2068 */ {I_VCMPFALSE_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4771, 188},
+    /* 2069 */ {I_VCMPFALSEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4744, 188},
+    /* 2070 */ {I_VCMPFALSEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4753, 188},
+    /* 2071 */ {I_VCMPFALSEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4762, 188},
+    /* 2072 */ {I_VCMPFALSEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4771, 188},
+    /* 2073 */ {I_VCMPNEQ_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4780, 188},
+    /* 2074 */ {I_VCMPNEQ_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4789, 188},
+    /* 2075 */ {I_VCMPNEQ_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4798, 188},
+    /* 2076 */ {I_VCMPNEQ_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4807, 188},
+    /* 2077 */ {I_VCMPGE_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4816, 188},
+    /* 2078 */ {I_VCMPGE_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4825, 188},
+    /* 2079 */ {I_VCMPGE_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4834, 188},
+    /* 2080 */ {I_VCMPGE_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4843, 188},
+    /* 2081 */ {I_VCMPGEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4816, 188},
+    /* 2082 */ {I_VCMPGEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4825, 188},
+    /* 2083 */ {I_VCMPGEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4834, 188},
+    /* 2084 */ {I_VCMPGEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4843, 188},
+    /* 2085 */ {I_VCMPGT_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4852, 188},
+    /* 2086 */ {I_VCMPGT_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4861, 188},
+    /* 2087 */ {I_VCMPGT_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4870, 188},
+    /* 2088 */ {I_VCMPGT_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4879, 188},
+    /* 2089 */ {I_VCMPGTPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4852, 188},
+    /* 2090 */ {I_VCMPGTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4861, 188},
+    /* 2091 */ {I_VCMPGTPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4870, 188},
+    /* 2092 */ {I_VCMPGTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4879, 188},
+    /* 2093 */ {I_VCMPTRUE_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4888, 188},
+    /* 2094 */ {I_VCMPTRUE_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4897, 188},
+    /* 2095 */ {I_VCMPTRUE_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4906, 188},
+    /* 2096 */ {I_VCMPTRUE_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4915, 188},
+    /* 2097 */ {I_VCMPTRUEPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4888, 188},
+    /* 2098 */ {I_VCMPTRUEPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4897, 188},
+    /* 2099 */ {I_VCMPTRUEPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4906, 188},
+    /* 2100 */ {I_VCMPTRUEPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4915, 188},
+    /* 2101 */ {I_VCMPEQ_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4312, 188},
+    /* 2102 */ {I_VCMPEQ_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4321, 188},
+    /* 2103 */ {I_VCMPEQ_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4330, 188},
+    /* 2104 */ {I_VCMPEQ_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4339, 188},
+    /* 2105 */ {I_VCMPLT_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4924, 188},
+    /* 2106 */ {I_VCMPLT_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4933, 188},
+    /* 2107 */ {I_VCMPLT_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4942, 188},
+    /* 2108 */ {I_VCMPLT_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4951, 188},
+    /* 2109 */ {I_VCMPLE_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4960, 188},
+    /* 2110 */ {I_VCMPLE_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+4969, 188},
+    /* 2111 */ {I_VCMPLE_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+4978, 188},
+    /* 2112 */ {I_VCMPLE_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+4987, 188},
+    /* 2113 */ {I_VCMPUNORD_SPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+4996, 188},
+    /* 2114 */ {I_VCMPUNORD_SPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5005, 188},
+    /* 2115 */ {I_VCMPUNORD_SPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5014, 188},
+    /* 2116 */ {I_VCMPUNORD_SPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5023, 188},
+    /* 2117 */ {I_VCMPNEQ_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5032, 188},
+    /* 2118 */ {I_VCMPNEQ_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5041, 188},
+    /* 2119 */ {I_VCMPNEQ_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5050, 188},
+    /* 2120 */ {I_VCMPNEQ_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5059, 188},
+    /* 2121 */ {I_VCMPNLT_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5068, 188},
+    /* 2122 */ {I_VCMPNLT_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5077, 188},
+    /* 2123 */ {I_VCMPNLT_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5086, 188},
+    /* 2124 */ {I_VCMPNLT_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5095, 188},
+    /* 2125 */ {I_VCMPNLE_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5104, 188},
+    /* 2126 */ {I_VCMPNLE_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5113, 188},
+    /* 2127 */ {I_VCMPNLE_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5122, 188},
+    /* 2128 */ {I_VCMPNLE_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5131, 188},
+    /* 2129 */ {I_VCMPORD_SPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5140, 188},
+    /* 2130 */ {I_VCMPORD_SPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5149, 188},
+    /* 2131 */ {I_VCMPORD_SPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5158, 188},
+    /* 2132 */ {I_VCMPORD_SPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5167, 188},
+    /* 2133 */ {I_VCMPEQ_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5176, 188},
+    /* 2134 */ {I_VCMPEQ_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5185, 188},
+    /* 2135 */ {I_VCMPEQ_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5194, 188},
+    /* 2136 */ {I_VCMPEQ_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5203, 188},
+    /* 2137 */ {I_VCMPNGE_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5212, 188},
+    /* 2138 */ {I_VCMPNGE_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5221, 188},
+    /* 2139 */ {I_VCMPNGE_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5230, 188},
+    /* 2140 */ {I_VCMPNGE_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5239, 188},
+    /* 2141 */ {I_VCMPNGT_UQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5248, 188},
+    /* 2142 */ {I_VCMPNGT_UQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5257, 188},
+    /* 2143 */ {I_VCMPNGT_UQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5266, 188},
+    /* 2144 */ {I_VCMPNGT_UQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5275, 188},
+    /* 2145 */ {I_VCMPFALSE_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5284, 188},
+    /* 2146 */ {I_VCMPFALSE_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5293, 188},
+    /* 2147 */ {I_VCMPFALSE_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5302, 188},
+    /* 2148 */ {I_VCMPFALSE_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5311, 188},
+    /* 2149 */ {I_VCMPNEQ_OSPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5320, 188},
+    /* 2150 */ {I_VCMPNEQ_OSPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5329, 188},
+    /* 2151 */ {I_VCMPNEQ_OSPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5338, 188},
+    /* 2152 */ {I_VCMPNEQ_OSPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5347, 188},
+    /* 2153 */ {I_VCMPGE_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5356, 188},
+    /* 2154 */ {I_VCMPGE_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5365, 188},
+    /* 2155 */ {I_VCMPGE_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5374, 188},
+    /* 2156 */ {I_VCMPGE_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5383, 188},
+    /* 2157 */ {I_VCMPGT_OQPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5392, 188},
+    /* 2158 */ {I_VCMPGT_OQPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5401, 188},
+    /* 2159 */ {I_VCMPGT_OQPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5410, 188},
+    /* 2160 */ {I_VCMPGT_OQPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5419, 188},
+    /* 2161 */ {I_VCMPTRUE_USPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5428, 188},
+    /* 2162 */ {I_VCMPTRUE_USPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5437, 188},
+    /* 2163 */ {I_VCMPTRUE_USPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5446, 188},
+    /* 2164 */ {I_VCMPTRUE_USPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5455, 188},
+    /* 2165 */ {I_VCMPPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13432, 188},
+    /* 2166 */ {I_VCMPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13440, 188},
+    /* 2167 */ {I_VCMPPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13448, 188},
+    /* 2168 */ {I_VCMPPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13456, 188},
+    /* 2169 */ {I_VCMPEQ_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5464, 188},
+    /* 2170 */ {I_VCMPEQ_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5473, 188},
+    /* 2171 */ {I_VCMPEQ_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5482, 188},
+    /* 2172 */ {I_VCMPEQ_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5491, 188},
+    /* 2173 */ {I_VCMPEQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5500, 188},
+    /* 2174 */ {I_VCMPEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5509, 188},
+    /* 2175 */ {I_VCMPEQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5518, 188},
+    /* 2176 */ {I_VCMPEQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5527, 188},
+    /* 2177 */ {I_VCMPLT_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5536, 188},
+    /* 2178 */ {I_VCMPLT_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5545, 188},
+    /* 2179 */ {I_VCMPLT_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5554, 188},
+    /* 2180 */ {I_VCMPLT_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5563, 188},
+    /* 2181 */ {I_VCMPLTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5536, 188},
+    /* 2182 */ {I_VCMPLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5545, 188},
+    /* 2183 */ {I_VCMPLTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5554, 188},
+    /* 2184 */ {I_VCMPLTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5563, 188},
+    /* 2185 */ {I_VCMPLE_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5572, 188},
+    /* 2186 */ {I_VCMPLE_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5581, 188},
+    /* 2187 */ {I_VCMPLE_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5590, 188},
+    /* 2188 */ {I_VCMPLE_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5599, 188},
+    /* 2189 */ {I_VCMPLEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5572, 188},
+    /* 2190 */ {I_VCMPLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5581, 188},
+    /* 2191 */ {I_VCMPLEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5590, 188},
+    /* 2192 */ {I_VCMPLEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5599, 188},
+    /* 2193 */ {I_VCMPUNORD_QPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5608, 188},
+    /* 2194 */ {I_VCMPUNORD_QPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5617, 188},
+    /* 2195 */ {I_VCMPUNORD_QPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5626, 188},
+    /* 2196 */ {I_VCMPUNORD_QPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5635, 188},
+    /* 2197 */ {I_VCMPUNORDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5608, 188},
+    /* 2198 */ {I_VCMPUNORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5617, 188},
+    /* 2199 */ {I_VCMPUNORDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5626, 188},
+    /* 2200 */ {I_VCMPUNORDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5635, 188},
+    /* 2201 */ {I_VCMPNEQ_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5644, 188},
+    /* 2202 */ {I_VCMPNEQ_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5653, 188},
+    /* 2203 */ {I_VCMPNEQ_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5662, 188},
+    /* 2204 */ {I_VCMPNEQ_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5671, 188},
+    /* 2205 */ {I_VCMPNEQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5644, 188},
+    /* 2206 */ {I_VCMPNEQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5653, 188},
+    /* 2207 */ {I_VCMPNEQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5662, 188},
+    /* 2208 */ {I_VCMPNEQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5671, 188},
+    /* 2209 */ {I_VCMPNLT_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5680, 188},
+    /* 2210 */ {I_VCMPNLT_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5689, 188},
+    /* 2211 */ {I_VCMPNLT_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5698, 188},
+    /* 2212 */ {I_VCMPNLT_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5707, 188},
+    /* 2213 */ {I_VCMPNLTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5680, 188},
+    /* 2214 */ {I_VCMPNLTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5689, 188},
+    /* 2215 */ {I_VCMPNLTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5698, 188},
+    /* 2216 */ {I_VCMPNLTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5707, 188},
+    /* 2217 */ {I_VCMPNLE_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5716, 188},
+    /* 2218 */ {I_VCMPNLE_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5725, 188},
+    /* 2219 */ {I_VCMPNLE_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5734, 188},
+    /* 2220 */ {I_VCMPNLE_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5743, 188},
+    /* 2221 */ {I_VCMPNLEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5716, 188},
+    /* 2222 */ {I_VCMPNLEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5725, 188},
+    /* 2223 */ {I_VCMPNLEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5734, 188},
+    /* 2224 */ {I_VCMPNLEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5743, 188},
+    /* 2225 */ {I_VCMPORD_QPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5752, 188},
+    /* 2226 */ {I_VCMPORD_QPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5761, 188},
+    /* 2227 */ {I_VCMPORD_QPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5770, 188},
+    /* 2228 */ {I_VCMPORD_QPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5779, 188},
+    /* 2229 */ {I_VCMPORDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5752, 188},
+    /* 2230 */ {I_VCMPORDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5761, 188},
+    /* 2231 */ {I_VCMPORDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5770, 188},
+    /* 2232 */ {I_VCMPORDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5779, 188},
+    /* 2233 */ {I_VCMPEQ_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5788, 188},
+    /* 2234 */ {I_VCMPEQ_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5797, 188},
+    /* 2235 */ {I_VCMPEQ_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5806, 188},
+    /* 2236 */ {I_VCMPEQ_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5815, 188},
+    /* 2237 */ {I_VCMPNGE_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5824, 188},
+    /* 2238 */ {I_VCMPNGE_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5833, 188},
+    /* 2239 */ {I_VCMPNGE_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5842, 188},
+    /* 2240 */ {I_VCMPNGE_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5851, 188},
+    /* 2241 */ {I_VCMPNGEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5824, 188},
+    /* 2242 */ {I_VCMPNGEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5833, 188},
+    /* 2243 */ {I_VCMPNGEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5842, 188},
+    /* 2244 */ {I_VCMPNGEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5851, 188},
+    /* 2245 */ {I_VCMPNGT_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5860, 188},
+    /* 2246 */ {I_VCMPNGT_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5869, 188},
+    /* 2247 */ {I_VCMPNGT_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5878, 188},
+    /* 2248 */ {I_VCMPNGT_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5887, 188},
+    /* 2249 */ {I_VCMPNGTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5860, 188},
+    /* 2250 */ {I_VCMPNGTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5869, 188},
+    /* 2251 */ {I_VCMPNGTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5878, 188},
+    /* 2252 */ {I_VCMPNGTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5887, 188},
+    /* 2253 */ {I_VCMPFALSE_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5896, 188},
+    /* 2254 */ {I_VCMPFALSE_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5905, 188},
+    /* 2255 */ {I_VCMPFALSE_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5914, 188},
+    /* 2256 */ {I_VCMPFALSE_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5923, 188},
+    /* 2257 */ {I_VCMPFALSEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5896, 188},
+    /* 2258 */ {I_VCMPFALSEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5905, 188},
+    /* 2259 */ {I_VCMPFALSEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5914, 188},
+    /* 2260 */ {I_VCMPFALSEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5923, 188},
+    /* 2261 */ {I_VCMPNEQ_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5932, 188},
+    /* 2262 */ {I_VCMPNEQ_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5941, 188},
+    /* 2263 */ {I_VCMPNEQ_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5950, 188},
+    /* 2264 */ {I_VCMPNEQ_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5959, 188},
+    /* 2265 */ {I_VCMPGE_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5968, 188},
+    /* 2266 */ {I_VCMPGE_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5977, 188},
+    /* 2267 */ {I_VCMPGE_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5986, 188},
+    /* 2268 */ {I_VCMPGE_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5995, 188},
+    /* 2269 */ {I_VCMPGEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5968, 188},
+    /* 2270 */ {I_VCMPGEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5977, 188},
+    /* 2271 */ {I_VCMPGEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5986, 188},
+    /* 2272 */ {I_VCMPGEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5995, 188},
+    /* 2273 */ {I_VCMPGT_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6004, 188},
+    /* 2274 */ {I_VCMPGT_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6013, 188},
+    /* 2275 */ {I_VCMPGT_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6022, 188},
+    /* 2276 */ {I_VCMPGT_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6031, 188},
+    /* 2277 */ {I_VCMPGTPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6004, 188},
+    /* 2278 */ {I_VCMPGTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6013, 188},
+    /* 2279 */ {I_VCMPGTPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6022, 188},
+    /* 2280 */ {I_VCMPGTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6031, 188},
+    /* 2281 */ {I_VCMPTRUE_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6040, 188},
+    /* 2282 */ {I_VCMPTRUE_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6049, 188},
+    /* 2283 */ {I_VCMPTRUE_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6058, 188},
+    /* 2284 */ {I_VCMPTRUE_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6067, 188},
+    /* 2285 */ {I_VCMPTRUEPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6040, 188},
+    /* 2286 */ {I_VCMPTRUEPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6049, 188},
+    /* 2287 */ {I_VCMPTRUEPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6058, 188},
+    /* 2288 */ {I_VCMPTRUEPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6067, 188},
+    /* 2289 */ {I_VCMPEQ_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+5464, 188},
+    /* 2290 */ {I_VCMPEQ_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+5473, 188},
+    /* 2291 */ {I_VCMPEQ_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+5482, 188},
+    /* 2292 */ {I_VCMPEQ_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+5491, 188},
+    /* 2293 */ {I_VCMPLT_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6076, 188},
+    /* 2294 */ {I_VCMPLT_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6085, 188},
+    /* 2295 */ {I_VCMPLT_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6094, 188},
+    /* 2296 */ {I_VCMPLT_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6103, 188},
+    /* 2297 */ {I_VCMPLE_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6112, 188},
+    /* 2298 */ {I_VCMPLE_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6121, 188},
+    /* 2299 */ {I_VCMPLE_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6130, 188},
+    /* 2300 */ {I_VCMPLE_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6139, 188},
+    /* 2301 */ {I_VCMPUNORD_SPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6148, 188},
+    /* 2302 */ {I_VCMPUNORD_SPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6157, 188},
+    /* 2303 */ {I_VCMPUNORD_SPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6166, 188},
+    /* 2304 */ {I_VCMPUNORD_SPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6175, 188},
+    /* 2305 */ {I_VCMPNEQ_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6184, 188},
+    /* 2306 */ {I_VCMPNEQ_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6193, 188},
+    /* 2307 */ {I_VCMPNEQ_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6202, 188},
+    /* 2308 */ {I_VCMPNEQ_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6211, 188},
+    /* 2309 */ {I_VCMPNLT_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6220, 188},
+    /* 2310 */ {I_VCMPNLT_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6229, 188},
+    /* 2311 */ {I_VCMPNLT_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6238, 188},
+    /* 2312 */ {I_VCMPNLT_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6247, 188},
+    /* 2313 */ {I_VCMPNLE_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6256, 188},
+    /* 2314 */ {I_VCMPNLE_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6265, 188},
+    /* 2315 */ {I_VCMPNLE_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6274, 188},
+    /* 2316 */ {I_VCMPNLE_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6283, 188},
+    /* 2317 */ {I_VCMPORD_SPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6292, 188},
+    /* 2318 */ {I_VCMPORD_SPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6301, 188},
+    /* 2319 */ {I_VCMPORD_SPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6310, 188},
+    /* 2320 */ {I_VCMPORD_SPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6319, 188},
+    /* 2321 */ {I_VCMPEQ_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6328, 188},
+    /* 2322 */ {I_VCMPEQ_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6337, 188},
+    /* 2323 */ {I_VCMPEQ_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6346, 188},
+    /* 2324 */ {I_VCMPEQ_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6355, 188},
+    /* 2325 */ {I_VCMPNGE_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6364, 188},
+    /* 2326 */ {I_VCMPNGE_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6373, 188},
+    /* 2327 */ {I_VCMPNGE_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6382, 188},
+    /* 2328 */ {I_VCMPNGE_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6391, 188},
+    /* 2329 */ {I_VCMPNGT_UQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6400, 188},
+    /* 2330 */ {I_VCMPNGT_UQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6409, 188},
+    /* 2331 */ {I_VCMPNGT_UQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6418, 188},
+    /* 2332 */ {I_VCMPNGT_UQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6427, 188},
+    /* 2333 */ {I_VCMPFALSE_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6436, 188},
+    /* 2334 */ {I_VCMPFALSE_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6445, 188},
+    /* 2335 */ {I_VCMPFALSE_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6454, 188},
+    /* 2336 */ {I_VCMPFALSE_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6463, 188},
+    /* 2337 */ {I_VCMPNEQ_OSPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6472, 188},
+    /* 2338 */ {I_VCMPNEQ_OSPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6481, 188},
+    /* 2339 */ {I_VCMPNEQ_OSPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6490, 188},
+    /* 2340 */ {I_VCMPNEQ_OSPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6499, 188},
+    /* 2341 */ {I_VCMPGE_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6508, 188},
+    /* 2342 */ {I_VCMPGE_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6517, 188},
+    /* 2343 */ {I_VCMPGE_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6526, 188},
+    /* 2344 */ {I_VCMPGE_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6535, 188},
+    /* 2345 */ {I_VCMPGT_OQPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6544, 188},
+    /* 2346 */ {I_VCMPGT_OQPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6553, 188},
+    /* 2347 */ {I_VCMPGT_OQPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6562, 188},
+    /* 2348 */ {I_VCMPGT_OQPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6571, 188},
+    /* 2349 */ {I_VCMPTRUE_USPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+6580, 188},
+    /* 2350 */ {I_VCMPTRUE_USPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+6589, 188},
+    /* 2351 */ {I_VCMPTRUE_USPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+6598, 188},
+    /* 2352 */ {I_VCMPTRUE_USPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+6607, 188},
+    /* 2353 */ {I_VCMPPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13464, 188},
+    /* 2354 */ {I_VCMPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13472, 188},
+    /* 2355 */ {I_VCMPPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13480, 188},
+    /* 2356 */ {I_VCMPPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13488, 188},
+    /* 2357 */ {I_VCMPEQ_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6616, 188},
+    /* 2358 */ {I_VCMPEQ_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6625, 188},
+    /* 2359 */ {I_VCMPEQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6634, 188},
+    /* 2360 */ {I_VCMPEQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6643, 188},
+    /* 2361 */ {I_VCMPLT_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6652, 188},
+    /* 2362 */ {I_VCMPLT_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6661, 188},
+    /* 2363 */ {I_VCMPLTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6652, 188},
+    /* 2364 */ {I_VCMPLTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6661, 188},
+    /* 2365 */ {I_VCMPLE_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6670, 188},
+    /* 2366 */ {I_VCMPLE_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6679, 188},
+    /* 2367 */ {I_VCMPLESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6670, 188},
+    /* 2368 */ {I_VCMPLESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6679, 188},
+    /* 2369 */ {I_VCMPUNORD_QSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6688, 188},
+    /* 2370 */ {I_VCMPUNORD_QSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6697, 188},
+    /* 2371 */ {I_VCMPUNORDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6688, 188},
+    /* 2372 */ {I_VCMPUNORDSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6697, 188},
+    /* 2373 */ {I_VCMPNEQ_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6706, 188},
+    /* 2374 */ {I_VCMPNEQ_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6715, 188},
+    /* 2375 */ {I_VCMPNEQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6706, 188},
+    /* 2376 */ {I_VCMPNEQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6715, 188},
+    /* 2377 */ {I_VCMPNLT_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6724, 188},
+    /* 2378 */ {I_VCMPNLT_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6733, 188},
+    /* 2379 */ {I_VCMPNLTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6724, 188},
+    /* 2380 */ {I_VCMPNLTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6733, 188},
+    /* 2381 */ {I_VCMPNLE_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6742, 188},
+    /* 2382 */ {I_VCMPNLE_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6751, 188},
+    /* 2383 */ {I_VCMPNLESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6742, 188},
+    /* 2384 */ {I_VCMPNLESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6751, 188},
+    /* 2385 */ {I_VCMPORD_QSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6760, 188},
+    /* 2386 */ {I_VCMPORD_QSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6769, 188},
+    /* 2387 */ {I_VCMPORDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6760, 188},
+    /* 2388 */ {I_VCMPORDSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6769, 188},
+    /* 2389 */ {I_VCMPEQ_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6778, 188},
+    /* 2390 */ {I_VCMPEQ_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6787, 188},
+    /* 2391 */ {I_VCMPNGE_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6796, 188},
+    /* 2392 */ {I_VCMPNGE_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6805, 188},
+    /* 2393 */ {I_VCMPNGESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6796, 188},
+    /* 2394 */ {I_VCMPNGESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6805, 188},
+    /* 2395 */ {I_VCMPNGT_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6814, 188},
+    /* 2396 */ {I_VCMPNGT_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6823, 188},
+    /* 2397 */ {I_VCMPNGTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6814, 188},
+    /* 2398 */ {I_VCMPNGTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6823, 188},
+    /* 2399 */ {I_VCMPFALSE_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6832, 188},
+    /* 2400 */ {I_VCMPFALSE_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6841, 188},
+    /* 2401 */ {I_VCMPFALSESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6832, 188},
+    /* 2402 */ {I_VCMPFALSESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6841, 188},
+    /* 2403 */ {I_VCMPNEQ_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6850, 188},
+    /* 2404 */ {I_VCMPNEQ_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6859, 188},
+    /* 2405 */ {I_VCMPGE_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6868, 188},
+    /* 2406 */ {I_VCMPGE_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6877, 188},
+    /* 2407 */ {I_VCMPGESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6868, 188},
+    /* 2408 */ {I_VCMPGESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6877, 188},
+    /* 2409 */ {I_VCMPGT_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6886, 188},
+    /* 2410 */ {I_VCMPGT_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6895, 188},
+    /* 2411 */ {I_VCMPGTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6886, 188},
+    /* 2412 */ {I_VCMPGTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6895, 188},
+    /* 2413 */ {I_VCMPTRUE_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6904, 188},
+    /* 2414 */ {I_VCMPTRUE_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6913, 188},
+    /* 2415 */ {I_VCMPTRUESD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6904, 188},
+    /* 2416 */ {I_VCMPTRUESD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6913, 188},
+    /* 2417 */ {I_VCMPEQ_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6616, 188},
+    /* 2418 */ {I_VCMPEQ_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6625, 188},
+    /* 2419 */ {I_VCMPLT_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6922, 188},
+    /* 2420 */ {I_VCMPLT_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6931, 188},
+    /* 2421 */ {I_VCMPLE_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6940, 188},
+    /* 2422 */ {I_VCMPLE_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6949, 188},
+    /* 2423 */ {I_VCMPUNORD_SSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6958, 188},
+    /* 2424 */ {I_VCMPUNORD_SSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6967, 188},
+    /* 2425 */ {I_VCMPNEQ_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6976, 188},
+    /* 2426 */ {I_VCMPNEQ_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+6985, 188},
+    /* 2427 */ {I_VCMPNLT_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+6994, 188},
+    /* 2428 */ {I_VCMPNLT_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7003, 188},
+    /* 2429 */ {I_VCMPNLE_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7012, 188},
+    /* 2430 */ {I_VCMPNLE_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7021, 188},
+    /* 2431 */ {I_VCMPORD_SSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7030, 188},
+    /* 2432 */ {I_VCMPORD_SSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7039, 188},
+    /* 2433 */ {I_VCMPEQ_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7048, 188},
+    /* 2434 */ {I_VCMPEQ_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7057, 188},
+    /* 2435 */ {I_VCMPNGE_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7066, 188},
+    /* 2436 */ {I_VCMPNGE_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7075, 188},
+    /* 2437 */ {I_VCMPNGT_UQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7084, 188},
+    /* 2438 */ {I_VCMPNGT_UQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7093, 188},
+    /* 2439 */ {I_VCMPFALSE_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7102, 188},
+    /* 2440 */ {I_VCMPFALSE_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7111, 188},
+    /* 2441 */ {I_VCMPNEQ_OSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7120, 188},
+    /* 2442 */ {I_VCMPNEQ_OSSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7129, 188},
+    /* 2443 */ {I_VCMPGE_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7138, 188},
+    /* 2444 */ {I_VCMPGE_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7147, 188},
+    /* 2445 */ {I_VCMPGT_OQSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7156, 188},
+    /* 2446 */ {I_VCMPGT_OQSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7165, 188},
+    /* 2447 */ {I_VCMPTRUE_USSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7174, 188},
+    /* 2448 */ {I_VCMPTRUE_USSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7183, 188},
+    /* 2449 */ {I_VCMPSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13496, 188},
+    /* 2450 */ {I_VCMPSD, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13504, 188},
+    /* 2451 */ {I_VCMPEQ_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7192, 188},
+    /* 2452 */ {I_VCMPEQ_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7201, 188},
+    /* 2453 */ {I_VCMPEQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7210, 188},
+    /* 2454 */ {I_VCMPEQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7219, 188},
+    /* 2455 */ {I_VCMPLT_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7228, 188},
+    /* 2456 */ {I_VCMPLT_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7237, 188},
+    /* 2457 */ {I_VCMPLTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7228, 188},
+    /* 2458 */ {I_VCMPLTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7237, 188},
+    /* 2459 */ {I_VCMPLE_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7246, 188},
+    /* 2460 */ {I_VCMPLE_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7255, 188},
+    /* 2461 */ {I_VCMPLESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7246, 188},
+    /* 2462 */ {I_VCMPLESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7255, 188},
+    /* 2463 */ {I_VCMPUNORD_QSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7264, 188},
+    /* 2464 */ {I_VCMPUNORD_QSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7273, 188},
+    /* 2465 */ {I_VCMPUNORDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7264, 188},
+    /* 2466 */ {I_VCMPUNORDSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7273, 188},
+    /* 2467 */ {I_VCMPNEQ_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7282, 188},
+    /* 2468 */ {I_VCMPNEQ_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7291, 188},
+    /* 2469 */ {I_VCMPNEQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7282, 188},
+    /* 2470 */ {I_VCMPNEQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7291, 188},
+    /* 2471 */ {I_VCMPNLT_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7300, 188},
+    /* 2472 */ {I_VCMPNLT_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7309, 188},
+    /* 2473 */ {I_VCMPNLTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7300, 188},
+    /* 2474 */ {I_VCMPNLTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7309, 188},
+    /* 2475 */ {I_VCMPNLE_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7318, 188},
+    /* 2476 */ {I_VCMPNLE_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7327, 188},
+    /* 2477 */ {I_VCMPNLESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7318, 188},
+    /* 2478 */ {I_VCMPNLESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7327, 188},
+    /* 2479 */ {I_VCMPORD_QSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7336, 188},
+    /* 2480 */ {I_VCMPORD_QSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7345, 188},
+    /* 2481 */ {I_VCMPORDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7336, 188},
+    /* 2482 */ {I_VCMPORDSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7345, 188},
+    /* 2483 */ {I_VCMPEQ_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7354, 188},
+    /* 2484 */ {I_VCMPEQ_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7363, 188},
+    /* 2485 */ {I_VCMPNGE_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7372, 188},
+    /* 2486 */ {I_VCMPNGE_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7381, 188},
+    /* 2487 */ {I_VCMPNGESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7372, 188},
+    /* 2488 */ {I_VCMPNGESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7381, 188},
+    /* 2489 */ {I_VCMPNGT_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7390, 188},
+    /* 2490 */ {I_VCMPNGT_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7399, 188},
+    /* 2491 */ {I_VCMPNGTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7390, 188},
+    /* 2492 */ {I_VCMPNGTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7399, 188},
+    /* 2493 */ {I_VCMPFALSE_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7408, 188},
+    /* 2494 */ {I_VCMPFALSE_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7417, 188},
+    /* 2495 */ {I_VCMPFALSESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7408, 188},
+    /* 2496 */ {I_VCMPFALSESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7417, 188},
+    /* 2497 */ {I_VCMPNEQ_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7426, 188},
+    /* 2498 */ {I_VCMPNEQ_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7435, 188},
+    /* 2499 */ {I_VCMPGE_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7444, 188},
+    /* 2500 */ {I_VCMPGE_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7453, 188},
+    /* 2501 */ {I_VCMPGESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7444, 188},
+    /* 2502 */ {I_VCMPGESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7453, 188},
+    /* 2503 */ {I_VCMPGT_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7462, 188},
+    /* 2504 */ {I_VCMPGT_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7471, 188},
+    /* 2505 */ {I_VCMPGTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7462, 188},
+    /* 2506 */ {I_VCMPGTSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7471, 188},
+    /* 2507 */ {I_VCMPTRUE_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7480, 188},
+    /* 2508 */ {I_VCMPTRUE_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7489, 188},
+    /* 2509 */ {I_VCMPTRUESS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7480, 188},
+    /* 2510 */ {I_VCMPTRUESS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7489, 188},
+    /* 2511 */ {I_VCMPEQ_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7192, 188},
+    /* 2512 */ {I_VCMPEQ_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7201, 188},
+    /* 2513 */ {I_VCMPLT_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7498, 188},
+    /* 2514 */ {I_VCMPLT_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7507, 188},
+    /* 2515 */ {I_VCMPLE_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7516, 188},
+    /* 2516 */ {I_VCMPLE_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7525, 188},
+    /* 2517 */ {I_VCMPUNORD_SSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7534, 188},
+    /* 2518 */ {I_VCMPUNORD_SSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7543, 188},
+    /* 2519 */ {I_VCMPNEQ_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7552, 188},
+    /* 2520 */ {I_VCMPNEQ_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7561, 188},
+    /* 2521 */ {I_VCMPNLT_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7570, 188},
+    /* 2522 */ {I_VCMPNLT_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7579, 188},
+    /* 2523 */ {I_VCMPNLE_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7588, 188},
+    /* 2524 */ {I_VCMPNLE_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7597, 188},
+    /* 2525 */ {I_VCMPORD_SSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7606, 188},
+    /* 2526 */ {I_VCMPORD_SSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7615, 188},
+    /* 2527 */ {I_VCMPEQ_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7624, 188},
+    /* 2528 */ {I_VCMPEQ_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7633, 188},
+    /* 2529 */ {I_VCMPNGE_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7642, 188},
+    /* 2530 */ {I_VCMPNGE_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7651, 188},
+    /* 2531 */ {I_VCMPNGT_UQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7660, 188},
+    /* 2532 */ {I_VCMPNGT_UQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7669, 188},
+    /* 2533 */ {I_VCMPFALSE_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7678, 188},
+    /* 2534 */ {I_VCMPFALSE_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7687, 188},
+    /* 2535 */ {I_VCMPNEQ_OSSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7696, 188},
+    /* 2536 */ {I_VCMPNEQ_OSSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7705, 188},
+    /* 2537 */ {I_VCMPGE_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7714, 188},
+    /* 2538 */ {I_VCMPGE_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7723, 188},
+    /* 2539 */ {I_VCMPGT_OQSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7732, 188},
+    /* 2540 */ {I_VCMPGT_OQSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7741, 188},
+    /* 2541 */ {I_VCMPTRUE_USSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+7750, 188},
+    /* 2542 */ {I_VCMPTRUE_USSS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+7759, 188},
+    /* 2543 */ {I_VCMPSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13512, 188},
+    /* 2544 */ {I_VCMPSS, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13520, 188},
+    /* 2545 */ {I_VCOMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35272, 188},
+    /* 2546 */ {I_VCOMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35279, 188},
+    /* 2547 */ {I_VCVTDQ2PD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35286, 188},
+    /* 2548 */ {I_VCVTDQ2PD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35293, 188},
+    /* 2549 */ {I_VCVTDQ2PS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35300, 188},
+    /* 2550 */ {I_VCVTDQ2PS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35307, 188},
+    /* 2551 */ {I_VCVTPD2DQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35314, 188},
+    /* 2552 */ {I_VCVTPD2DQ, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35314, 192},
+    /* 2553 */ {I_VCVTPD2DQ, 2, {XMM_L16,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35321, 188},
+    /* 2554 */ {I_VCVTPD2DQ, 2, {XMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35321, 193},
+    /* 2555 */ {I_VCVTPD2PS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35328, 188},
+    /* 2556 */ {I_VCVTPD2PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35328, 192},
+    /* 2557 */ {I_VCVTPD2PS, 2, {XMM_L16,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35335, 188},
+    /* 2558 */ {I_VCVTPD2PS, 2, {XMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35335, 193},
+    /* 2559 */ {I_VCVTPS2DQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35342, 188},
+    /* 2560 */ {I_VCVTPS2DQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35349, 188},
+    /* 2561 */ {I_VCVTPS2PD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35356, 188},
+    /* 2562 */ {I_VCVTPS2PD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35363, 188},
+    /* 2563 */ {I_VCVTSD2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35370, 188},
+    /* 2564 */ {I_VCVTSD2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35377, 194},
+    /* 2565 */ {I_VCVTSD2SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35384, 188},
+    /* 2566 */ {I_VCVTSD2SS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35391, 188},
+    /* 2567 */ {I_VCVTSI2SD, 3, {XMM_L16,XMM_L16,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35398, 195},
+    /* 2568 */ {I_VCVTSI2SD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35405, 195},
+    /* 2569 */ {I_VCVTSI2SD, 3, {XMM_L16,XMM_L16,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35412, 196},
+    /* 2570 */ {I_VCVTSI2SD, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35419, 196},
+    /* 2571 */ {I_VCVTSI2SS, 3, {XMM_L16,XMM_L16,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35426, 195},
+    /* 2572 */ {I_VCVTSI2SS, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35433, 195},
+    /* 2573 */ {I_VCVTSI2SS, 3, {XMM_L16,XMM_L16,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35440, 196},
+    /* 2574 */ {I_VCVTSI2SS, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35447, 196},
+    /* 2575 */ {I_VCVTSS2SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35454, 188},
+    /* 2576 */ {I_VCVTSS2SD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35461, 188},
+    /* 2577 */ {I_VCVTSS2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35468, 188},
+    /* 2578 */ {I_VCVTSS2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35475, 194},
+    /* 2579 */ {I_VCVTTPD2DQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35482, 188},
+    /* 2580 */ {I_VCVTTPD2DQ, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35482, 192},
+    /* 2581 */ {I_VCVTTPD2DQ, 2, {XMM_L16,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35489, 188},
+    /* 2582 */ {I_VCVTTPD2DQ, 2, {XMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35489, 193},
+    /* 2583 */ {I_VCVTTPS2DQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35496, 188},
+    /* 2584 */ {I_VCVTTPS2DQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35503, 188},
+    /* 2585 */ {I_VCVTTSD2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35510, 188},
+    /* 2586 */ {I_VCVTTSD2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35517, 194},
+    /* 2587 */ {I_VCVTTSS2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35524, 188},
+    /* 2588 */ {I_VCVTTSS2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35531, 194},
+    /* 2589 */ {I_VDIVPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35538, 188},
+    /* 2590 */ {I_VDIVPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35545, 188},
+    /* 2591 */ {I_VDIVPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35552, 188},
+    /* 2592 */ {I_VDIVPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35559, 188},
+    /* 2593 */ {I_VDIVPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35566, 188},
+    /* 2594 */ {I_VDIVPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35573, 188},
+    /* 2595 */ {I_VDIVPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35580, 188},
+    /* 2596 */ {I_VDIVPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35587, 188},
+    /* 2597 */ {I_VDIVSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35594, 188},
+    /* 2598 */ {I_VDIVSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35601, 188},
+    /* 2599 */ {I_VDIVSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35608, 188},
+    /* 2600 */ {I_VDIVSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35615, 188},
+    /* 2601 */ {I_VDPPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13528, 188},
+    /* 2602 */ {I_VDPPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13536, 188},
+    /* 2603 */ {I_VDPPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13544, 188},
+    /* 2604 */ {I_VDPPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13552, 188},
+    /* 2605 */ {I_VDPPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13560, 188},
+    /* 2606 */ {I_VDPPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13568, 188},
+    /* 2607 */ {I_VEXTRACTF128, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13576, 188},
+    /* 2608 */ {I_VEXTRACTPS, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13584, 188},
+    /* 2609 */ {I_VHADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35622, 188},
+    /* 2610 */ {I_VHADDPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35629, 188},
+    /* 2611 */ {I_VHADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35636, 188},
+    /* 2612 */ {I_VHADDPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35643, 188},
+    /* 2613 */ {I_VHADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35650, 188},
+    /* 2614 */ {I_VHADDPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35657, 188},
+    /* 2615 */ {I_VHADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35664, 188},
+    /* 2616 */ {I_VHADDPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35671, 188},
+    /* 2617 */ {I_VHSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35678, 188},
+    /* 2618 */ {I_VHSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35685, 188},
+    /* 2619 */ {I_VHSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35692, 188},
+    /* 2620 */ {I_VHSUBPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35699, 188},
+    /* 2621 */ {I_VHSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35706, 188},
+    /* 2622 */ {I_VHSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35713, 188},
+    /* 2623 */ {I_VHSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35720, 188},
+    /* 2624 */ {I_VHSUBPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35727, 188},
+    /* 2625 */ {I_VINSERTF128, 4, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13592, 188},
+    /* 2626 */ {I_VINSERTF128, 3, {YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13600, 188},
+    /* 2627 */ {I_VINSERTPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13608, 188},
+    /* 2628 */ {I_VINSERTPS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13616, 188},
+    /* 2629 */ {I_VLDDQU, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35734, 188},
+    /* 2630 */ {I_VLDQQU, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35741, 188},
+    /* 2631 */ {I_VLDDQU, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35741, 188},
+    /* 2632 */ {I_VLDMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+35748, 188},
+    /* 2633 */ {I_VMASKMOVDQU, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35755, 188},
+    /* 2634 */ {I_VMASKMOVPS, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35762, 188},
+    /* 2635 */ {I_VMASKMOVPS, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35769, 188},
+    /* 2636 */ {I_VMASKMOVPS, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35776, 192},
+    /* 2637 */ {I_VMASKMOVPS, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35783, 193},
+    /* 2638 */ {I_VMASKMOVPD, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35790, 188},
+    /* 2639 */ {I_VMASKMOVPD, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35797, 188},
+    /* 2640 */ {I_VMASKMOVPD, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35804, 188},
+    /* 2641 */ {I_VMASKMOVPD, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+35811, 188},
+    /* 2642 */ {I_VMAXPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35818, 188},
+    /* 2643 */ {I_VMAXPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35825, 188},
+    /* 2644 */ {I_VMAXPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35832, 188},
+    /* 2645 */ {I_VMAXPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35839, 188},
+    /* 2646 */ {I_VMAXPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35846, 188},
+    /* 2647 */ {I_VMAXPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35853, 188},
+    /* 2648 */ {I_VMAXPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35860, 188},
+    /* 2649 */ {I_VMAXPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35867, 188},
+    /* 2650 */ {I_VMAXSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35874, 188},
+    /* 2651 */ {I_VMAXSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35881, 188},
+    /* 2652 */ {I_VMAXSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35888, 188},
+    /* 2653 */ {I_VMAXSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35895, 188},
+    /* 2654 */ {I_VMINPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35902, 188},
+    /* 2655 */ {I_VMINPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35909, 188},
+    /* 2656 */ {I_VMINPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35916, 188},
+    /* 2657 */ {I_VMINPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35923, 188},
+    /* 2658 */ {I_VMINPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+35930, 188},
+    /* 2659 */ {I_VMINPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35937, 188},
+    /* 2660 */ {I_VMINPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+35944, 188},
+    /* 2661 */ {I_VMINPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+35951, 188},
+    /* 2662 */ {I_VMINSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+35958, 188},
+    /* 2663 */ {I_VMINSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+35965, 188},
+    /* 2664 */ {I_VMINSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+35972, 188},
+    /* 2665 */ {I_VMINSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+35979, 188},
+    /* 2666 */ {I_VMOVAPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+35986, 188},
+    /* 2667 */ {I_VMOVAPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35993, 188},
+    /* 2668 */ {I_VMOVAPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36000, 188},
+    /* 2669 */ {I_VMOVAPD, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36007, 188},
+    /* 2670 */ {I_VMOVAPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36014, 188},
+    /* 2671 */ {I_VMOVAPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36021, 188},
+    /* 2672 */ {I_VMOVAPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36028, 188},
+    /* 2673 */ {I_VMOVAPS, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36035, 188},
+    /* 2674 */ {I_VMOVD, 2, {XMM_L16,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+36042, 188},
+    /* 2675 */ {I_VMOVD, 2, {RM_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36049, 188},
+    /* 2676 */ {I_VMOVQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36056, 197},
+    /* 2677 */ {I_VMOVQ, 2, {RM_XMM_L16|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36063, 197},
+    /* 2678 */ {I_VMOVQ, 2, {XMM_L16,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36070, 196},
+    /* 2679 */ {I_VMOVQ, 2, {RM_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36077, 196},
+    /* 2680 */ {I_VMOVDDUP, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36084, 188},
+    /* 2681 */ {I_VMOVDDUP, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36091, 188},
+    /* 2682 */ {I_VMOVDQA, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36098, 188},
+    /* 2683 */ {I_VMOVDQA, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36105, 188},
+    /* 2684 */ {I_VMOVQQA, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36112, 188},
+    /* 2685 */ {I_VMOVQQA, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36119, 188},
+    /* 2686 */ {I_VMOVDQA, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36112, 188},
+    /* 2687 */ {I_VMOVDQA, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36119, 188},
+    /* 2688 */ {I_VMOVDQU, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36126, 188},
+    /* 2689 */ {I_VMOVDQU, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36133, 188},
+    /* 2690 */ {I_VMOVQQU, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36140, 188},
+    /* 2691 */ {I_VMOVQQU, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36147, 188},
+    /* 2692 */ {I_VMOVDQU, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36140, 188},
+    /* 2693 */ {I_VMOVDQU, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36147, 188},
+    /* 2694 */ {I_VMOVHLPS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36154, 188},
+    /* 2695 */ {I_VMOVHLPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36161, 188},
+    /* 2696 */ {I_VMOVHPD, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36168, 188},
+    /* 2697 */ {I_VMOVHPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36175, 188},
+    /* 2698 */ {I_VMOVHPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36182, 188},
+    /* 2699 */ {I_VMOVHPS, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36189, 188},
+    /* 2700 */ {I_VMOVHPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36196, 188},
+    /* 2701 */ {I_VMOVHPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36203, 188},
+    /* 2702 */ {I_VMOVLHPS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36189, 188},
+    /* 2703 */ {I_VMOVLHPS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36196, 188},
+    /* 2704 */ {I_VMOVLPD, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36210, 188},
+    /* 2705 */ {I_VMOVLPD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36217, 188},
+    /* 2706 */ {I_VMOVLPD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36224, 188},
+    /* 2707 */ {I_VMOVLPS, 3, {XMM_L16,XMM_L16,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36154, 188},
+    /* 2708 */ {I_VMOVLPS, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36161, 188},
+    /* 2709 */ {I_VMOVLPS, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36231, 188},
+    /* 2710 */ {I_VMOVMSKPD, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36238, 194},
+    /* 2711 */ {I_VMOVMSKPD, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36238, 188},
+    /* 2712 */ {I_VMOVMSKPD, 2, {REG_GPR|BITS64,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36245, 194},
+    /* 2713 */ {I_VMOVMSKPD, 2, {REG_GPR|BITS32,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36245, 188},
+    /* 2714 */ {I_VMOVMSKPS, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36252, 194},
+    /* 2715 */ {I_VMOVMSKPS, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36252, 188},
+    /* 2716 */ {I_VMOVMSKPS, 2, {REG_GPR|BITS64,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36259, 194},
+    /* 2717 */ {I_VMOVMSKPS, 2, {REG_GPR|BITS32,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36259, 188},
+    /* 2718 */ {I_VMOVNTDQ, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36266, 188},
+    /* 2719 */ {I_VMOVNTQQ, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36273, 188},
+    /* 2720 */ {I_VMOVNTDQ, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36273, 188},
+    /* 2721 */ {I_VMOVNTDQA, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36280, 188},
+    /* 2722 */ {I_VMOVNTPD, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36287, 188},
+    /* 2723 */ {I_VMOVNTPD, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36294, 188},
+    /* 2724 */ {I_VMOVNTPS, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36301, 188},
+    /* 2725 */ {I_VMOVNTPS, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36308, 188},
+    /* 2726 */ {I_VMOVSD, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36315, 188},
+    /* 2727 */ {I_VMOVSD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36322, 188},
+    /* 2728 */ {I_VMOVSD, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36329, 188},
+    /* 2729 */ {I_VMOVSD, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36336, 188},
+    /* 2730 */ {I_VMOVSD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36343, 188},
+    /* 2731 */ {I_VMOVSD, 2, {MEMORY|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36350, 188},
+    /* 2732 */ {I_VMOVSHDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36357, 188},
+    /* 2733 */ {I_VMOVSHDUP, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36364, 188},
+    /* 2734 */ {I_VMOVSLDUP, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36371, 188},
+    /* 2735 */ {I_VMOVSLDUP, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36378, 188},
+    /* 2736 */ {I_VMOVSS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36385, 188},
+    /* 2737 */ {I_VMOVSS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36392, 188},
+    /* 2738 */ {I_VMOVSS, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+36399, 188},
+    /* 2739 */ {I_VMOVSS, 3, {XMM_L16,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+36406, 188},
+    /* 2740 */ {I_VMOVSS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36413, 188},
+    /* 2741 */ {I_VMOVSS, 2, {MEMORY|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36420, 188},
+    /* 2742 */ {I_VMOVUPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36427, 188},
+    /* 2743 */ {I_VMOVUPD, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36434, 188},
+    /* 2744 */ {I_VMOVUPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36441, 188},
+    /* 2745 */ {I_VMOVUPD, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36448, 188},
+    /* 2746 */ {I_VMOVUPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36455, 188},
+    /* 2747 */ {I_VMOVUPS, 2, {RM_XMM_L16|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36462, 188},
+    /* 2748 */ {I_VMOVUPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36469, 188},
+    /* 2749 */ {I_VMOVUPS, 2, {RM_YMM_L16|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+36476, 188},
+    /* 2750 */ {I_VMPSADBW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13624, 188},
+    /* 2751 */ {I_VMPSADBW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13632, 188},
+    /* 2752 */ {I_VMULPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36483, 188},
+    /* 2753 */ {I_VMULPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36490, 188},
+    /* 2754 */ {I_VMULPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36497, 188},
+    /* 2755 */ {I_VMULPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36504, 188},
+    /* 2756 */ {I_VMULPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36511, 188},
+    /* 2757 */ {I_VMULPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36518, 188},
+    /* 2758 */ {I_VMULPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36525, 188},
+    /* 2759 */ {I_VMULPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36532, 188},
+    /* 2760 */ {I_VMULSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+36539, 188},
+    /* 2761 */ {I_VMULSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+36546, 188},
+    /* 2762 */ {I_VMULSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+36553, 188},
+    /* 2763 */ {I_VMULSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+36560, 188},
+    /* 2764 */ {I_VORPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36567, 188},
+    /* 2765 */ {I_VORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36574, 188},
+    /* 2766 */ {I_VORPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36581, 188},
+    /* 2767 */ {I_VORPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36588, 188},
+    /* 2768 */ {I_VORPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36595, 188},
+    /* 2769 */ {I_VORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36602, 188},
+    /* 2770 */ {I_VORPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36609, 188},
+    /* 2771 */ {I_VORPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+36616, 188},
+    /* 2772 */ {I_VPABSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36623, 188},
+    /* 2773 */ {I_VPABSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36630, 188},
+    /* 2774 */ {I_VPABSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36637, 188},
+    /* 2775 */ {I_VPACKSSWB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36644, 188},
+    /* 2776 */ {I_VPACKSSWB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36651, 188},
+    /* 2777 */ {I_VPACKSSDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36658, 188},
+    /* 2778 */ {I_VPACKSSDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36665, 188},
+    /* 2779 */ {I_VPACKUSWB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36672, 188},
+    /* 2780 */ {I_VPACKUSWB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36679, 188},
+    /* 2781 */ {I_VPACKUSDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36686, 188},
+    /* 2782 */ {I_VPACKUSDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36693, 188},
+    /* 2783 */ {I_VPADDB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36700, 188},
+    /* 2784 */ {I_VPADDB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36707, 188},
+    /* 2785 */ {I_VPADDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36714, 188},
+    /* 2786 */ {I_VPADDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36721, 188},
+    /* 2787 */ {I_VPADDD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36728, 188},
+    /* 2788 */ {I_VPADDD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36735, 188},
+    /* 2789 */ {I_VPADDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36742, 188},
+    /* 2790 */ {I_VPADDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36749, 188},
+    /* 2791 */ {I_VPADDSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36756, 188},
+    /* 2792 */ {I_VPADDSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36763, 188},
+    /* 2793 */ {I_VPADDSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36770, 188},
+    /* 2794 */ {I_VPADDSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36777, 188},
+    /* 2795 */ {I_VPADDUSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36784, 188},
+    /* 2796 */ {I_VPADDUSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36791, 188},
+    /* 2797 */ {I_VPADDUSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36798, 188},
+    /* 2798 */ {I_VPADDUSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36805, 188},
+    /* 2799 */ {I_VPALIGNR, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13640, 188},
+    /* 2800 */ {I_VPALIGNR, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13648, 188},
+    /* 2801 */ {I_VPAND, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36812, 188},
+    /* 2802 */ {I_VPAND, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36819, 188},
+    /* 2803 */ {I_VPANDN, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36826, 188},
+    /* 2804 */ {I_VPANDN, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36833, 188},
+    /* 2805 */ {I_VPAVGB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36840, 188},
+    /* 2806 */ {I_VPAVGB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36847, 188},
+    /* 2807 */ {I_VPAVGW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36854, 188},
+    /* 2808 */ {I_VPAVGW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36861, 188},
+    /* 2809 */ {I_VPBLENDVB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+13656, 188},
+    /* 2810 */ {I_VPBLENDVB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+13664, 188},
+    /* 2811 */ {I_VPBLENDW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13672, 188},
+    /* 2812 */ {I_VPBLENDW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13680, 188},
+    /* 2813 */ {I_VPCMPESTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13688, 188},
+    /* 2814 */ {I_VPCMPESTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13696, 188},
+    /* 2815 */ {I_VPCMPISTRI, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13704, 188},
+    /* 2816 */ {I_VPCMPISTRM, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13712, 188},
+    /* 2817 */ {I_VPCMPEQB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36868, 188},
+    /* 2818 */ {I_VPCMPEQB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36875, 188},
+    /* 2819 */ {I_VPCMPEQW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36882, 188},
+    /* 2820 */ {I_VPCMPEQW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36889, 188},
+    /* 2821 */ {I_VPCMPEQD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36896, 188},
+    /* 2822 */ {I_VPCMPEQD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36903, 188},
+    /* 2823 */ {I_VPCMPEQQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36910, 188},
+    /* 2824 */ {I_VPCMPEQQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36917, 188},
+    /* 2825 */ {I_VPCMPGTB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36924, 188},
+    /* 2826 */ {I_VPCMPGTB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36931, 188},
+    /* 2827 */ {I_VPCMPGTW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36938, 188},
+    /* 2828 */ {I_VPCMPGTW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36945, 188},
+    /* 2829 */ {I_VPCMPGTD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36952, 188},
+    /* 2830 */ {I_VPCMPGTD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36959, 188},
+    /* 2831 */ {I_VPCMPGTQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36966, 188},
+    /* 2832 */ {I_VPCMPGTQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36973, 188},
+    /* 2833 */ {I_VPERMILPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+36980, 188},
+    /* 2834 */ {I_VPERMILPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+36987, 188},
+    /* 2835 */ {I_VPERMILPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+36994, 188},
+    /* 2836 */ {I_VPERMILPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37001, 188},
+    /* 2837 */ {I_VPERMILPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13720, 188},
+    /* 2838 */ {I_VPERMILPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13728, 188},
+    /* 2839 */ {I_VPERMILPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37008, 188},
+    /* 2840 */ {I_VPERMILPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37015, 188},
+    /* 2841 */ {I_VPERMILPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+37022, 188},
+    /* 2842 */ {I_VPERMILPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37029, 188},
+    /* 2843 */ {I_VPERMILPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13736, 188},
+    /* 2844 */ {I_VPERMILPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13744, 188},
+    /* 2845 */ {I_VPERM2F128, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13752, 188},
+    /* 2846 */ {I_VPERM2F128, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13760, 188},
+    /* 2847 */ {I_VPEXTRB, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13768, 194},
+    /* 2848 */ {I_VPEXTRB, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13768, 188},
+    /* 2849 */ {I_VPEXTRB, 3, {MEMORY|BITS8,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13768, 188},
+    /* 2850 */ {I_VPEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13776, 194},
+    /* 2851 */ {I_VPEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13776, 188},
+    /* 2852 */ {I_VPEXTRW, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13784, 194},
+    /* 2853 */ {I_VPEXTRW, 3, {REG_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13784, 188},
+    /* 2854 */ {I_VPEXTRW, 3, {MEMORY|BITS16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13784, 188},
+    /* 2855 */ {I_VPEXTRD, 3, {REG_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13792, 194},
+    /* 2856 */ {I_VPEXTRD, 3, {RM_GPR|BITS32,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13792, 188},
+    /* 2857 */ {I_VPEXTRQ, 3, {RM_GPR|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13800, 194},
+    /* 2858 */ {I_VPHADDW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37036, 188},
+    /* 2859 */ {I_VPHADDW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37043, 188},
+    /* 2860 */ {I_VPHADDD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37050, 188},
+    /* 2861 */ {I_VPHADDD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37057, 188},
+    /* 2862 */ {I_VPHADDSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37064, 188},
+    /* 2863 */ {I_VPHADDSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37071, 188},
+    /* 2864 */ {I_VPHMINPOSUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37078, 188},
+    /* 2865 */ {I_VPHSUBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37085, 188},
+    /* 2866 */ {I_VPHSUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37092, 188},
+    /* 2867 */ {I_VPHSUBD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37099, 188},
+    /* 2868 */ {I_VPHSUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37106, 188},
+    /* 2869 */ {I_VPHSUBSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37113, 188},
+    /* 2870 */ {I_VPHSUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37120, 188},
+    /* 2871 */ {I_VPINSRB, 4, {XMM_L16,XMM_L16,MEMORY|BITS8,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13808, 188},
+    /* 2872 */ {I_VPINSRB, 3, {XMM_L16,MEMORY|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13816, 188},
+    /* 2873 */ {I_VPINSRB, 4, {XMM_L16,XMM_L16,RM_GPR|BITS8,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13808, 188},
+    /* 2874 */ {I_VPINSRB, 3, {XMM_L16,RM_GPR|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13816, 188},
+    /* 2875 */ {I_VPINSRB, 4, {XMM_L16,XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13808, 188},
+    /* 2876 */ {I_VPINSRB, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13816, 188},
+    /* 2877 */ {I_VPINSRW, 4, {XMM_L16,XMM_L16,MEMORY|BITS16,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13824, 188},
+    /* 2878 */ {I_VPINSRW, 3, {XMM_L16,MEMORY|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13832, 188},
+    /* 2879 */ {I_VPINSRW, 4, {XMM_L16,XMM_L16,RM_GPR|BITS16,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13824, 188},
+    /* 2880 */ {I_VPINSRW, 3, {XMM_L16,RM_GPR|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13832, 188},
+    /* 2881 */ {I_VPINSRW, 4, {XMM_L16,XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13824, 188},
+    /* 2882 */ {I_VPINSRW, 3, {XMM_L16,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13832, 188},
+    /* 2883 */ {I_VPINSRD, 4, {XMM_L16,XMM_L16,MEMORY|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13840, 188},
+    /* 2884 */ {I_VPINSRD, 3, {XMM_L16,MEMORY|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13848, 188},
+    /* 2885 */ {I_VPINSRD, 4, {XMM_L16,XMM_L16,RM_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13840, 188},
+    /* 2886 */ {I_VPINSRD, 3, {XMM_L16,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13848, 188},
+    /* 2887 */ {I_VPINSRQ, 4, {XMM_L16,XMM_L16,MEMORY|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13856, 194},
+    /* 2888 */ {I_VPINSRQ, 3, {XMM_L16,MEMORY|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13864, 194},
+    /* 2889 */ {I_VPINSRQ, 4, {XMM_L16,XMM_L16,RM_GPR|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+13856, 194},
+    /* 2890 */ {I_VPINSRQ, 3, {XMM_L16,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13864, 194},
+    /* 2891 */ {I_VPMADDWD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37127, 188},
+    /* 2892 */ {I_VPMADDWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37134, 188},
+    /* 2893 */ {I_VPMADDUBSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37141, 188},
+    /* 2894 */ {I_VPMADDUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37148, 188},
+    /* 2895 */ {I_VPMAXSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37155, 188},
+    /* 2896 */ {I_VPMAXSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37162, 188},
+    /* 2897 */ {I_VPMAXSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37169, 188},
+    /* 2898 */ {I_VPMAXSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37176, 188},
+    /* 2899 */ {I_VPMAXSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37183, 188},
+    /* 2900 */ {I_VPMAXSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37190, 188},
+    /* 2901 */ {I_VPMAXUB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37197, 188},
+    /* 2902 */ {I_VPMAXUB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37204, 188},
+    /* 2903 */ {I_VPMAXUW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37211, 188},
+    /* 2904 */ {I_VPMAXUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37218, 188},
+    /* 2905 */ {I_VPMAXUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37225, 188},
+    /* 2906 */ {I_VPMAXUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37232, 188},
+    /* 2907 */ {I_VPMINSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37239, 188},
+    /* 2908 */ {I_VPMINSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37246, 188},
+    /* 2909 */ {I_VPMINSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37253, 188},
+    /* 2910 */ {I_VPMINSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37260, 188},
+    /* 2911 */ {I_VPMINSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37267, 188},
+    /* 2912 */ {I_VPMINSD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37274, 188},
+    /* 2913 */ {I_VPMINUB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37281, 188},
+    /* 2914 */ {I_VPMINUB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37288, 188},
+    /* 2915 */ {I_VPMINUW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37295, 188},
+    /* 2916 */ {I_VPMINUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37302, 188},
+    /* 2917 */ {I_VPMINUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37309, 188},
+    /* 2918 */ {I_VPMINUD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37316, 188},
+    /* 2919 */ {I_VPMOVMSKB, 2, {REG_GPR|BITS64,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37323, 194},
+    /* 2920 */ {I_VPMOVMSKB, 2, {REG_GPR|BITS32,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37323, 188},
+    /* 2921 */ {I_VPMOVSXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37330, 188},
+    /* 2922 */ {I_VPMOVSXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37337, 188},
+    /* 2923 */ {I_VPMOVSXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37344, 188},
+    /* 2924 */ {I_VPMOVSXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37351, 188},
+    /* 2925 */ {I_VPMOVSXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37358, 188},
+    /* 2926 */ {I_VPMOVSXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37365, 188},
+    /* 2927 */ {I_VPMOVZXBW, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37372, 188},
+    /* 2928 */ {I_VPMOVZXBD, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37379, 188},
+    /* 2929 */ {I_VPMOVZXBQ, 2, {XMM_L16,RM_XMM_L16|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+37386, 188},
+    /* 2930 */ {I_VPMOVZXWD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37393, 188},
+    /* 2931 */ {I_VPMOVZXWQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37400, 188},
+    /* 2932 */ {I_VPMOVZXDQ, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+37407, 188},
+    /* 2933 */ {I_VPMULHUW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37414, 188},
+    /* 2934 */ {I_VPMULHUW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37421, 188},
+    /* 2935 */ {I_VPMULHRSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37428, 188},
+    /* 2936 */ {I_VPMULHRSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37435, 188},
+    /* 2937 */ {I_VPMULHW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37442, 188},
+    /* 2938 */ {I_VPMULHW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37449, 188},
+    /* 2939 */ {I_VPMULLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37456, 188},
+    /* 2940 */ {I_VPMULLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37463, 188},
+    /* 2941 */ {I_VPMULLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37470, 188},
+    /* 2942 */ {I_VPMULLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37477, 188},
+    /* 2943 */ {I_VPMULUDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37484, 188},
+    /* 2944 */ {I_VPMULUDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37491, 188},
+    /* 2945 */ {I_VPMULDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37498, 188},
+    /* 2946 */ {I_VPMULDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37505, 188},
+    /* 2947 */ {I_VPOR, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37512, 188},
+    /* 2948 */ {I_VPOR, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37519, 188},
+    /* 2949 */ {I_VPSADBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37526, 188},
+    /* 2950 */ {I_VPSADBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37533, 188},
+    /* 2951 */ {I_VPSHUFB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37540, 188},
+    /* 2952 */ {I_VPSHUFB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37547, 188},
+    /* 2953 */ {I_VPSHUFD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13872, 188},
+    /* 2954 */ {I_VPSHUFHW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13880, 188},
+    /* 2955 */ {I_VPSHUFLW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13888, 188},
+    /* 2956 */ {I_VPSIGNB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37554, 188},
+    /* 2957 */ {I_VPSIGNB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37561, 188},
+    /* 2958 */ {I_VPSIGNW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37568, 188},
+    /* 2959 */ {I_VPSIGNW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37575, 188},
+    /* 2960 */ {I_VPSIGND, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37582, 188},
+    /* 2961 */ {I_VPSIGND, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37589, 188},
+    /* 2962 */ {I_VPSLLDQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13896, 188},
+    /* 2963 */ {I_VPSLLDQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13904, 188},
+    /* 2964 */ {I_VPSRLDQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13912, 188},
+    /* 2965 */ {I_VPSRLDQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13920, 188},
+    /* 2966 */ {I_VPSLLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37596, 188},
+    /* 2967 */ {I_VPSLLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37603, 188},
+    /* 2968 */ {I_VPSLLW, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13928, 188},
+    /* 2969 */ {I_VPSLLW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13936, 188},
+    /* 2970 */ {I_VPSLLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37610, 188},
+    /* 2971 */ {I_VPSLLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37617, 188},
+    /* 2972 */ {I_VPSLLD, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13944, 188},
+    /* 2973 */ {I_VPSLLD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13952, 188},
+    /* 2974 */ {I_VPSLLQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37624, 188},
+    /* 2975 */ {I_VPSLLQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37631, 188},
+    /* 2976 */ {I_VPSLLQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13960, 188},
+    /* 2977 */ {I_VPSLLQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13968, 188},
+    /* 2978 */ {I_VPSRAW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37638, 188},
+    /* 2979 */ {I_VPSRAW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37645, 188},
+    /* 2980 */ {I_VPSRAW, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13976, 188},
+    /* 2981 */ {I_VPSRAW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+13984, 188},
+    /* 2982 */ {I_VPSRAD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37652, 188},
+    /* 2983 */ {I_VPSRAD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37659, 188},
+    /* 2984 */ {I_VPSRAD, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+13992, 188},
+    /* 2985 */ {I_VPSRAD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14000, 188},
+    /* 2986 */ {I_VPSRLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37666, 188},
+    /* 2987 */ {I_VPSRLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37673, 188},
+    /* 2988 */ {I_VPSRLW, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14008, 188},
+    /* 2989 */ {I_VPSRLW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14016, 188},
+    /* 2990 */ {I_VPSRLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37680, 188},
+    /* 2991 */ {I_VPSRLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37687, 188},
+    /* 2992 */ {I_VPSRLD, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14024, 188},
+    /* 2993 */ {I_VPSRLD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14032, 188},
+    /* 2994 */ {I_VPSRLQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37694, 188},
+    /* 2995 */ {I_VPSRLQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37701, 188},
+    /* 2996 */ {I_VPSRLQ, 3, {XMM_L16,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14040, 188},
+    /* 2997 */ {I_VPSRLQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+14048, 188},
+    /* 2998 */ {I_VPTEST, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37708, 188},
+    /* 2999 */ {I_VPTEST, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37715, 188},
+    /* 3000 */ {I_VPSUBB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37722, 188},
+    /* 3001 */ {I_VPSUBB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37729, 188},
+    /* 3002 */ {I_VPSUBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37736, 188},
+    /* 3003 */ {I_VPSUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37743, 188},
+    /* 3004 */ {I_VPSUBD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37750, 188},
+    /* 3005 */ {I_VPSUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37757, 188},
+    /* 3006 */ {I_VPSUBQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37764, 188},
+    /* 3007 */ {I_VPSUBQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37771, 188},
+    /* 3008 */ {I_VPSUBSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37778, 188},
+    /* 3009 */ {I_VPSUBSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37785, 188},
+    /* 3010 */ {I_VPSUBSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37792, 188},
+    /* 3011 */ {I_VPSUBSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37799, 188},
+    /* 3012 */ {I_VPSUBUSB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37806, 188},
+    /* 3013 */ {I_VPSUBUSB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37813, 188},
+    /* 3014 */ {I_VPSUBUSW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37820, 188},
+    /* 3015 */ {I_VPSUBUSW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37827, 188},
+    /* 3016 */ {I_VPUNPCKHBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37834, 188},
+    /* 3017 */ {I_VPUNPCKHBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37841, 188},
+    /* 3018 */ {I_VPUNPCKHWD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37848, 188},
+    /* 3019 */ {I_VPUNPCKHWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37855, 188},
+    /* 3020 */ {I_VPUNPCKHDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37862, 188},
+    /* 3021 */ {I_VPUNPCKHDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37869, 188},
+    /* 3022 */ {I_VPUNPCKHQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37876, 188},
+    /* 3023 */ {I_VPUNPCKHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37883, 188},
+    /* 3024 */ {I_VPUNPCKLBW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37890, 188},
+    /* 3025 */ {I_VPUNPCKLBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37897, 188},
+    /* 3026 */ {I_VPUNPCKLWD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37904, 188},
+    /* 3027 */ {I_VPUNPCKLWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37911, 188},
+    /* 3028 */ {I_VPUNPCKLDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37918, 188},
+    /* 3029 */ {I_VPUNPCKLDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37925, 188},
+    /* 3030 */ {I_VPUNPCKLQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37932, 188},
+    /* 3031 */ {I_VPUNPCKLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37939, 188},
+    /* 3032 */ {I_VPXOR, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+37946, 188},
+    /* 3033 */ {I_VPXOR, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37953, 188},
+    /* 3034 */ {I_VRCPPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37960, 188},
+    /* 3035 */ {I_VRCPPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37967, 188},
+    /* 3036 */ {I_VRCPSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+37974, 188},
+    /* 3037 */ {I_VRCPSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+37981, 188},
+    /* 3038 */ {I_VRSQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+37988, 188},
+    /* 3039 */ {I_VRSQRTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+37995, 188},
+    /* 3040 */ {I_VRSQRTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38002, 188},
+    /* 3041 */ {I_VRSQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38009, 188},
+    /* 3042 */ {I_VROUNDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14056, 188},
+    /* 3043 */ {I_VROUNDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14064, 188},
+    /* 3044 */ {I_VROUNDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14072, 188},
+    /* 3045 */ {I_VROUNDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14080, 188},
+    /* 3046 */ {I_VROUNDSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14088, 188},
+    /* 3047 */ {I_VROUNDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14096, 188},
+    /* 3048 */ {I_VROUNDSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14104, 188},
+    /* 3049 */ {I_VROUNDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14112, 188},
+    /* 3050 */ {I_VSHUFPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14120, 188},
+    /* 3051 */ {I_VSHUFPD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14128, 188},
+    /* 3052 */ {I_VSHUFPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14136, 188},
+    /* 3053 */ {I_VSHUFPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14144, 188},
+    /* 3054 */ {I_VSHUFPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14152, 188},
+    /* 3055 */ {I_VSHUFPS, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14160, 188},
+    /* 3056 */ {I_VSHUFPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14168, 188},
+    /* 3057 */ {I_VSHUFPS, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14176, 188},
+    /* 3058 */ {I_VSQRTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38016, 188},
+    /* 3059 */ {I_VSQRTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38023, 188},
+    /* 3060 */ {I_VSQRTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38030, 188},
+    /* 3061 */ {I_VSQRTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38037, 188},
+    /* 3062 */ {I_VSQRTSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38044, 188},
+    /* 3063 */ {I_VSQRTSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+38051, 188},
+    /* 3064 */ {I_VSQRTSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38058, 188},
+    /* 3065 */ {I_VSQRTSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38065, 188},
+    /* 3066 */ {I_VSTMXCSR, 1, {MEMORY|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+38072, 188},
+    /* 3067 */ {I_VSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38079, 188},
+    /* 3068 */ {I_VSUBPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38086, 188},
+    /* 3069 */ {I_VSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38093, 188},
+    /* 3070 */ {I_VSUBPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38100, 188},
+    /* 3071 */ {I_VSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38107, 188},
+    /* 3072 */ {I_VSUBPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38114, 188},
+    /* 3073 */ {I_VSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38121, 188},
+    /* 3074 */ {I_VSUBPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38128, 188},
+    /* 3075 */ {I_VSUBSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38135, 188},
+    /* 3076 */ {I_VSUBSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+38142, 188},
+    /* 3077 */ {I_VSUBSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38149, 188},
+    /* 3078 */ {I_VSUBSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38156, 188},
+    /* 3079 */ {I_VTESTPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38163, 188},
+    /* 3080 */ {I_VTESTPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38170, 188},
+    /* 3081 */ {I_VTESTPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38177, 188},
+    /* 3082 */ {I_VTESTPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38184, 188},
+    /* 3083 */ {I_VUCOMISD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+38191, 188},
+    /* 3084 */ {I_VUCOMISS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+38198, 188},
+    /* 3085 */ {I_VUNPCKHPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38205, 188},
+    /* 3086 */ {I_VUNPCKHPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38212, 188},
+    /* 3087 */ {I_VUNPCKHPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38219, 188},
+    /* 3088 */ {I_VUNPCKHPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38226, 188},
+    /* 3089 */ {I_VUNPCKHPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38233, 188},
+    /* 3090 */ {I_VUNPCKHPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38240, 188},
+    /* 3091 */ {I_VUNPCKHPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38247, 188},
+    /* 3092 */ {I_VUNPCKHPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38254, 188},
+    /* 3093 */ {I_VUNPCKLPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38261, 188},
+    /* 3094 */ {I_VUNPCKLPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38268, 188},
+    /* 3095 */ {I_VUNPCKLPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38275, 188},
+    /* 3096 */ {I_VUNPCKLPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38282, 188},
+    /* 3097 */ {I_VUNPCKLPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38289, 188},
+    /* 3098 */ {I_VUNPCKLPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38296, 188},
+    /* 3099 */ {I_VUNPCKLPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38303, 188},
+    /* 3100 */ {I_VUNPCKLPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38310, 188},
+    /* 3101 */ {I_VXORPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38317, 188},
+    /* 3102 */ {I_VXORPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38324, 188},
+    /* 3103 */ {I_VXORPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38331, 188},
+    /* 3104 */ {I_VXORPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38338, 188},
+    /* 3105 */ {I_VXORPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38345, 188},
+    /* 3106 */ {I_VXORPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+38352, 188},
+    /* 3107 */ {I_VXORPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38359, 188},
+    /* 3108 */ {I_VXORPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+38366, 188},
+    /* 3109 */ {I_VZEROALL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45759, 188},
+    /* 3110 */ {I_VZEROUPPER, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45765, 188},
+    /* 3111 */ {I_PCLMULLQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7768, 187},
+    /* 3112 */ {I_PCLMULHQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7777, 187},
+    /* 3113 */ {I_PCLMULLQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7786, 187},
+    /* 3114 */ {I_PCLMULHQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7795, 187},
+    /* 3115 */ {I_PCLMULQDQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14184, 187},
+    /* 3116 */ {I_VPCLMULLQLQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7804, 188},
+    /* 3117 */ {I_VPCLMULLQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7813, 188},
+    /* 3118 */ {I_VPCLMULHQLQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7822, 188},
+    /* 3119 */ {I_VPCLMULHQLQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7831, 188},
+    /* 3120 */ {I_VPCLMULLQHQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7840, 188},
+    /* 3121 */ {I_VPCLMULLQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7849, 188},
+    /* 3122 */ {I_VPCLMULHQHQDQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+7858, 188},
+    /* 3123 */ {I_VPCLMULHQHQDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+7867, 188},
+    /* 3124 */ {I_VPCLMULQDQ, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14192, 188},
+    /* 3125 */ {I_VPCLMULQDQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14200, 188},
+    /* 3126 */ {I_VPCLMULLQLQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7876, 198},
+    /* 3127 */ {I_VPCLMULLQLQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7885, 198},
+    /* 3128 */ {I_VPCLMULHQLQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7894, 198},
+    /* 3129 */ {I_VPCLMULHQLQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7903, 198},
+    /* 3130 */ {I_VPCLMULLQHQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7912, 198},
+    /* 3131 */ {I_VPCLMULLQHQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7921, 198},
+    /* 3132 */ {I_VPCLMULHQHQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+7930, 198},
+    /* 3133 */ {I_VPCLMULHQHQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+7939, 198},
+    /* 3134 */ {I_VPCLMULQDQ, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+14208, 198},
+    /* 3135 */ {I_VPCLMULQDQ, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14216, 198},
+    /* 3136 */ {I_VPCLMULLQLQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+0, 199},
+    /* 3137 */ {I_VPCLMULLQLQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+10, 199},
+    /* 3138 */ {I_VPCLMULHQLQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+20, 199},
+    /* 3139 */ {I_VPCLMULHQLQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+30, 199},
+    /* 3140 */ {I_VPCLMULLQHQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40, 199},
+    /* 3141 */ {I_VPCLMULLQHQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+50, 199},
+    /* 3142 */ {I_VPCLMULHQHQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+60, 199},
+    /* 3143 */ {I_VPCLMULHQHQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+70, 199},
+    /* 3144 */ {I_VPCLMULQDQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+7948, 199},
+    /* 3145 */ {I_VPCLMULQDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+7957, 199},
+    /* 3146 */ {I_VPCLMULLQLQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+80, 199},
+    /* 3147 */ {I_VPCLMULLQLQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+90, 199},
+    /* 3148 */ {I_VPCLMULHQLQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+100, 199},
+    /* 3149 */ {I_VPCLMULHQLQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+110, 199},
+    /* 3150 */ {I_VPCLMULLQHQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+120, 199},
+    /* 3151 */ {I_VPCLMULLQHQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+130, 199},
+    /* 3152 */ {I_VPCLMULHQHQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+140, 199},
+    /* 3153 */ {I_VPCLMULHQHQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+150, 199},
+    /* 3154 */ {I_VPCLMULQDQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+7966, 199},
+    /* 3155 */ {I_VPCLMULQDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+7975, 199},
+    /* 3156 */ {I_VPCLMULLQLQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+160, 200},
+    /* 3157 */ {I_VPCLMULLQLQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+170, 200},
+    /* 3158 */ {I_VPCLMULHQLQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+180, 200},
+    /* 3159 */ {I_VPCLMULHQLQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+190, 200},
+    /* 3160 */ {I_VPCLMULLQHQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+200, 200},
+    /* 3161 */ {I_VPCLMULLQHQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+210, 200},
+    /* 3162 */ {I_VPCLMULHQHQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+220, 200},
+    /* 3163 */ {I_VPCLMULHQHQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+230, 200},
+    /* 3164 */ {I_VPCLMULQDQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+7984, 200},
+    /* 3165 */ {I_VPCLMULQDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+7993, 200},
+    /* 3166 */ {I_VFMADD132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38373, 201},
+    /* 3167 */ {I_VFMADD132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38380, 201},
+    /* 3168 */ {I_VFMADD132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38387, 201},
+    /* 3169 */ {I_VFMADD132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38394, 201},
+    /* 3170 */ {I_VFMADD312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38373, 201},
+    /* 3171 */ {I_VFMADD312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38380, 201},
+    /* 3172 */ {I_VFMADD312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38387, 201},
+    /* 3173 */ {I_VFMADD312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38394, 201},
+    /* 3174 */ {I_VFMADD213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38401, 201},
+    /* 3175 */ {I_VFMADD213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38408, 201},
+    /* 3176 */ {I_VFMADD213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38415, 201},
+    /* 3177 */ {I_VFMADD213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38422, 201},
+    /* 3178 */ {I_VFMADD123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38401, 201},
+    /* 3179 */ {I_VFMADD123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38408, 201},
+    /* 3180 */ {I_VFMADD123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38415, 201},
+    /* 3181 */ {I_VFMADD123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38422, 201},
+    /* 3182 */ {I_VFMADD231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38429, 201},
+    /* 3183 */ {I_VFMADD231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38436, 201},
+    /* 3184 */ {I_VFMADD231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38443, 201},
+    /* 3185 */ {I_VFMADD231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38450, 201},
+    /* 3186 */ {I_VFMADD321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38429, 201},
+    /* 3187 */ {I_VFMADD321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38436, 201},
+    /* 3188 */ {I_VFMADD321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38443, 201},
+    /* 3189 */ {I_VFMADD321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38450, 201},
+    /* 3190 */ {I_VFMADDSUB132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38457, 201},
+    /* 3191 */ {I_VFMADDSUB132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38464, 201},
+    /* 3192 */ {I_VFMADDSUB132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38471, 201},
+    /* 3193 */ {I_VFMADDSUB132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38478, 201},
+    /* 3194 */ {I_VFMADDSUB312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38457, 201},
+    /* 3195 */ {I_VFMADDSUB312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38464, 201},
+    /* 3196 */ {I_VFMADDSUB312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38471, 201},
+    /* 3197 */ {I_VFMADDSUB312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38478, 201},
+    /* 3198 */ {I_VFMADDSUB213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38485, 201},
+    /* 3199 */ {I_VFMADDSUB213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38492, 201},
+    /* 3200 */ {I_VFMADDSUB213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38499, 201},
+    /* 3201 */ {I_VFMADDSUB213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38506, 201},
+    /* 3202 */ {I_VFMADDSUB123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38485, 201},
+    /* 3203 */ {I_VFMADDSUB123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38492, 201},
+    /* 3204 */ {I_VFMADDSUB123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38499, 201},
+    /* 3205 */ {I_VFMADDSUB123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38506, 201},
+    /* 3206 */ {I_VFMADDSUB231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38513, 201},
+    /* 3207 */ {I_VFMADDSUB231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38520, 201},
+    /* 3208 */ {I_VFMADDSUB231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38527, 201},
+    /* 3209 */ {I_VFMADDSUB231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38534, 201},
+    /* 3210 */ {I_VFMADDSUB321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38513, 201},
+    /* 3211 */ {I_VFMADDSUB321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38520, 201},
+    /* 3212 */ {I_VFMADDSUB321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38527, 201},
+    /* 3213 */ {I_VFMADDSUB321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38534, 201},
+    /* 3214 */ {I_VFMSUB132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38541, 201},
+    /* 3215 */ {I_VFMSUB132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38548, 201},
+    /* 3216 */ {I_VFMSUB132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38555, 201},
+    /* 3217 */ {I_VFMSUB132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38562, 201},
+    /* 3218 */ {I_VFMSUB312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38541, 201},
+    /* 3219 */ {I_VFMSUB312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38548, 201},
+    /* 3220 */ {I_VFMSUB312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38555, 201},
+    /* 3221 */ {I_VFMSUB312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38562, 201},
+    /* 3222 */ {I_VFMSUB213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38569, 201},
+    /* 3223 */ {I_VFMSUB213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38576, 201},
+    /* 3224 */ {I_VFMSUB213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38583, 201},
+    /* 3225 */ {I_VFMSUB213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38590, 201},
+    /* 3226 */ {I_VFMSUB123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38569, 201},
+    /* 3227 */ {I_VFMSUB123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38576, 201},
+    /* 3228 */ {I_VFMSUB123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38583, 201},
+    /* 3229 */ {I_VFMSUB123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38590, 201},
+    /* 3230 */ {I_VFMSUB231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38597, 201},
+    /* 3231 */ {I_VFMSUB231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38604, 201},
+    /* 3232 */ {I_VFMSUB231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38611, 201},
+    /* 3233 */ {I_VFMSUB231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38618, 201},
+    /* 3234 */ {I_VFMSUB321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38597, 201},
+    /* 3235 */ {I_VFMSUB321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38604, 201},
+    /* 3236 */ {I_VFMSUB321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38611, 201},
+    /* 3237 */ {I_VFMSUB321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38618, 201},
+    /* 3238 */ {I_VFMSUBADD132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38625, 201},
+    /* 3239 */ {I_VFMSUBADD132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38632, 201},
+    /* 3240 */ {I_VFMSUBADD132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38639, 201},
+    /* 3241 */ {I_VFMSUBADD132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38646, 201},
+    /* 3242 */ {I_VFMSUBADD312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38625, 201},
+    /* 3243 */ {I_VFMSUBADD312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38632, 201},
+    /* 3244 */ {I_VFMSUBADD312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38639, 201},
+    /* 3245 */ {I_VFMSUBADD312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38646, 201},
+    /* 3246 */ {I_VFMSUBADD213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38653, 201},
+    /* 3247 */ {I_VFMSUBADD213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38660, 201},
+    /* 3248 */ {I_VFMSUBADD213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38667, 201},
+    /* 3249 */ {I_VFMSUBADD213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38674, 201},
+    /* 3250 */ {I_VFMSUBADD123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38653, 201},
+    /* 3251 */ {I_VFMSUBADD123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38660, 201},
+    /* 3252 */ {I_VFMSUBADD123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38667, 201},
+    /* 3253 */ {I_VFMSUBADD123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38674, 201},
+    /* 3254 */ {I_VFMSUBADD231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38681, 201},
+    /* 3255 */ {I_VFMSUBADD231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38688, 201},
+    /* 3256 */ {I_VFMSUBADD231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38695, 201},
+    /* 3257 */ {I_VFMSUBADD231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38702, 201},
+    /* 3258 */ {I_VFMSUBADD321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38681, 201},
+    /* 3259 */ {I_VFMSUBADD321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38688, 201},
+    /* 3260 */ {I_VFMSUBADD321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38695, 201},
+    /* 3261 */ {I_VFMSUBADD321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38702, 201},
+    /* 3262 */ {I_VFNMADD132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38709, 201},
+    /* 3263 */ {I_VFNMADD132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38716, 201},
+    /* 3264 */ {I_VFNMADD132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38723, 201},
+    /* 3265 */ {I_VFNMADD132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38730, 201},
+    /* 3266 */ {I_VFNMADD312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38709, 201},
+    /* 3267 */ {I_VFNMADD312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38716, 201},
+    /* 3268 */ {I_VFNMADD312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38723, 201},
+    /* 3269 */ {I_VFNMADD312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38730, 201},
+    /* 3270 */ {I_VFNMADD213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38737, 201},
+    /* 3271 */ {I_VFNMADD213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38744, 201},
+    /* 3272 */ {I_VFNMADD213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38751, 201},
+    /* 3273 */ {I_VFNMADD213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38758, 201},
+    /* 3274 */ {I_VFNMADD123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38737, 201},
+    /* 3275 */ {I_VFNMADD123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38744, 201},
+    /* 3276 */ {I_VFNMADD123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38751, 201},
+    /* 3277 */ {I_VFNMADD123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38758, 201},
+    /* 3278 */ {I_VFNMADD231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38765, 201},
+    /* 3279 */ {I_VFNMADD231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38772, 201},
+    /* 3280 */ {I_VFNMADD231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38779, 201},
+    /* 3281 */ {I_VFNMADD231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38786, 201},
+    /* 3282 */ {I_VFNMADD321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38765, 201},
+    /* 3283 */ {I_VFNMADD321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38772, 201},
+    /* 3284 */ {I_VFNMADD321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38779, 201},
+    /* 3285 */ {I_VFNMADD321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38786, 201},
+    /* 3286 */ {I_VFNMSUB132PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38793, 201},
+    /* 3287 */ {I_VFNMSUB132PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38800, 201},
+    /* 3288 */ {I_VFNMSUB132PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38807, 201},
+    /* 3289 */ {I_VFNMSUB132PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38814, 201},
+    /* 3290 */ {I_VFNMSUB312PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38793, 201},
+    /* 3291 */ {I_VFNMSUB312PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38800, 201},
+    /* 3292 */ {I_VFNMSUB312PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38807, 201},
+    /* 3293 */ {I_VFNMSUB312PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38814, 201},
+    /* 3294 */ {I_VFNMSUB213PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38821, 201},
+    /* 3295 */ {I_VFNMSUB213PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38828, 201},
+    /* 3296 */ {I_VFNMSUB213PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38835, 201},
+    /* 3297 */ {I_VFNMSUB213PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38842, 201},
+    /* 3298 */ {I_VFNMSUB123PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38821, 201},
+    /* 3299 */ {I_VFNMSUB123PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38828, 201},
+    /* 3300 */ {I_VFNMSUB123PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38835, 201},
+    /* 3301 */ {I_VFNMSUB123PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38842, 201},
+    /* 3302 */ {I_VFNMSUB231PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38849, 201},
+    /* 3303 */ {I_VFNMSUB231PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38856, 201},
+    /* 3304 */ {I_VFNMSUB231PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38863, 201},
+    /* 3305 */ {I_VFNMSUB231PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38870, 201},
+    /* 3306 */ {I_VFNMSUB321PS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38849, 201},
+    /* 3307 */ {I_VFNMSUB321PS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38856, 201},
+    /* 3308 */ {I_VFNMSUB321PD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+38863, 201},
+    /* 3309 */ {I_VFNMSUB321PD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+38870, 201},
+    /* 3310 */ {I_VFMADD132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38877, 201},
+    /* 3311 */ {I_VFMADD132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38884, 201},
+    /* 3312 */ {I_VFMADD312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38877, 201},
+    /* 3313 */ {I_VFMADD312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38884, 201},
+    /* 3314 */ {I_VFMADD213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38891, 201},
+    /* 3315 */ {I_VFMADD213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38898, 201},
+    /* 3316 */ {I_VFMADD123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38891, 201},
+    /* 3317 */ {I_VFMADD123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38898, 201},
+    /* 3318 */ {I_VFMADD231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38905, 201},
+    /* 3319 */ {I_VFMADD231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38912, 201},
+    /* 3320 */ {I_VFMADD321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38905, 201},
+    /* 3321 */ {I_VFMADD321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38912, 201},
+    /* 3322 */ {I_VFMSUB132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38919, 201},
+    /* 3323 */ {I_VFMSUB132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38926, 201},
+    /* 3324 */ {I_VFMSUB312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38919, 201},
+    /* 3325 */ {I_VFMSUB312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38926, 201},
+    /* 3326 */ {I_VFMSUB213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38933, 201},
+    /* 3327 */ {I_VFMSUB213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38940, 201},
+    /* 3328 */ {I_VFMSUB123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38933, 201},
+    /* 3329 */ {I_VFMSUB123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38940, 201},
+    /* 3330 */ {I_VFMSUB231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38947, 201},
+    /* 3331 */ {I_VFMSUB231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38954, 201},
+    /* 3332 */ {I_VFMSUB321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38947, 201},
+    /* 3333 */ {I_VFMSUB321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38954, 201},
+    /* 3334 */ {I_VFNMADD132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38961, 201},
+    /* 3335 */ {I_VFNMADD132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38968, 201},
+    /* 3336 */ {I_VFNMADD312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38961, 201},
+    /* 3337 */ {I_VFNMADD312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38968, 201},
+    /* 3338 */ {I_VFNMADD213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38975, 201},
+    /* 3339 */ {I_VFNMADD213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38982, 201},
+    /* 3340 */ {I_VFNMADD123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38975, 201},
+    /* 3341 */ {I_VFNMADD123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38982, 201},
+    /* 3342 */ {I_VFNMADD231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38989, 201},
+    /* 3343 */ {I_VFNMADD231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38996, 201},
+    /* 3344 */ {I_VFNMADD321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+38989, 201},
+    /* 3345 */ {I_VFNMADD321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+38996, 201},
+    /* 3346 */ {I_VFNMSUB132SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39003, 201},
+    /* 3347 */ {I_VFNMSUB132SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39010, 201},
+    /* 3348 */ {I_VFNMSUB312SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39003, 201},
+    /* 3349 */ {I_VFNMSUB312SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39010, 201},
+    /* 3350 */ {I_VFNMSUB213SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39017, 201},
+    /* 3351 */ {I_VFNMSUB213SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39024, 201},
+    /* 3352 */ {I_VFNMSUB123SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39017, 201},
+    /* 3353 */ {I_VFNMSUB123SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39024, 201},
+    /* 3354 */ {I_VFNMSUB231SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39031, 201},
+    /* 3355 */ {I_VFNMSUB231SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39038, 201},
+    /* 3356 */ {I_VFNMSUB321SS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+39031, 201},
+    /* 3357 */ {I_VFNMSUB321SD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+39038, 201},
+    /* 3358 */ {I_RDFSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39045, 136},
+    /* 3359 */ {I_RDFSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39052, 136},
+    /* 3360 */ {I_RDGSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39059, 136},
+    /* 3361 */ {I_RDGSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39066, 136},
+    /* 3362 */ {I_RDRAND, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45771, 135},
+    /* 3363 */ {I_RDRAND, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45777, 135},
+    /* 3364 */ {I_RDRAND, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45783, 136},
+    /* 3365 */ {I_WRFSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39073, 136},
+    /* 3366 */ {I_WRFSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39080, 136},
+    /* 3367 */ {I_WRGSBASE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39087, 136},
+    /* 3368 */ {I_WRGSBASE, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39094, 136},
+    /* 3369 */ {I_VCVTPH2PS, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39101, 202},
+    /* 3370 */ {I_VCVTPH2PS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+39108, 202},
+    /* 3371 */ {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14224, 202},
+    /* 3372 */ {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14232, 202},
+    /* 3373 */ {I_ADCX, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+14240, 135},
+    /* 3374 */ {I_ADCX, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+14248, 136},
+    /* 3375 */ {I_ADOX, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+14256, 135},
+    /* 3376 */ {I_ADOX, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+14264, 136},
+    /* 3377 */ {I_RDSEED, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45789, 135},
+    /* 3378 */ {I_RDSEED, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45795, 135},
+    /* 3379 */ {I_RDSEED, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45801, 136},
+    /* 3380 */ {I_CLAC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49147, 203},
+    /* 3381 */ {I_STAC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49152, 203},
+    /* 3382 */ {I_XSTORE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49157, 32},
+    /* 3383 */ {I_XCRYPTECB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45807, 32},
+    /* 3384 */ {I_XCRYPTCBC, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45813, 32},
+    /* 3385 */ {I_XCRYPTCTR, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45819, 32},
+    /* 3386 */ {I_XCRYPTCFB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45825, 32},
+    /* 3387 */ {I_XCRYPTOFB, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45831, 32},
+    /* 3388 */ {I_MONTMUL, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45837, 32},
+    /* 3389 */ {I_XSHA1, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45843, 32},
+    /* 3390 */ {I_XSHA256, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45849, 32},
+    /* 3391 */ {I_LLWPCB, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39115, 204},
+    /* 3392 */ {I_LLWPCB, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39122, 205},
+    /* 3393 */ {I_SLWPCB, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39129, 204},
+    /* 3394 */ {I_SLWPCB, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39136, 205},
+    /* 3395 */ {I_LWPVAL, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14272, 204},
+    /* 3396 */ {I_LWPVAL, 3, {REG_GPR|BITS64,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14280, 205},
+    /* 3397 */ {I_LWPINS, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14288, 204},
+    /* 3398 */ {I_LWPINS, 3, {REG_GPR|BITS64,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14296, 205},
+    /* 3399 */ {I_VFMADDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14304, 206},
+    /* 3400 */ {I_VFMADDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14312, 206},
+    /* 3401 */ {I_VFMADDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14320, 206},
+    /* 3402 */ {I_VFMADDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14328, 206},
+    /* 3403 */ {I_VFMADDPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14336, 206},
+    /* 3404 */ {I_VFMADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14344, 206},
+    /* 3405 */ {I_VFMADDPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14352, 206},
+    /* 3406 */ {I_VFMADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14360, 206},
+    /* 3407 */ {I_VFMADDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14368, 206},
+    /* 3408 */ {I_VFMADDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14376, 206},
+    /* 3409 */ {I_VFMADDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14384, 206},
+    /* 3410 */ {I_VFMADDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14392, 206},
+    /* 3411 */ {I_VFMADDPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14400, 206},
+    /* 3412 */ {I_VFMADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14408, 206},
+    /* 3413 */ {I_VFMADDPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14416, 206},
+    /* 3414 */ {I_VFMADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14424, 206},
+    /* 3415 */ {I_VFMADDSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14432, 206},
+    /* 3416 */ {I_VFMADDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14440, 206},
+    /* 3417 */ {I_VFMADDSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+14448, 206},
+    /* 3418 */ {I_VFMADDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+14456, 206},
+    /* 3419 */ {I_VFMADDSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14464, 206},
+    /* 3420 */ {I_VFMADDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14472, 206},
+    /* 3421 */ {I_VFMADDSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+14480, 206},
+    /* 3422 */ {I_VFMADDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14488, 206},
+    /* 3423 */ {I_VFMADDSUBPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14496, 206},
+    /* 3424 */ {I_VFMADDSUBPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14504, 206},
+    /* 3425 */ {I_VFMADDSUBPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14512, 206},
+    /* 3426 */ {I_VFMADDSUBPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14520, 206},
+    /* 3427 */ {I_VFMADDSUBPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14528, 206},
+    /* 3428 */ {I_VFMADDSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14536, 206},
+    /* 3429 */ {I_VFMADDSUBPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14544, 206},
+    /* 3430 */ {I_VFMADDSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14552, 206},
+    /* 3431 */ {I_VFMADDSUBPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14560, 206},
+    /* 3432 */ {I_VFMADDSUBPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14568, 206},
+    /* 3433 */ {I_VFMADDSUBPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14576, 206},
+    /* 3434 */ {I_VFMADDSUBPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14584, 206},
+    /* 3435 */ {I_VFMADDSUBPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14592, 206},
+    /* 3436 */ {I_VFMADDSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14600, 206},
+    /* 3437 */ {I_VFMADDSUBPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14608, 206},
+    /* 3438 */ {I_VFMADDSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14616, 206},
+    /* 3439 */ {I_VFMSUBADDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14624, 206},
+    /* 3440 */ {I_VFMSUBADDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14632, 206},
+    /* 3441 */ {I_VFMSUBADDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14640, 206},
+    /* 3442 */ {I_VFMSUBADDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14648, 206},
+    /* 3443 */ {I_VFMSUBADDPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14656, 206},
+    /* 3444 */ {I_VFMSUBADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14664, 206},
+    /* 3445 */ {I_VFMSUBADDPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14672, 206},
+    /* 3446 */ {I_VFMSUBADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14680, 206},
+    /* 3447 */ {I_VFMSUBADDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14688, 206},
+    /* 3448 */ {I_VFMSUBADDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14696, 206},
+    /* 3449 */ {I_VFMSUBADDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14704, 206},
+    /* 3450 */ {I_VFMSUBADDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14712, 206},
+    /* 3451 */ {I_VFMSUBADDPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14720, 206},
+    /* 3452 */ {I_VFMSUBADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14728, 206},
+    /* 3453 */ {I_VFMSUBADDPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14736, 206},
+    /* 3454 */ {I_VFMSUBADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14744, 206},
+    /* 3455 */ {I_VFMSUBPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14752, 206},
+    /* 3456 */ {I_VFMSUBPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14760, 206},
+    /* 3457 */ {I_VFMSUBPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14768, 206},
+    /* 3458 */ {I_VFMSUBPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14776, 206},
+    /* 3459 */ {I_VFMSUBPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14784, 206},
+    /* 3460 */ {I_VFMSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14792, 206},
+    /* 3461 */ {I_VFMSUBPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14800, 206},
+    /* 3462 */ {I_VFMSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14808, 206},
+    /* 3463 */ {I_VFMSUBPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14816, 206},
+    /* 3464 */ {I_VFMSUBPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14824, 206},
+    /* 3465 */ {I_VFMSUBPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14832, 206},
+    /* 3466 */ {I_VFMSUBPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14840, 206},
+    /* 3467 */ {I_VFMSUBPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14848, 206},
+    /* 3468 */ {I_VFMSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14856, 206},
+    /* 3469 */ {I_VFMSUBPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14864, 206},
+    /* 3470 */ {I_VFMSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+14872, 206},
+    /* 3471 */ {I_VFMSUBSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14880, 206},
+    /* 3472 */ {I_VFMSUBSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14888, 206},
+    /* 3473 */ {I_VFMSUBSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+14896, 206},
+    /* 3474 */ {I_VFMSUBSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+14904, 206},
+    /* 3475 */ {I_VFMSUBSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14912, 206},
+    /* 3476 */ {I_VFMSUBSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14920, 206},
+    /* 3477 */ {I_VFMSUBSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+14928, 206},
+    /* 3478 */ {I_VFMSUBSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+14936, 206},
+    /* 3479 */ {I_VFNMADDPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14944, 206},
+    /* 3480 */ {I_VFNMADDPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14952, 206},
+    /* 3481 */ {I_VFNMADDPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+14960, 206},
+    /* 3482 */ {I_VFNMADDPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+14968, 206},
+    /* 3483 */ {I_VFNMADDPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+14976, 206},
+    /* 3484 */ {I_VFNMADDPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+14984, 206},
+    /* 3485 */ {I_VFNMADDPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+14992, 206},
+    /* 3486 */ {I_VFNMADDPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15000, 206},
+    /* 3487 */ {I_VFNMADDPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15008, 206},
+    /* 3488 */ {I_VFNMADDPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15016, 206},
+    /* 3489 */ {I_VFNMADDPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15024, 206},
+    /* 3490 */ {I_VFNMADDPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15032, 206},
+    /* 3491 */ {I_VFNMADDPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15040, 206},
+    /* 3492 */ {I_VFNMADDPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15048, 206},
+    /* 3493 */ {I_VFNMADDPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15056, 206},
+    /* 3494 */ {I_VFNMADDPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15064, 206},
+    /* 3495 */ {I_VFNMADDSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15072, 206},
+    /* 3496 */ {I_VFNMADDSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15080, 206},
+    /* 3497 */ {I_VFNMADDSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+15088, 206},
+    /* 3498 */ {I_VFNMADDSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+15096, 206},
+    /* 3499 */ {I_VFNMADDSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15104, 206},
+    /* 3500 */ {I_VFNMADDSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15112, 206},
+    /* 3501 */ {I_VFNMADDSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+15120, 206},
+    /* 3502 */ {I_VFNMADDSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+15128, 206},
+    /* 3503 */ {I_VFNMSUBPD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15136, 206},
+    /* 3504 */ {I_VFNMSUBPD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15144, 206},
+    /* 3505 */ {I_VFNMSUBPD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15152, 206},
+    /* 3506 */ {I_VFNMSUBPD, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15160, 206},
+    /* 3507 */ {I_VFNMSUBPD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15168, 206},
+    /* 3508 */ {I_VFNMSUBPD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15176, 206},
+    /* 3509 */ {I_VFNMSUBPD, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15184, 206},
+    /* 3510 */ {I_VFNMSUBPD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15192, 206},
+    /* 3511 */ {I_VFNMSUBPS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15200, 206},
+    /* 3512 */ {I_VFNMSUBPS, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15208, 206},
+    /* 3513 */ {I_VFNMSUBPS, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15216, 206},
+    /* 3514 */ {I_VFNMSUBPS, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15224, 206},
+    /* 3515 */ {I_VFNMSUBPS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15232, 206},
+    /* 3516 */ {I_VFNMSUBPS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15240, 206},
+    /* 3517 */ {I_VFNMSUBPS, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15248, 206},
+    /* 3518 */ {I_VFNMSUBPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15256, 206},
+    /* 3519 */ {I_VFNMSUBSD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15264, 206},
+    /* 3520 */ {I_VFNMSUBSD, 3, {XMM_L16,RM_XMM_L16|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15272, 206},
+    /* 3521 */ {I_VFNMSUBSD, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0}, NO_DECORATOR, nasm_bytecodes+15280, 206},
+    /* 3522 */ {I_VFNMSUBSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+15288, 206},
+    /* 3523 */ {I_VFNMSUBSS, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15296, 206},
+    /* 3524 */ {I_VFNMSUBSS, 3, {XMM_L16,RM_XMM_L16|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15304, 206},
+    /* 3525 */ {I_VFNMSUBSS, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0}, NO_DECORATOR, nasm_bytecodes+15312, 206},
+    /* 3526 */ {I_VFNMSUBSS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+15320, 206},
+    /* 3527 */ {I_VFRCZPD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39143, 206},
+    /* 3528 */ {I_VFRCZPD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39150, 206},
+    /* 3529 */ {I_VFRCZPD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39157, 206},
+    /* 3530 */ {I_VFRCZPD, 1, {YMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39164, 206},
+    /* 3531 */ {I_VFRCZPS, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39171, 206},
+    /* 3532 */ {I_VFRCZPS, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39178, 206},
+    /* 3533 */ {I_VFRCZPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39185, 206},
+    /* 3534 */ {I_VFRCZPS, 1, {YMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39192, 206},
+    /* 3535 */ {I_VFRCZSD, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+39199, 206},
+    /* 3536 */ {I_VFRCZSD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39206, 206},
+    /* 3537 */ {I_VFRCZSS, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+39213, 206},
+    /* 3538 */ {I_VFRCZSS, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39220, 206},
+    /* 3539 */ {I_VPCMOV, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15328, 206},
+    /* 3540 */ {I_VPCMOV, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15336, 206},
+    /* 3541 */ {I_VPCMOV, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15344, 206},
+    /* 3542 */ {I_VPCMOV, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15352, 206},
+    /* 3543 */ {I_VPCMOV, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15360, 206},
+    /* 3544 */ {I_VPCMOV, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15368, 206},
+    /* 3545 */ {I_VPCMOV, 4, {YMM_L16,YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0}, NO_DECORATOR, nasm_bytecodes+15376, 206},
+    /* 3546 */ {I_VPCMOV, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+15384, 206},
+    /* 3547 */ {I_VPCOMB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15392, 206},
+    /* 3548 */ {I_VPCOMB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15400, 206},
+    /* 3549 */ {I_VPCOMD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15408, 206},
+    /* 3550 */ {I_VPCOMD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15416, 206},
+    /* 3551 */ {I_VPCOMQ, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15424, 206},
+    /* 3552 */ {I_VPCOMQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15432, 206},
+    /* 3553 */ {I_VPCOMUB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15440, 206},
+    /* 3554 */ {I_VPCOMUB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15448, 206},
+    /* 3555 */ {I_VPCOMUD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15456, 206},
+    /* 3556 */ {I_VPCOMUD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15464, 206},
+    /* 3557 */ {I_VPCOMUQ, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15472, 206},
+    /* 3558 */ {I_VPCOMUQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15480, 206},
+    /* 3559 */ {I_VPCOMUW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15488, 206},
+    /* 3560 */ {I_VPCOMUW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15496, 206},
+    /* 3561 */ {I_VPCOMW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15504, 206},
+    /* 3562 */ {I_VPCOMW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15512, 206},
+    /* 3563 */ {I_VPHADDBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39227, 206},
+    /* 3564 */ {I_VPHADDBD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39234, 206},
+    /* 3565 */ {I_VPHADDBQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39241, 206},
+    /* 3566 */ {I_VPHADDBQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39248, 206},
+    /* 3567 */ {I_VPHADDBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39255, 206},
+    /* 3568 */ {I_VPHADDBW, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39262, 206},
+    /* 3569 */ {I_VPHADDDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39269, 206},
+    /* 3570 */ {I_VPHADDDQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39276, 206},
+    /* 3571 */ {I_VPHADDUBD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39283, 206},
+    /* 3572 */ {I_VPHADDUBD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39290, 206},
+    /* 3573 */ {I_VPHADDUBQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39297, 206},
+    /* 3574 */ {I_VPHADDUBQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39304, 206},
+    /* 3575 */ {I_VPHADDUBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39311, 206},
+    /* 3576 */ {I_VPHADDUBW, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39318, 206},
+    /* 3577 */ {I_VPHADDUDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39325, 206},
+    /* 3578 */ {I_VPHADDUDQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39332, 206},
+    /* 3579 */ {I_VPHADDUWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39339, 206},
+    /* 3580 */ {I_VPHADDUWD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39346, 206},
+    /* 3581 */ {I_VPHADDUWQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39353, 206},
+    /* 3582 */ {I_VPHADDUWQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39360, 206},
+    /* 3583 */ {I_VPHADDWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39367, 206},
+    /* 3584 */ {I_VPHADDWD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39374, 206},
+    /* 3585 */ {I_VPHADDWQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39381, 206},
+    /* 3586 */ {I_VPHADDWQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39388, 206},
+    /* 3587 */ {I_VPHSUBBW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39395, 206},
+    /* 3588 */ {I_VPHSUBBW, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39402, 206},
+    /* 3589 */ {I_VPHSUBDQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39409, 206},
+    /* 3590 */ {I_VPHSUBDQ, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39416, 206},
+    /* 3591 */ {I_VPHSUBWD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39423, 206},
+    /* 3592 */ {I_VPHSUBWD, 1, {XMM_L16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+39430, 206},
+    /* 3593 */ {I_VPMACSDD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15520, 206},
+    /* 3594 */ {I_VPMACSDD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15528, 206},
+    /* 3595 */ {I_VPMACSDQH, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15536, 206},
+    /* 3596 */ {I_VPMACSDQH, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15544, 206},
+    /* 3597 */ {I_VPMACSDQL, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15552, 206},
+    /* 3598 */ {I_VPMACSDQL, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15560, 206},
+    /* 3599 */ {I_VPMACSSDD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15568, 206},
+    /* 3600 */ {I_VPMACSSDD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15576, 206},
+    /* 3601 */ {I_VPMACSSDQH, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15584, 206},
+    /* 3602 */ {I_VPMACSSDQH, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15592, 206},
+    /* 3603 */ {I_VPMACSSDQL, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15600, 206},
+    /* 3604 */ {I_VPMACSSDQL, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15608, 206},
+    /* 3605 */ {I_VPMACSSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15616, 206},
+    /* 3606 */ {I_VPMACSSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15624, 206},
+    /* 3607 */ {I_VPMACSSWW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15632, 206},
+    /* 3608 */ {I_VPMACSSWW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15640, 206},
+    /* 3609 */ {I_VPMACSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15648, 206},
+    /* 3610 */ {I_VPMACSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15656, 206},
+    /* 3611 */ {I_VPMACSWW, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15664, 206},
+    /* 3612 */ {I_VPMACSWW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15672, 206},
+    /* 3613 */ {I_VPMADCSSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15680, 206},
+    /* 3614 */ {I_VPMADCSSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15688, 206},
+    /* 3615 */ {I_VPMADCSWD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15696, 206},
+    /* 3616 */ {I_VPMADCSWD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15704, 206},
+    /* 3617 */ {I_VPPERM, 4, {XMM_L16,XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0}, NO_DECORATOR, nasm_bytecodes+15712, 206},
+    /* 3618 */ {I_VPPERM, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+15720, 206},
+    /* 3619 */ {I_VPPERM, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15728, 206},
+    /* 3620 */ {I_VPPERM, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15736, 206},
+    /* 3621 */ {I_VPROTB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39437, 206},
+    /* 3622 */ {I_VPROTB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39444, 206},
+    /* 3623 */ {I_VPROTB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39451, 206},
+    /* 3624 */ {I_VPROTB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39458, 206},
+    /* 3625 */ {I_VPROTB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15744, 206},
+    /* 3626 */ {I_VPROTB, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15752, 206},
+    /* 3627 */ {I_VPROTD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39465, 206},
+    /* 3628 */ {I_VPROTD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39472, 206},
+    /* 3629 */ {I_VPROTD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39479, 206},
+    /* 3630 */ {I_VPROTD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39486, 206},
+    /* 3631 */ {I_VPROTD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15760, 206},
+    /* 3632 */ {I_VPROTD, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15768, 206},
+    /* 3633 */ {I_VPROTQ, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39493, 206},
+    /* 3634 */ {I_VPROTQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39500, 206},
+    /* 3635 */ {I_VPROTQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39507, 206},
+    /* 3636 */ {I_VPROTQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39514, 206},
+    /* 3637 */ {I_VPROTQ, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15776, 206},
+    /* 3638 */ {I_VPROTQ, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15784, 206},
+    /* 3639 */ {I_VPROTW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39521, 206},
+    /* 3640 */ {I_VPROTW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39528, 206},
+    /* 3641 */ {I_VPROTW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39535, 206},
+    /* 3642 */ {I_VPROTW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39542, 206},
+    /* 3643 */ {I_VPROTW, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15792, 206},
+    /* 3644 */ {I_VPROTW, 2, {XMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15800, 206},
+    /* 3645 */ {I_VPSHAB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39549, 206},
+    /* 3646 */ {I_VPSHAB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39556, 206},
+    /* 3647 */ {I_VPSHAB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39563, 206},
+    /* 3648 */ {I_VPSHAB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39570, 206},
+    /* 3649 */ {I_VPSHAD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39577, 206},
+    /* 3650 */ {I_VPSHAD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39584, 206},
+    /* 3651 */ {I_VPSHAD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39591, 206},
+    /* 3652 */ {I_VPSHAD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39598, 206},
+    /* 3653 */ {I_VPSHAQ, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39605, 206},
+    /* 3654 */ {I_VPSHAQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39612, 206},
+    /* 3655 */ {I_VPSHAQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39619, 206},
+    /* 3656 */ {I_VPSHAQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39626, 206},
+    /* 3657 */ {I_VPSHAW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39633, 206},
+    /* 3658 */ {I_VPSHAW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39640, 206},
+    /* 3659 */ {I_VPSHAW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39647, 206},
+    /* 3660 */ {I_VPSHAW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39654, 206},
+    /* 3661 */ {I_VPSHLB, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39661, 206},
+    /* 3662 */ {I_VPSHLB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39668, 206},
+    /* 3663 */ {I_VPSHLB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39675, 206},
+    /* 3664 */ {I_VPSHLB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39682, 206},
+    /* 3665 */ {I_VPSHLD, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39689, 206},
+    /* 3666 */ {I_VPSHLD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39696, 206},
+    /* 3667 */ {I_VPSHLD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39703, 206},
+    /* 3668 */ {I_VPSHLD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39710, 206},
+    /* 3669 */ {I_VPSHLQ, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39717, 206},
+    /* 3670 */ {I_VPSHLQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39724, 206},
+    /* 3671 */ {I_VPSHLQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39731, 206},
+    /* 3672 */ {I_VPSHLQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39738, 206},
+    /* 3673 */ {I_VPSHLW, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+39745, 206},
+    /* 3674 */ {I_VPSHLW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+39752, 206},
+    /* 3675 */ {I_VPSHLW, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+39759, 206},
+    /* 3676 */ {I_VPSHLW, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39766, 206},
+    /* 3677 */ {I_VMPSADBW, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15808, 207},
+    /* 3678 */ {I_VMPSADBW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15816, 207},
+    /* 3679 */ {I_VPABSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39773, 207},
+    /* 3680 */ {I_VPABSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39780, 207},
+    /* 3681 */ {I_VPABSD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39787, 207},
+    /* 3682 */ {I_VPACKSSWB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39794, 207},
+    /* 3683 */ {I_VPACKSSWB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39801, 207},
+    /* 3684 */ {I_VPACKSSDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39808, 207},
+    /* 3685 */ {I_VPACKSSDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39815, 207},
+    /* 3686 */ {I_VPACKUSDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39822, 207},
+    /* 3687 */ {I_VPACKUSDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39829, 207},
+    /* 3688 */ {I_VPACKUSWB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39836, 207},
+    /* 3689 */ {I_VPACKUSWB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39843, 207},
+    /* 3690 */ {I_VPADDB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39850, 207},
+    /* 3691 */ {I_VPADDB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39857, 207},
+    /* 3692 */ {I_VPADDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39864, 207},
+    /* 3693 */ {I_VPADDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39871, 207},
+    /* 3694 */ {I_VPADDD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39878, 207},
+    /* 3695 */ {I_VPADDD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39885, 207},
+    /* 3696 */ {I_VPADDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39892, 207},
+    /* 3697 */ {I_VPADDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39899, 207},
+    /* 3698 */ {I_VPADDSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39906, 207},
+    /* 3699 */ {I_VPADDSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39913, 207},
+    /* 3700 */ {I_VPADDSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39920, 207},
+    /* 3701 */ {I_VPADDSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39927, 207},
+    /* 3702 */ {I_VPADDUSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39934, 207},
+    /* 3703 */ {I_VPADDUSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39941, 207},
+    /* 3704 */ {I_VPADDUSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39948, 207},
+    /* 3705 */ {I_VPADDUSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39955, 207},
+    /* 3706 */ {I_VPALIGNR, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15824, 207},
+    /* 3707 */ {I_VPALIGNR, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15832, 207},
+    /* 3708 */ {I_VPAND, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39962, 207},
+    /* 3709 */ {I_VPAND, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39969, 207},
+    /* 3710 */ {I_VPANDN, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39976, 207},
+    /* 3711 */ {I_VPANDN, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39983, 207},
+    /* 3712 */ {I_VPAVGB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+39990, 207},
+    /* 3713 */ {I_VPAVGB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+39997, 207},
+    /* 3714 */ {I_VPAVGW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40004, 207},
+    /* 3715 */ {I_VPAVGW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40011, 207},
+    /* 3716 */ {I_VPBLENDVB, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0}, NO_DECORATOR, nasm_bytecodes+15840, 207},
+    /* 3717 */ {I_VPBLENDVB, 3, {YMM_L16,RM_YMM_L16|BITS256,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+15848, 207},
+    /* 3718 */ {I_VPBLENDW, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+15856, 207},
+    /* 3719 */ {I_VPBLENDW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15864, 207},
+    /* 3720 */ {I_VPCMPEQB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40018, 207},
+    /* 3721 */ {I_VPCMPEQB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40025, 207},
+    /* 3722 */ {I_VPCMPEQW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40032, 207},
+    /* 3723 */ {I_VPCMPEQW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40039, 207},
+    /* 3724 */ {I_VPCMPEQD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40046, 207},
+    /* 3725 */ {I_VPCMPEQD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40053, 207},
+    /* 3726 */ {I_VPCMPEQQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40060, 207},
+    /* 3727 */ {I_VPCMPEQQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40067, 207},
+    /* 3728 */ {I_VPCMPGTB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40074, 207},
+    /* 3729 */ {I_VPCMPGTB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40081, 207},
+    /* 3730 */ {I_VPCMPGTW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40088, 207},
+    /* 3731 */ {I_VPCMPGTW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40095, 207},
+    /* 3732 */ {I_VPCMPGTD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40102, 207},
+    /* 3733 */ {I_VPCMPGTD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40109, 207},
+    /* 3734 */ {I_VPCMPGTQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40116, 207},
+    /* 3735 */ {I_VPCMPGTQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40123, 207},
+    /* 3736 */ {I_VPHADDW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40130, 207},
+    /* 3737 */ {I_VPHADDW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40137, 207},
+    /* 3738 */ {I_VPHADDD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40144, 207},
+    /* 3739 */ {I_VPHADDD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40151, 207},
+    /* 3740 */ {I_VPHADDSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40158, 207},
+    /* 3741 */ {I_VPHADDSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40165, 207},
+    /* 3742 */ {I_VPHSUBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40172, 207},
+    /* 3743 */ {I_VPHSUBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40179, 207},
+    /* 3744 */ {I_VPHSUBD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40186, 207},
+    /* 3745 */ {I_VPHSUBD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40193, 207},
+    /* 3746 */ {I_VPHSUBSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40200, 207},
+    /* 3747 */ {I_VPHSUBSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40207, 207},
+    /* 3748 */ {I_VPMADDUBSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40214, 207},
+    /* 3749 */ {I_VPMADDUBSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40221, 207},
+    /* 3750 */ {I_VPMADDWD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40228, 207},
+    /* 3751 */ {I_VPMADDWD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40235, 207},
+    /* 3752 */ {I_VPMAXSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40242, 207},
+    /* 3753 */ {I_VPMAXSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40249, 207},
+    /* 3754 */ {I_VPMAXSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40256, 207},
+    /* 3755 */ {I_VPMAXSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40263, 207},
+    /* 3756 */ {I_VPMAXSD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40270, 207},
+    /* 3757 */ {I_VPMAXSD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40277, 207},
+    /* 3758 */ {I_VPMAXUB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40284, 207},
+    /* 3759 */ {I_VPMAXUB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40291, 207},
+    /* 3760 */ {I_VPMAXUW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40298, 207},
+    /* 3761 */ {I_VPMAXUW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40305, 207},
+    /* 3762 */ {I_VPMAXUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40312, 207},
+    /* 3763 */ {I_VPMAXUD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40319, 207},
+    /* 3764 */ {I_VPMINSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40326, 207},
+    /* 3765 */ {I_VPMINSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40333, 207},
+    /* 3766 */ {I_VPMINSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40340, 207},
+    /* 3767 */ {I_VPMINSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40347, 207},
+    /* 3768 */ {I_VPMINSD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40354, 207},
+    /* 3769 */ {I_VPMINSD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40361, 207},
+    /* 3770 */ {I_VPMINUB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40368, 207},
+    /* 3771 */ {I_VPMINUB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40375, 207},
+    /* 3772 */ {I_VPMINUW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40382, 207},
+    /* 3773 */ {I_VPMINUW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40389, 207},
+    /* 3774 */ {I_VPMINUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40396, 207},
+    /* 3775 */ {I_VPMINUD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40403, 207},
+    /* 3776 */ {I_VPMOVMSKB, 2, {REG_GPR|BITS32,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40410, 207},
+    /* 3777 */ {I_VPMOVMSKB, 2, {REG_GPR|BITS64,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40410, 207},
+    /* 3778 */ {I_VPMOVSXBW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40417, 207},
+    /* 3779 */ {I_VPMOVSXBD, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40424, 207},
+    /* 3780 */ {I_VPMOVSXBD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40424, 207},
+    /* 3781 */ {I_VPMOVSXBQ, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+40431, 207},
+    /* 3782 */ {I_VPMOVSXBQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40431, 207},
+    /* 3783 */ {I_VPMOVSXWD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40438, 207},
+    /* 3784 */ {I_VPMOVSXWQ, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40445, 207},
+    /* 3785 */ {I_VPMOVSXWQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40445, 207},
+    /* 3786 */ {I_VPMOVSXDQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40452, 207},
+    /* 3787 */ {I_VPMOVZXBW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40459, 207},
+    /* 3788 */ {I_VPMOVZXBD, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40466, 207},
+    /* 3789 */ {I_VPMOVZXBD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40466, 207},
+    /* 3790 */ {I_VPMOVZXBQ, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+40473, 207},
+    /* 3791 */ {I_VPMOVZXBQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40473, 207},
+    /* 3792 */ {I_VPMOVZXWD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40480, 207},
+    /* 3793 */ {I_VPMOVZXWQ, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+40487, 207},
+    /* 3794 */ {I_VPMOVZXWQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+40487, 207},
+    /* 3795 */ {I_VPMOVZXDQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40494, 207},
+    /* 3796 */ {I_VPMULDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40501, 207},
+    /* 3797 */ {I_VPMULDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40508, 207},
+    /* 3798 */ {I_VPMULHRSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40515, 207},
+    /* 3799 */ {I_VPMULHRSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40522, 207},
+    /* 3800 */ {I_VPMULHUW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40529, 207},
+    /* 3801 */ {I_VPMULHUW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40536, 207},
+    /* 3802 */ {I_VPMULHW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40543, 207},
+    /* 3803 */ {I_VPMULHW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40550, 207},
+    /* 3804 */ {I_VPMULLW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40557, 207},
+    /* 3805 */ {I_VPMULLW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40564, 207},
+    /* 3806 */ {I_VPMULLD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40571, 207},
+    /* 3807 */ {I_VPMULLD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40578, 207},
+    /* 3808 */ {I_VPMULUDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40585, 207},
+    /* 3809 */ {I_VPMULUDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40592, 207},
+    /* 3810 */ {I_VPOR, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40599, 207},
+    /* 3811 */ {I_VPOR, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40606, 207},
+    /* 3812 */ {I_VPSADBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40613, 207},
+    /* 3813 */ {I_VPSADBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40620, 207},
+    /* 3814 */ {I_VPSHUFB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40627, 207},
+    /* 3815 */ {I_VPSHUFB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40634, 207},
+    /* 3816 */ {I_VPSHUFD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15872, 207},
+    /* 3817 */ {I_VPSHUFHW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15880, 207},
+    /* 3818 */ {I_VPSHUFLW, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15888, 207},
+    /* 3819 */ {I_VPSIGNB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40641, 207},
+    /* 3820 */ {I_VPSIGNB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40648, 207},
+    /* 3821 */ {I_VPSIGNW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40655, 207},
+    /* 3822 */ {I_VPSIGNW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40662, 207},
+    /* 3823 */ {I_VPSIGND, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40669, 207},
+    /* 3824 */ {I_VPSIGND, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40676, 207},
+    /* 3825 */ {I_VPSLLDQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15896, 207},
+    /* 3826 */ {I_VPSLLDQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15904, 207},
+    /* 3827 */ {I_VPSLLW, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40683, 207},
+    /* 3828 */ {I_VPSLLW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40690, 207},
+    /* 3829 */ {I_VPSLLW, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15912, 207},
+    /* 3830 */ {I_VPSLLW, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15920, 207},
+    /* 3831 */ {I_VPSLLD, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40697, 207},
+    /* 3832 */ {I_VPSLLD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40704, 207},
+    /* 3833 */ {I_VPSLLD, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15928, 207},
+    /* 3834 */ {I_VPSLLD, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15936, 207},
+    /* 3835 */ {I_VPSLLQ, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40711, 207},
+    /* 3836 */ {I_VPSLLQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40718, 207},
+    /* 3837 */ {I_VPSLLQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15944, 207},
+    /* 3838 */ {I_VPSLLQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15952, 207},
+    /* 3839 */ {I_VPSRAW, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40725, 207},
+    /* 3840 */ {I_VPSRAW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40732, 207},
+    /* 3841 */ {I_VPSRAW, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15960, 207},
+    /* 3842 */ {I_VPSRAW, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15968, 207},
+    /* 3843 */ {I_VPSRAD, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40739, 207},
+    /* 3844 */ {I_VPSRAD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40746, 207},
+    /* 3845 */ {I_VPSRAD, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15976, 207},
+    /* 3846 */ {I_VPSRAD, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+15984, 207},
+    /* 3847 */ {I_VPSRLDQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+15992, 207},
+    /* 3848 */ {I_VPSRLDQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16000, 207},
+    /* 3849 */ {I_VPSRLW, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40753, 207},
+    /* 3850 */ {I_VPSRLW, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40760, 207},
+    /* 3851 */ {I_VPSRLW, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16008, 207},
+    /* 3852 */ {I_VPSRLW, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16016, 207},
+    /* 3853 */ {I_VPSRLD, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40767, 207},
+    /* 3854 */ {I_VPSRLD, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40774, 207},
+    /* 3855 */ {I_VPSRLD, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16024, 207},
+    /* 3856 */ {I_VPSRLD, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16032, 207},
+    /* 3857 */ {I_VPSRLQ, 3, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+40781, 207},
+    /* 3858 */ {I_VPSRLQ, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+40788, 207},
+    /* 3859 */ {I_VPSRLQ, 3, {YMM_L16,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16040, 207},
+    /* 3860 */ {I_VPSRLQ, 2, {YMM_L16,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+16048, 207},
+    /* 3861 */ {I_VPSUBB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40795, 207},
+    /* 3862 */ {I_VPSUBB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40802, 207},
+    /* 3863 */ {I_VPSUBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40809, 207},
+    /* 3864 */ {I_VPSUBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40816, 207},
+    /* 3865 */ {I_VPSUBD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40823, 207},
+    /* 3866 */ {I_VPSUBD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40830, 207},
+    /* 3867 */ {I_VPSUBQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40837, 207},
+    /* 3868 */ {I_VPSUBQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40844, 207},
+    /* 3869 */ {I_VPSUBSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40851, 207},
+    /* 3870 */ {I_VPSUBSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40858, 207},
+    /* 3871 */ {I_VPSUBSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40865, 207},
+    /* 3872 */ {I_VPSUBSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40872, 207},
+    /* 3873 */ {I_VPSUBUSB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40879, 207},
+    /* 3874 */ {I_VPSUBUSB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40886, 207},
+    /* 3875 */ {I_VPSUBUSW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40893, 207},
+    /* 3876 */ {I_VPSUBUSW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40900, 207},
+    /* 3877 */ {I_VPUNPCKHBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40907, 207},
+    /* 3878 */ {I_VPUNPCKHBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40914, 207},
+    /* 3879 */ {I_VPUNPCKHWD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40921, 207},
+    /* 3880 */ {I_VPUNPCKHWD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40928, 207},
+    /* 3881 */ {I_VPUNPCKHDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40935, 207},
+    /* 3882 */ {I_VPUNPCKHDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40942, 207},
+    /* 3883 */ {I_VPUNPCKHQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40949, 207},
+    /* 3884 */ {I_VPUNPCKHQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40956, 207},
+    /* 3885 */ {I_VPUNPCKLBW, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40963, 207},
+    /* 3886 */ {I_VPUNPCKLBW, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40970, 207},
+    /* 3887 */ {I_VPUNPCKLWD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40977, 207},
+    /* 3888 */ {I_VPUNPCKLWD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40984, 207},
+    /* 3889 */ {I_VPUNPCKLDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+40991, 207},
+    /* 3890 */ {I_VPUNPCKLDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+40998, 207},
+    /* 3891 */ {I_VPUNPCKLQDQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41005, 207},
+    /* 3892 */ {I_VPUNPCKLQDQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41012, 207},
+    /* 3893 */ {I_VPXOR, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41019, 207},
+    /* 3894 */ {I_VPXOR, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41026, 207},
+    /* 3895 */ {I_VMOVNTDQA, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41033, 207},
+    /* 3896 */ {I_VBROADCASTSS, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35244, 207},
+    /* 3897 */ {I_VBROADCASTSS, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35251, 207},
+    /* 3898 */ {I_VBROADCASTSD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+35258, 207},
+    /* 3899 */ {I_VBROADCASTI128, 2, {YMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41040, 207},
+    /* 3900 */ {I_VPBLENDD, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16056, 207},
+    /* 3901 */ {I_VPBLENDD, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16064, 207},
+    /* 3902 */ {I_VPBLENDD, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16072, 207},
+    /* 3903 */ {I_VPBLENDD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16080, 207},
+    /* 3904 */ {I_VPBROADCASTB, 2, {XMM_L16,MEMORY|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+41047, 207},
+    /* 3905 */ {I_VPBROADCASTB, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41047, 207},
+    /* 3906 */ {I_VPBROADCASTB, 2, {YMM_L16,MEMORY|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+41054, 207},
+    /* 3907 */ {I_VPBROADCASTB, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41054, 207},
+    /* 3908 */ {I_VPBROADCASTW, 2, {XMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41061, 207},
+    /* 3909 */ {I_VPBROADCASTW, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41061, 207},
+    /* 3910 */ {I_VPBROADCASTW, 2, {YMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41068, 207},
+    /* 3911 */ {I_VPBROADCASTW, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41068, 207},
+    /* 3912 */ {I_VPBROADCASTD, 2, {XMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41075, 207},
+    /* 3913 */ {I_VPBROADCASTD, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41075, 207},
+    /* 3914 */ {I_VPBROADCASTD, 2, {YMM_L16,MEMORY|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41082, 207},
+    /* 3915 */ {I_VPBROADCASTD, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41082, 207},
+    /* 3916 */ {I_VPBROADCASTQ, 2, {XMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41089, 207},
+    /* 3917 */ {I_VPBROADCASTQ, 2, {XMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41089, 207},
+    /* 3918 */ {I_VPBROADCASTQ, 2, {YMM_L16,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41096, 207},
+    /* 3919 */ {I_VPBROADCASTQ, 2, {YMM_L16,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41096, 207},
+    /* 3920 */ {I_VPERMD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41103, 207},
+    /* 3921 */ {I_VPERMD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41110, 207},
+    /* 3922 */ {I_VPERMPD, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16088, 207},
+    /* 3923 */ {I_VPERMPS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41117, 207},
+    /* 3924 */ {I_VPERMPS, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41124, 207},
+    /* 3925 */ {I_VPERMQ, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16096, 207},
+    /* 3926 */ {I_VPERM2I128, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16104, 207},
+    /* 3927 */ {I_VPERM2I128, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16112, 207},
+    /* 3928 */ {I_VEXTRACTI128, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16120, 207},
+    /* 3929 */ {I_VINSERTI128, 4, {YMM_L16,YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+16128, 207},
+    /* 3930 */ {I_VINSERTI128, 3, {YMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16136, 207},
+    /* 3931 */ {I_VPMASKMOVD, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41131, 207},
+    /* 3932 */ {I_VPMASKMOVD, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41138, 207},
+    /* 3933 */ {I_VPMASKMOVD, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41145, 207},
+    /* 3934 */ {I_VPMASKMOVD, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41152, 207},
+    /* 3935 */ {I_VPMASKMOVQ, 3, {XMM_L16,XMM_L16,MEMORY|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41159, 207},
+    /* 3936 */ {I_VPMASKMOVQ, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41166, 207},
+    /* 3937 */ {I_VPMASKMOVQ, 3, {YMM_L16,YMM_L16,MEMORY|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41173, 207},
+    /* 3938 */ {I_VPMASKMOVQ, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41180, 207},
+    /* 3939 */ {I_VPMASKMOVD, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41187, 207},
+    /* 3940 */ {I_VPMASKMOVD, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41194, 207},
+    /* 3941 */ {I_VPMASKMOVD, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41201, 207},
+    /* 3942 */ {I_VPMASKMOVD, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41208, 207},
+    /* 3943 */ {I_VPMASKMOVQ, 3, {MEMORY|BITS128,XMM_L16,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41215, 207},
+    /* 3944 */ {I_VPMASKMOVQ, 2, {MEMORY|BITS128,XMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41222, 207},
+    /* 3945 */ {I_VPMASKMOVQ, 3, {MEMORY|BITS256,YMM_L16,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+41229, 207},
+    /* 3946 */ {I_VPMASKMOVQ, 2, {MEMORY|BITS256,YMM_L16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41236, 207},
+    /* 3947 */ {I_VPSLLVD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41243, 207},
+    /* 3948 */ {I_VPSLLVD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41250, 207},
+    /* 3949 */ {I_VPSLLVQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41257, 207},
+    /* 3950 */ {I_VPSLLVQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41264, 207},
+    /* 3951 */ {I_VPSLLVD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41271, 207},
+    /* 3952 */ {I_VPSLLVD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41278, 207},
+    /* 3953 */ {I_VPSLLVQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41285, 207},
+    /* 3954 */ {I_VPSLLVQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41292, 207},
+    /* 3955 */ {I_VPSRAVD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41299, 207},
+    /* 3956 */ {I_VPSRAVD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41306, 207},
+    /* 3957 */ {I_VPSRAVD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41313, 207},
+    /* 3958 */ {I_VPSRAVD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41320, 207},
+    /* 3959 */ {I_VPSRLVD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41327, 207},
+    /* 3960 */ {I_VPSRLVD, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41334, 207},
+    /* 3961 */ {I_VPSRLVQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41341, 207},
+    /* 3962 */ {I_VPSRLVQ, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41348, 207},
+    /* 3963 */ {I_VPSRLVD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41355, 207},
+    /* 3964 */ {I_VPSRLVD, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41362, 207},
+    /* 3965 */ {I_VPSRLVQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41369, 207},
+    /* 3966 */ {I_VPSRLVQ, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41376, 207},
+    /* 3967 */ {I_VGATHERDPD, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16144, 207},
+    /* 3968 */ {I_VGATHERQPD, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16152, 207},
+    /* 3969 */ {I_VGATHERDPD, 3, {YMM_L16,XMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16160, 207},
+    /* 3970 */ {I_VGATHERQPD, 3, {YMM_L16,YMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16168, 207},
+    /* 3971 */ {I_VGATHERDPS, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16176, 207},
+    /* 3972 */ {I_VGATHERQPS, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16184, 207},
+    /* 3973 */ {I_VGATHERDPS, 3, {YMM_L16,YMEM|BITS32,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16192, 207},
+    /* 3974 */ {I_VGATHERQPS, 3, {XMM_L16,YMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16200, 207},
+    /* 3975 */ {I_VPGATHERDD, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16208, 207},
+    /* 3976 */ {I_VPGATHERQD, 3, {XMM_L16,XMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16216, 207},
+    /* 3977 */ {I_VPGATHERDD, 3, {YMM_L16,YMEM|BITS32,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16224, 207},
+    /* 3978 */ {I_VPGATHERQD, 3, {XMM_L16,YMEM|BITS32,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16232, 207},
+    /* 3979 */ {I_VPGATHERDQ, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16240, 207},
+    /* 3980 */ {I_VPGATHERQQ, 3, {XMM_L16,XMEM|BITS64,XMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16248, 207},
+    /* 3981 */ {I_VPGATHERDQ, 3, {YMM_L16,XMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16256, 207},
+    /* 3982 */ {I_VPGATHERQQ, 3, {YMM_L16,YMEM|BITS64,YMM_L16,0,0}, NO_DECORATOR, nasm_bytecodes+16264, 207},
+    /* 3983 */ {I_XABORT, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49162, 208},
+    /* 3984 */ {I_XABORT, 1, {IMMEDIATE|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49162, 208},
+    /* 3985 */ {I_XBEGIN, 1, {IMMEDIATE,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45855, 208},
+    /* 3986 */ {I_XBEGIN, 1, {IMMEDIATE|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45861, 209},
+    /* 3987 */ {I_XBEGIN, 1, {IMMEDIATE|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45867, 209},
+    /* 3988 */ {I_XBEGIN, 1, {IMMEDIATE|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45873, 210},
+    /* 3989 */ {I_XEND, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49167, 208},
+    /* 3990 */ {I_XTEST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49172, 211},
+    /* 3991 */ {I_ANDN, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41383, 212},
+    /* 3992 */ {I_ANDN, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41390, 213},
+    /* 3993 */ {I_BEXTR, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41397, 212},
+    /* 3994 */ {I_BEXTR, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41404, 213},
+    /* 3995 */ {I_BEXTR, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+16272, 214},
+    /* 3996 */ {I_BEXTR, 3, {REG_GPR|BITS64,RM_GPR|BITS64,IMMEDIATE|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+16280, 215},
+    /* 3997 */ {I_BLCI, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41411, 214},
+    /* 3998 */ {I_BLCI, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41418, 215},
+    /* 3999 */ {I_BLCIC, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41425, 214},
+    /* 4000 */ {I_BLCIC, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41432, 215},
+    /* 4001 */ {I_BLSI, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41439, 212},
+    /* 4002 */ {I_BLSI, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41446, 213},
+    /* 4003 */ {I_BLSIC, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41453, 214},
+    /* 4004 */ {I_BLSIC, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41460, 215},
+    /* 4005 */ {I_BLCFILL, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41467, 214},
+    /* 4006 */ {I_BLCFILL, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41474, 215},
+    /* 4007 */ {I_BLSFILL, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41481, 214},
+    /* 4008 */ {I_BLSFILL, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41488, 215},
+    /* 4009 */ {I_BLCMSK, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41495, 214},
+    /* 4010 */ {I_BLCMSK, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41502, 215},
+    /* 4011 */ {I_BLSMSK, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41509, 212},
+    /* 4012 */ {I_BLSMSK, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41516, 213},
+    /* 4013 */ {I_BLSR, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41523, 212},
+    /* 4014 */ {I_BLSR, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41530, 213},
+    /* 4015 */ {I_BLCS, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41537, 214},
+    /* 4016 */ {I_BLCS, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41544, 215},
+    /* 4017 */ {I_BZHI, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41551, 216},
+    /* 4018 */ {I_BZHI, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41558, 217},
+    /* 4019 */ {I_MULX, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41565, 216},
+    /* 4020 */ {I_MULX, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41572, 217},
+    /* 4021 */ {I_PDEP, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41579, 216},
+    /* 4022 */ {I_PDEP, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41586, 217},
+    /* 4023 */ {I_PEXT, 3, {REG_GPR|BITS32,REG_GPR|BITS32,RM_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41593, 216},
+    /* 4024 */ {I_PEXT, 3, {REG_GPR|BITS64,REG_GPR|BITS64,RM_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41600, 217},
+    /* 4025 */ {I_RORX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16288, 216},
+    /* 4026 */ {I_RORX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16296, 217},
+    /* 4027 */ {I_SARX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41607, 216},
+    /* 4028 */ {I_SARX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41614, 217},
+    /* 4029 */ {I_SHLX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41621, 216},
+    /* 4030 */ {I_SHLX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41628, 217},
+    /* 4031 */ {I_SHRX, 3, {REG_GPR|BITS32,RM_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+41635, 216},
+    /* 4032 */ {I_SHRX, 3, {REG_GPR|BITS64,RM_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+41642, 217},
+    /* 4033 */ {I_TZCNT, 2, {REG_GPR|BITS16,RM_GPR|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41649, 218},
+    /* 4034 */ {I_TZCNT, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41656, 218},
+    /* 4035 */ {I_TZCNT, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41663, 219},
+    /* 4036 */ {I_TZMSK, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41670, 214},
+    /* 4037 */ {I_TZMSK, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41677, 215},
+    /* 4038 */ {I_T1MSKC, 2, {REG_GPR|BITS32,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41684, 214},
+    /* 4039 */ {I_T1MSKC, 2, {REG_GPR|BITS64,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41691, 215},
+    /* 4040 */ {I_PREFETCHWT1, 1, {MEMORY|BITS8,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49177, 220},
+    /* 4041 */ {I_BNDMK, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45879, 221},
+    /* 4042 */ {I_BNDCL, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41699, 222},
+    /* 4043 */ {I_BNDCL, 2, {BNDREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41699, 223},
+    /* 4044 */ {I_BNDCL, 2, {BNDREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41698, 224},
+    /* 4045 */ {I_BNDCU, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41706, 222},
+    /* 4046 */ {I_BNDCU, 2, {BNDREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41706, 223},
+    /* 4047 */ {I_BNDCU, 2, {BNDREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41705, 224},
+    /* 4048 */ {I_BNDCN, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+41713, 222},
+    /* 4049 */ {I_BNDCN, 2, {BNDREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+41713, 223},
+    /* 4050 */ {I_BNDCN, 2, {BNDREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+41712, 224},
+    /* 4051 */ {I_BNDMOV, 2, {BNDREG,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45885, 222},
+    /* 4052 */ {I_BNDMOV, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45885, 222},
+    /* 4053 */ {I_BNDMOV, 2, {BNDREG,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45891, 222},
+    /* 4054 */ {I_BNDMOV, 2, {MEMORY,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45891, 222},
+    /* 4055 */ {I_BNDLDX, 2, {BNDREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+45886, 221},
+    /* 4056 */ {I_BNDLDX, 3, {BNDREG,MEMORY,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+45897, 225},
+    /* 4057 */ {I_BNDLDX, 3, {BNDREG,MEMORY,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+45897, 226},
+    /* 4058 */ {I_BNDSTX, 2, {MEMORY,BNDREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+45892, 221},
+    /* 4059 */ {I_BNDSTX, 3, {MEMORY,REG_GPR|BITS32,BNDREG,0,0}, NO_DECORATOR, nasm_bytecodes+45903, 225},
+    /* 4060 */ {I_BNDSTX, 3, {MEMORY,REG_GPR|BITS64,BNDREG,0,0}, NO_DECORATOR, nasm_bytecodes+45903, 226},
+    /* 4061 */ {I_BNDSTX, 3, {MEMORY,BNDREG,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+45909, 225},
+    /* 4062 */ {I_BNDSTX, 3, {MEMORY,BNDREG,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+45909, 226},
+    /* 4063 */ {I_SHA1MSG1, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45915, 227},
+    /* 4064 */ {I_SHA1MSG2, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45921, 227},
+    /* 4065 */ {I_SHA1NEXTE, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45927, 227},
+    /* 4066 */ {I_SHA1RNDS4, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+41719, 227},
+    /* 4067 */ {I_SHA256MSG1, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45933, 227},
+    /* 4068 */ {I_SHA256MSG2, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45939, 227},
+    /* 4069 */ {I_SHA256RNDS2, 3, {XMM_L16,RM_XMM_L16|BITS128,XMM0,0,0}, NO_DECORATOR, nasm_bytecodes+45945, 227},
+    /* 4070 */ {I_SHA256RNDS2, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+45945, 227},
+    /* 4071 */ {I_VBCSTNEBF16PS, 2, {XMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41726, 228},
+    /* 4072 */ {I_VBCSTNEBF16PS, 2, {YMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41733, 228},
+    /* 4073 */ {I_VBCSTNESH2PS, 2, {XMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41740, 228},
+    /* 4074 */ {I_VBCSTNESH2PS, 2, {YMM_L16,MEMORY|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+41747, 228},
+    /* 4075 */ {I_VCVTNEEBF162PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41754, 229},
+    /* 4076 */ {I_VCVTNEEBF162PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41761, 230},
+    /* 4077 */ {I_VCVTNEEPH2PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41768, 229},
+    /* 4078 */ {I_VCVTNEEPH2PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41775, 230},
+    /* 4079 */ {I_VCVTNEOBF162PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41782, 229},
+    /* 4080 */ {I_VCVTNEOBF162PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41789, 230},
+    /* 4081 */ {I_VCVTNEOPH2PS, 2, {XMM_L16,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41796, 229},
+    /* 4082 */ {I_VCVTNEOPH2PS, 2, {YMM_L16,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41803, 230},
+    /* 4083 */ {I_VCVTNEPS2BF16, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+41810, 229},
+    /* 4084 */ {I_VCVTNEPS2BF16, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+41817, 230},
+    /* 4085 */ {I_VPDPBSSD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41824, 231},
+    /* 4086 */ {I_VPDPBSSD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41831, 232},
+    /* 4087 */ {I_VPDPBSSDS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41838, 231},
+    /* 4088 */ {I_VPDPBSSDS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41845, 232},
+    /* 4089 */ {I_VPDPBSUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41852, 231},
+    /* 4090 */ {I_VPDPBSUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41859, 232},
+    /* 4091 */ {I_VPDPBSUDS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41866, 231},
+    /* 4092 */ {I_VPDPBSUDS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41873, 232},
+    /* 4093 */ {I_VPDPBUUD, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41880, 231},
+    /* 4094 */ {I_VPDPBUUD, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41887, 232},
+    /* 4095 */ {I_VPDPBUUDS, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41894, 231},
+    /* 4096 */ {I_VPDPBUUDS, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41901, 232},
+    /* 4097 */ {I_VPMADD52HUQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41908, 233},
+    /* 4098 */ {I_VPMADD52HUQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41915, 234},
+    /* 4099 */ {I_VPMADD52LUQ, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+41922, 233},
+    /* 4100 */ {I_VPMADD52LUQ, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+41929, 234},
+    /* 4101 */ {I_KADDB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41936, 235},
+    /* 4102 */ {I_KADDD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41943, 235},
+    /* 4103 */ {I_KADDQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41950, 235},
+    /* 4104 */ {I_KADDW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41957, 235},
+    /* 4105 */ {I_KANDB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41964, 235},
+    /* 4106 */ {I_KANDD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41971, 235},
+    /* 4107 */ {I_KANDNB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41978, 235},
+    /* 4108 */ {I_KANDND, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41985, 235},
+    /* 4109 */ {I_KANDNQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41992, 235},
+    /* 4110 */ {I_KANDNW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+41999, 235},
+    /* 4111 */ {I_KANDQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42006, 235},
+    /* 4112 */ {I_KANDW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42013, 235},
+    /* 4113 */ {I_KMOVB, 2, {KREG,RM_K|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+42020, 235},
+    /* 4114 */ {I_KMOVB, 2, {MEMORY|BITS8,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42027, 235},
+    /* 4115 */ {I_KMOVB, 2, {KREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42034, 235},
+    /* 4116 */ {I_KMOVB, 2, {REG_GPR|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42041, 235},
+    /* 4117 */ {I_KMOVD, 2, {KREG,RM_K|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42048, 235},
+    /* 4118 */ {I_KMOVD, 2, {MEMORY|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42055, 235},
+    /* 4119 */ {I_KMOVD, 2, {KREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42062, 235},
+    /* 4120 */ {I_KMOVD, 2, {REG_GPR|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42069, 235},
+    /* 4121 */ {I_KMOVQ, 2, {KREG,RM_K|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42076, 235},
+    /* 4122 */ {I_KMOVQ, 2, {MEMORY|BITS64,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42083, 235},
+    /* 4123 */ {I_KMOVQ, 2, {KREG,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42090, 235},
+    /* 4124 */ {I_KMOVQ, 2, {REG_GPR|BITS64,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42097, 235},
+    /* 4125 */ {I_KMOVW, 2, {KREG,RM_K|BITS16,0,0,0}, NO_DECORATOR, nasm_bytecodes+42104, 235},
+    /* 4126 */ {I_KMOVW, 2, {MEMORY|BITS16,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42111, 235},
+    /* 4127 */ {I_KMOVW, 2, {KREG,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42118, 235},
+    /* 4128 */ {I_KMOVW, 2, {REG_GPR|BITS32,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42125, 235},
+    /* 4129 */ {I_KNOTB, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42132, 235},
+    /* 4130 */ {I_KNOTD, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42139, 235},
+    /* 4131 */ {I_KNOTQ, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42146, 235},
+    /* 4132 */ {I_KNOTW, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42153, 235},
+    /* 4133 */ {I_KORB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42160, 235},
+    /* 4134 */ {I_KORD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42167, 235},
+    /* 4135 */ {I_KORQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42174, 235},
+    /* 4136 */ {I_KORW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42181, 235},
+    /* 4137 */ {I_KORTESTB, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42188, 235},
+    /* 4138 */ {I_KORTESTD, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42195, 235},
+    /* 4139 */ {I_KORTESTQ, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42202, 235},
+    /* 4140 */ {I_KORTESTW, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42209, 235},
+    /* 4141 */ {I_KSHIFTLB, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16312, 235},
+    /* 4142 */ {I_KSHIFTLD, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16320, 235},
+    /* 4143 */ {I_KSHIFTLQ, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16328, 235},
+    /* 4144 */ {I_KSHIFTLW, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16336, 235},
+    /* 4145 */ {I_KSHIFTRB, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16344, 235},
+    /* 4146 */ {I_KSHIFTRD, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16352, 235},
+    /* 4147 */ {I_KSHIFTRQ, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16360, 235},
+    /* 4148 */ {I_KSHIFTRW, 3, {KREG,KREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+16368, 235},
+    /* 4149 */ {I_KTESTB, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42216, 235},
+    /* 4150 */ {I_KTESTD, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42223, 235},
+    /* 4151 */ {I_KTESTQ, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42230, 235},
+    /* 4152 */ {I_KTESTW, 2, {KREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42237, 235},
+    /* 4153 */ {I_KUNPCKBW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42244, 235},
+    /* 4154 */ {I_KUNPCKDQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42251, 235},
+    /* 4155 */ {I_KUNPCKWD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42258, 235},
+    /* 4156 */ {I_KXNORB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42265, 235},
+    /* 4157 */ {I_KXNORD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42272, 235},
+    /* 4158 */ {I_KXNORQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42279, 235},
+    /* 4159 */ {I_KXNORW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42286, 235},
+    /* 4160 */ {I_KXORB, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42293, 235},
+    /* 4161 */ {I_KXORD, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42300, 235},
+    /* 4162 */ {I_KXORQ, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42307, 235},
+    /* 4163 */ {I_KXORW, 3, {KREG,KREG,KREG,0,0}, NO_DECORATOR, nasm_bytecodes+42314, 235},
+    /* 4164 */ {I_VADDPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16376, 240},
+    /* 4165 */ {I_VADDPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16384, 240},
+    /* 4166 */ {I_VADDPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16392, 240},
+    /* 4167 */ {I_VADDPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16400, 240},
+    /* 4168 */ {I_VADDPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+16408, 241},
+    /* 4169 */ {I_VADDPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+16416, 241},
+    /* 4170 */ {I_VADDPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16424, 240},
+    /* 4171 */ {I_VADDPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16432, 240},
+    /* 4172 */ {I_VADDPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16440, 240},
+    /* 4173 */ {I_VADDPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16448, 240},
+    /* 4174 */ {I_VADDPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+16456, 241},
+    /* 4175 */ {I_VADDPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+16464, 241},
+    /* 4176 */ {I_VADDSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+16472, 241},
+    /* 4177 */ {I_VADDSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+16480, 241},
+    /* 4178 */ {I_VADDSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+16488, 241},
+    /* 4179 */ {I_VADDSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+16496, 241},
+    /* 4180 */ {I_VALIGND, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8002, 240},
+    /* 4181 */ {I_VALIGND, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8011, 240},
+    /* 4182 */ {I_VALIGND, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8020, 240},
+    /* 4183 */ {I_VALIGND, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8029, 240},
+    /* 4184 */ {I_VALIGND, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8038, 241},
+    /* 4185 */ {I_VALIGND, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8047, 241},
+    /* 4186 */ {I_VALIGNQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8056, 240},
+    /* 4187 */ {I_VALIGNQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8065, 240},
+    /* 4188 */ {I_VALIGNQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8074, 240},
+    /* 4189 */ {I_VALIGNQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8083, 240},
+    /* 4190 */ {I_VALIGNQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8092, 241},
+    /* 4191 */ {I_VALIGNQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8101, 241},
+    /* 4192 */ {I_VANDNPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16504, 242},
+    /* 4193 */ {I_VANDNPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16512, 242},
+    /* 4194 */ {I_VANDNPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16520, 242},
+    /* 4195 */ {I_VANDNPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16528, 242},
+    /* 4196 */ {I_VANDNPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16536, 243},
+    /* 4197 */ {I_VANDNPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16544, 243},
+    /* 4198 */ {I_VANDNPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16552, 242},
+    /* 4199 */ {I_VANDNPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16560, 242},
+    /* 4200 */ {I_VANDNPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16568, 242},
+    /* 4201 */ {I_VANDNPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16576, 242},
+    /* 4202 */ {I_VANDNPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16584, 243},
+    /* 4203 */ {I_VANDNPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16592, 243},
+    /* 4204 */ {I_VANDPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16600, 242},
+    /* 4205 */ {I_VANDPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16608, 242},
+    /* 4206 */ {I_VANDPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16616, 242},
+    /* 4207 */ {I_VANDPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16624, 242},
+    /* 4208 */ {I_VANDPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16632, 243},
+    /* 4209 */ {I_VANDPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+16640, 243},
+    /* 4210 */ {I_VANDPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16648, 242},
+    /* 4211 */ {I_VANDPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16656, 242},
+    /* 4212 */ {I_VANDPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16664, 242},
+    /* 4213 */ {I_VANDPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16672, 242},
+    /* 4214 */ {I_VANDPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16680, 243},
+    /* 4215 */ {I_VANDPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+16688, 243},
+    /* 4216 */ {I_VBLENDMPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16696, 240},
+    /* 4217 */ {I_VBLENDMPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16704, 240},
+    /* 4218 */ {I_VBLENDMPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+16712, 241},
+    /* 4219 */ {I_VBLENDMPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16720, 240},
+    /* 4220 */ {I_VBLENDMPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16728, 240},
+    /* 4221 */ {I_VBLENDMPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+16736, 241},
+    /* 4222 */ {I_VBROADCASTF32X2, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16744, 242},
+    /* 4223 */ {I_VBROADCASTF32X2, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16752, 243},
+    /* 4224 */ {I_VBROADCASTF32X4, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16760, 240},
+    /* 4225 */ {I_VBROADCASTF32X4, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16768, 241},
+    /* 4226 */ {I_VBROADCASTF32X8, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16776, 243},
+    /* 4227 */ {I_VBROADCASTF64X2, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16784, 242},
+    /* 4228 */ {I_VBROADCASTF64X2, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16792, 243},
+    /* 4229 */ {I_VBROADCASTF64X4, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16800, 241},
+    /* 4230 */ {I_VBROADCASTI32X2, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16808, 242},
+    /* 4231 */ {I_VBROADCASTI32X2, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16816, 242},
+    /* 4232 */ {I_VBROADCASTI32X2, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16824, 243},
+    /* 4233 */ {I_VBROADCASTI32X4, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16832, 240},
+    /* 4234 */ {I_VBROADCASTI32X4, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16840, 241},
+    /* 4235 */ {I_VBROADCASTI32X8, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16848, 243},
+    /* 4236 */ {I_VBROADCASTI64X2, 2, {YMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16856, 242},
+    /* 4237 */ {I_VBROADCASTI64X2, 2, {ZMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16864, 243},
+    /* 4238 */ {I_VBROADCASTI64X4, 2, {ZMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16872, 241},
+    /* 4239 */ {I_VBROADCASTSD, 2, {YMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16880, 240},
+    /* 4240 */ {I_VBROADCASTSD, 2, {ZMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16888, 241},
+    /* 4241 */ {I_VBROADCASTSD, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16896, 240},
+    /* 4242 */ {I_VBROADCASTSD, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16904, 241},
+    /* 4243 */ {I_VBROADCASTSS, 2, {XMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16912, 240},
+    /* 4244 */ {I_VBROADCASTSS, 2, {YMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16920, 240},
+    /* 4245 */ {I_VBROADCASTSS, 2, {ZMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16928, 241},
+    /* 4246 */ {I_VBROADCASTSS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16936, 240},
+    /* 4247 */ {I_VBROADCASTSS, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16944, 240},
+    /* 4248 */ {I_VBROADCASTSS, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+16952, 241},
+    /* 4249 */ {I_VCMPEQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+240, 240},
+    /* 4250 */ {I_VCMPEQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+250, 240},
+    /* 4251 */ {I_VCMPEQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+260, 241},
+    /* 4252 */ {I_VCMPEQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+270, 240},
+    /* 4253 */ {I_VCMPEQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+280, 240},
+    /* 4254 */ {I_VCMPEQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+290, 241},
+    /* 4255 */ {I_VCMPEQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+300, 241},
+    /* 4256 */ {I_VCMPEQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+310, 241},
+    /* 4257 */ {I_VCMPEQ_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+240, 240},
+    /* 4258 */ {I_VCMPEQ_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+250, 240},
+    /* 4259 */ {I_VCMPEQ_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+260, 241},
+    /* 4260 */ {I_VCMPEQ_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+270, 240},
+    /* 4261 */ {I_VCMPEQ_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+280, 240},
+    /* 4262 */ {I_VCMPEQ_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+290, 241},
+    /* 4263 */ {I_VCMPEQ_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+300, 241},
+    /* 4264 */ {I_VCMPEQ_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+310, 241},
+    /* 4265 */ {I_VCMPLTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+320, 240},
+    /* 4266 */ {I_VCMPLTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+330, 240},
+    /* 4267 */ {I_VCMPLTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+340, 241},
+    /* 4268 */ {I_VCMPLTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+350, 240},
+    /* 4269 */ {I_VCMPLTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+360, 240},
+    /* 4270 */ {I_VCMPLTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+370, 241},
+    /* 4271 */ {I_VCMPLTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+380, 241},
+    /* 4272 */ {I_VCMPLTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+390, 241},
+    /* 4273 */ {I_VCMPLT_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+320, 240},
+    /* 4274 */ {I_VCMPLT_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+330, 240},
+    /* 4275 */ {I_VCMPLT_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+340, 241},
+    /* 4276 */ {I_VCMPLT_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+350, 240},
+    /* 4277 */ {I_VCMPLT_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+360, 240},
+    /* 4278 */ {I_VCMPLT_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+370, 241},
+    /* 4279 */ {I_VCMPLT_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+380, 241},
+    /* 4280 */ {I_VCMPLT_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+390, 241},
+    /* 4281 */ {I_VCMPLEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+400, 240},
+    /* 4282 */ {I_VCMPLEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+410, 240},
+    /* 4283 */ {I_VCMPLEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+420, 241},
+    /* 4284 */ {I_VCMPLEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+430, 240},
+    /* 4285 */ {I_VCMPLEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+440, 240},
+    /* 4286 */ {I_VCMPLEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+450, 241},
+    /* 4287 */ {I_VCMPLESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+460, 241},
+    /* 4288 */ {I_VCMPLESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+470, 241},
+    /* 4289 */ {I_VCMPLE_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+400, 240},
+    /* 4290 */ {I_VCMPLE_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+410, 240},
+    /* 4291 */ {I_VCMPLE_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+420, 241},
+    /* 4292 */ {I_VCMPLE_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+430, 240},
+    /* 4293 */ {I_VCMPLE_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+440, 240},
+    /* 4294 */ {I_VCMPLE_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+450, 241},
+    /* 4295 */ {I_VCMPLE_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+460, 241},
+    /* 4296 */ {I_VCMPLE_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+470, 241},
+    /* 4297 */ {I_VCMPUNORDPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+480, 240},
+    /* 4298 */ {I_VCMPUNORDPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+490, 240},
+    /* 4299 */ {I_VCMPUNORDPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+500, 241},
+    /* 4300 */ {I_VCMPUNORDPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+510, 240},
+    /* 4301 */ {I_VCMPUNORDPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+520, 240},
+    /* 4302 */ {I_VCMPUNORDPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+530, 241},
+    /* 4303 */ {I_VCMPUNORDSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+540, 241},
+    /* 4304 */ {I_VCMPUNORDSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+550, 241},
+    /* 4305 */ {I_VCMPUNORD_QPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+480, 240},
+    /* 4306 */ {I_VCMPUNORD_QPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+490, 240},
+    /* 4307 */ {I_VCMPUNORD_QPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+500, 241},
+    /* 4308 */ {I_VCMPUNORD_QPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+510, 240},
+    /* 4309 */ {I_VCMPUNORD_QPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+520, 240},
+    /* 4310 */ {I_VCMPUNORD_QPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+530, 241},
+    /* 4311 */ {I_VCMPUNORD_QSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+540, 241},
+    /* 4312 */ {I_VCMPUNORD_QSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+550, 241},
+    /* 4313 */ {I_VCMPNEQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+560, 240},
+    /* 4314 */ {I_VCMPNEQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+570, 240},
+    /* 4315 */ {I_VCMPNEQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+580, 241},
+    /* 4316 */ {I_VCMPNEQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+590, 240},
+    /* 4317 */ {I_VCMPNEQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+600, 240},
+    /* 4318 */ {I_VCMPNEQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+610, 241},
+    /* 4319 */ {I_VCMPNEQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+620, 241},
+    /* 4320 */ {I_VCMPNEQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+630, 241},
+    /* 4321 */ {I_VCMPNEQ_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+560, 240},
+    /* 4322 */ {I_VCMPNEQ_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+570, 240},
+    /* 4323 */ {I_VCMPNEQ_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+580, 241},
+    /* 4324 */ {I_VCMPNEQ_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+590, 240},
+    /* 4325 */ {I_VCMPNEQ_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+600, 240},
+    /* 4326 */ {I_VCMPNEQ_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+610, 241},
+    /* 4327 */ {I_VCMPNEQ_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+620, 241},
+    /* 4328 */ {I_VCMPNEQ_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+630, 241},
+    /* 4329 */ {I_VCMPNLTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+640, 240},
+    /* 4330 */ {I_VCMPNLTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+650, 240},
+    /* 4331 */ {I_VCMPNLTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+660, 241},
+    /* 4332 */ {I_VCMPNLTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+670, 240},
+    /* 4333 */ {I_VCMPNLTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+680, 240},
+    /* 4334 */ {I_VCMPNLTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+690, 241},
+    /* 4335 */ {I_VCMPNLTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+700, 241},
+    /* 4336 */ {I_VCMPNLTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+710, 241},
+    /* 4337 */ {I_VCMPNLT_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+640, 240},
+    /* 4338 */ {I_VCMPNLT_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+650, 240},
+    /* 4339 */ {I_VCMPNLT_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+660, 241},
+    /* 4340 */ {I_VCMPNLT_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+670, 240},
+    /* 4341 */ {I_VCMPNLT_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+680, 240},
+    /* 4342 */ {I_VCMPNLT_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+690, 241},
+    /* 4343 */ {I_VCMPNLT_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+700, 241},
+    /* 4344 */ {I_VCMPNLT_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+710, 241},
+    /* 4345 */ {I_VCMPNLEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+720, 240},
+    /* 4346 */ {I_VCMPNLEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+730, 240},
+    /* 4347 */ {I_VCMPNLEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+740, 241},
+    /* 4348 */ {I_VCMPNLEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+750, 240},
+    /* 4349 */ {I_VCMPNLEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+760, 240},
+    /* 4350 */ {I_VCMPNLEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+770, 241},
+    /* 4351 */ {I_VCMPNLESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+780, 241},
+    /* 4352 */ {I_VCMPNLESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+790, 241},
+    /* 4353 */ {I_VCMPNLE_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+720, 240},
+    /* 4354 */ {I_VCMPNLE_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+730, 240},
+    /* 4355 */ {I_VCMPNLE_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+740, 241},
+    /* 4356 */ {I_VCMPNLE_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+750, 240},
+    /* 4357 */ {I_VCMPNLE_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+760, 240},
+    /* 4358 */ {I_VCMPNLE_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+770, 241},
+    /* 4359 */ {I_VCMPNLE_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+780, 241},
+    /* 4360 */ {I_VCMPNLE_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+790, 241},
+    /* 4361 */ {I_VCMPORDPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+800, 240},
+    /* 4362 */ {I_VCMPORDPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+810, 240},
+    /* 4363 */ {I_VCMPORDPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+820, 241},
+    /* 4364 */ {I_VCMPORDPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+830, 240},
+    /* 4365 */ {I_VCMPORDPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+840, 240},
+    /* 4366 */ {I_VCMPORDPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+850, 241},
+    /* 4367 */ {I_VCMPORDSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+860, 241},
+    /* 4368 */ {I_VCMPORDSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+870, 241},
+    /* 4369 */ {I_VCMPORD_QPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+800, 240},
+    /* 4370 */ {I_VCMPORD_QPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+810, 240},
+    /* 4371 */ {I_VCMPORD_QPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+820, 241},
+    /* 4372 */ {I_VCMPORD_QPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+830, 240},
+    /* 4373 */ {I_VCMPORD_QPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+840, 240},
+    /* 4374 */ {I_VCMPORD_QPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+850, 241},
+    /* 4375 */ {I_VCMPORD_QSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+860, 241},
+    /* 4376 */ {I_VCMPORD_QSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+870, 241},
+    /* 4377 */ {I_VCMPEQ_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+880, 240},
+    /* 4378 */ {I_VCMPEQ_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+890, 240},
+    /* 4379 */ {I_VCMPEQ_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+900, 241},
+    /* 4380 */ {I_VCMPEQ_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+910, 240},
+    /* 4381 */ {I_VCMPEQ_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+920, 240},
+    /* 4382 */ {I_VCMPEQ_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+930, 241},
+    /* 4383 */ {I_VCMPEQ_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+940, 241},
+    /* 4384 */ {I_VCMPEQ_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+950, 241},
+    /* 4385 */ {I_VCMPNGEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+960, 240},
+    /* 4386 */ {I_VCMPNGEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+970, 240},
+    /* 4387 */ {I_VCMPNGEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+980, 241},
+    /* 4388 */ {I_VCMPNGEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+990, 240},
+    /* 4389 */ {I_VCMPNGEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1000, 240},
+    /* 4390 */ {I_VCMPNGEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1010, 241},
+    /* 4391 */ {I_VCMPNGESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1020, 241},
+    /* 4392 */ {I_VCMPNGESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1030, 241},
+    /* 4393 */ {I_VCMPNGE_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+960, 240},
+    /* 4394 */ {I_VCMPNGE_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+970, 240},
+    /* 4395 */ {I_VCMPNGE_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+980, 241},
+    /* 4396 */ {I_VCMPNGE_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+990, 240},
+    /* 4397 */ {I_VCMPNGE_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1000, 240},
+    /* 4398 */ {I_VCMPNGE_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1010, 241},
+    /* 4399 */ {I_VCMPNGE_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1020, 241},
+    /* 4400 */ {I_VCMPNGE_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1030, 241},
+    /* 4401 */ {I_VCMPNGTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1040, 240},
+    /* 4402 */ {I_VCMPNGTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1050, 240},
+    /* 4403 */ {I_VCMPNGTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1060, 241},
+    /* 4404 */ {I_VCMPNGTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1070, 240},
+    /* 4405 */ {I_VCMPNGTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1080, 240},
+    /* 4406 */ {I_VCMPNGTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1090, 241},
+    /* 4407 */ {I_VCMPNGTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1100, 241},
+    /* 4408 */ {I_VCMPNGTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1110, 241},
+    /* 4409 */ {I_VCMPNGT_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1040, 240},
+    /* 4410 */ {I_VCMPNGT_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1050, 240},
+    /* 4411 */ {I_VCMPNGT_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1060, 241},
+    /* 4412 */ {I_VCMPNGT_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1070, 240},
+    /* 4413 */ {I_VCMPNGT_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1080, 240},
+    /* 4414 */ {I_VCMPNGT_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1090, 241},
+    /* 4415 */ {I_VCMPNGT_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1100, 241},
+    /* 4416 */ {I_VCMPNGT_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1110, 241},
+    /* 4417 */ {I_VCMPFALSEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1120, 240},
+    /* 4418 */ {I_VCMPFALSEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1130, 240},
+    /* 4419 */ {I_VCMPFALSEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1140, 241},
+    /* 4420 */ {I_VCMPFALSEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1150, 240},
+    /* 4421 */ {I_VCMPFALSEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1160, 240},
+    /* 4422 */ {I_VCMPFALSEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1170, 241},
+    /* 4423 */ {I_VCMPFALSESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1180, 241},
+    /* 4424 */ {I_VCMPFALSESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1190, 241},
+    /* 4425 */ {I_VCMPFALSE_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1120, 240},
+    /* 4426 */ {I_VCMPFALSE_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1130, 240},
+    /* 4427 */ {I_VCMPFALSE_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1140, 241},
+    /* 4428 */ {I_VCMPFALSE_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1150, 240},
+    /* 4429 */ {I_VCMPFALSE_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1160, 240},
+    /* 4430 */ {I_VCMPFALSE_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1170, 241},
+    /* 4431 */ {I_VCMPFALSE_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1180, 241},
+    /* 4432 */ {I_VCMPFALSE_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1190, 241},
+    /* 4433 */ {I_VCMPNEQ_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1200, 240},
+    /* 4434 */ {I_VCMPNEQ_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1210, 240},
+    /* 4435 */ {I_VCMPNEQ_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1220, 241},
+    /* 4436 */ {I_VCMPNEQ_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1230, 240},
+    /* 4437 */ {I_VCMPNEQ_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1240, 240},
+    /* 4438 */ {I_VCMPNEQ_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1250, 241},
+    /* 4439 */ {I_VCMPNEQ_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1260, 241},
+    /* 4440 */ {I_VCMPNEQ_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1270, 241},
+    /* 4441 */ {I_VCMPGEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1280, 240},
+    /* 4442 */ {I_VCMPGEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1290, 240},
+    /* 4443 */ {I_VCMPGEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1300, 241},
+    /* 4444 */ {I_VCMPGEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1310, 240},
+    /* 4445 */ {I_VCMPGEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1320, 240},
+    /* 4446 */ {I_VCMPGEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1330, 241},
+    /* 4447 */ {I_VCMPGESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1340, 241},
+    /* 4448 */ {I_VCMPGESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1350, 241},
+    /* 4449 */ {I_VCMPGE_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1280, 240},
+    /* 4450 */ {I_VCMPGE_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1290, 240},
+    /* 4451 */ {I_VCMPGE_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1300, 241},
+    /* 4452 */ {I_VCMPGE_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1310, 240},
+    /* 4453 */ {I_VCMPGE_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1320, 240},
+    /* 4454 */ {I_VCMPGE_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1330, 241},
+    /* 4455 */ {I_VCMPGE_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1340, 241},
+    /* 4456 */ {I_VCMPGE_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1350, 241},
+    /* 4457 */ {I_VCMPGTPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1360, 240},
+    /* 4458 */ {I_VCMPGTPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1370, 240},
+    /* 4459 */ {I_VCMPGTPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1380, 241},
+    /* 4460 */ {I_VCMPGTPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1390, 240},
+    /* 4461 */ {I_VCMPGTPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1400, 240},
+    /* 4462 */ {I_VCMPGTPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1410, 241},
+    /* 4463 */ {I_VCMPGTSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1420, 241},
+    /* 4464 */ {I_VCMPGTSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1430, 241},
+    /* 4465 */ {I_VCMPGT_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1360, 240},
+    /* 4466 */ {I_VCMPGT_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1370, 240},
+    /* 4467 */ {I_VCMPGT_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1380, 241},
+    /* 4468 */ {I_VCMPGT_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1390, 240},
+    /* 4469 */ {I_VCMPGT_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1400, 240},
+    /* 4470 */ {I_VCMPGT_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1410, 241},
+    /* 4471 */ {I_VCMPGT_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1420, 241},
+    /* 4472 */ {I_VCMPGT_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1430, 241},
+    /* 4473 */ {I_VCMPTRUEPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1440, 240},
+    /* 4474 */ {I_VCMPTRUEPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1450, 240},
+    /* 4475 */ {I_VCMPTRUEPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1460, 241},
+    /* 4476 */ {I_VCMPTRUEPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1470, 240},
+    /* 4477 */ {I_VCMPTRUEPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1480, 240},
+    /* 4478 */ {I_VCMPTRUEPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1490, 241},
+    /* 4479 */ {I_VCMPTRUESD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1500, 241},
+    /* 4480 */ {I_VCMPTRUESS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1510, 241},
+    /* 4481 */ {I_VCMPTRUE_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1440, 240},
+    /* 4482 */ {I_VCMPTRUE_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1450, 240},
+    /* 4483 */ {I_VCMPTRUE_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1460, 241},
+    /* 4484 */ {I_VCMPTRUE_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1470, 240},
+    /* 4485 */ {I_VCMPTRUE_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1480, 240},
+    /* 4486 */ {I_VCMPTRUE_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1490, 241},
+    /* 4487 */ {I_VCMPTRUE_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1500, 241},
+    /* 4488 */ {I_VCMPTRUE_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1510, 241},
+    /* 4489 */ {I_VCMPEQ_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1520, 240},
+    /* 4490 */ {I_VCMPEQ_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1530, 240},
+    /* 4491 */ {I_VCMPEQ_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1540, 241},
+    /* 4492 */ {I_VCMPEQ_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1550, 240},
+    /* 4493 */ {I_VCMPEQ_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1560, 240},
+    /* 4494 */ {I_VCMPEQ_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1570, 241},
+    /* 4495 */ {I_VCMPEQ_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1580, 241},
+    /* 4496 */ {I_VCMPEQ_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1590, 241},
+    /* 4497 */ {I_VCMPLT_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1600, 240},
+    /* 4498 */ {I_VCMPLT_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1610, 240},
+    /* 4499 */ {I_VCMPLT_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1620, 241},
+    /* 4500 */ {I_VCMPLT_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1630, 240},
+    /* 4501 */ {I_VCMPLT_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1640, 240},
+    /* 4502 */ {I_VCMPLT_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1650, 241},
+    /* 4503 */ {I_VCMPLT_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1660, 241},
+    /* 4504 */ {I_VCMPLT_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1670, 241},
+    /* 4505 */ {I_VCMPLE_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1680, 240},
+    /* 4506 */ {I_VCMPLE_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1690, 240},
+    /* 4507 */ {I_VCMPLE_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1700, 241},
+    /* 4508 */ {I_VCMPLE_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1710, 240},
+    /* 4509 */ {I_VCMPLE_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1720, 240},
+    /* 4510 */ {I_VCMPLE_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1730, 241},
+    /* 4511 */ {I_VCMPLE_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1740, 241},
+    /* 4512 */ {I_VCMPLE_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1750, 241},
+    /* 4513 */ {I_VCMPUNORD_SPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1760, 240},
+    /* 4514 */ {I_VCMPUNORD_SPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1770, 240},
+    /* 4515 */ {I_VCMPUNORD_SPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1780, 241},
+    /* 4516 */ {I_VCMPUNORD_SPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1790, 240},
+    /* 4517 */ {I_VCMPUNORD_SPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1800, 240},
+    /* 4518 */ {I_VCMPUNORD_SPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1810, 241},
+    /* 4519 */ {I_VCMPUNORD_SSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1820, 241},
+    /* 4520 */ {I_VCMPUNORD_SSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1830, 241},
+    /* 4521 */ {I_VCMPNEQ_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1840, 240},
+    /* 4522 */ {I_VCMPNEQ_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1850, 240},
+    /* 4523 */ {I_VCMPNEQ_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1860, 241},
+    /* 4524 */ {I_VCMPNEQ_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1870, 240},
+    /* 4525 */ {I_VCMPNEQ_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1880, 240},
+    /* 4526 */ {I_VCMPNEQ_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1890, 241},
+    /* 4527 */ {I_VCMPNEQ_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1900, 241},
+    /* 4528 */ {I_VCMPNEQ_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1910, 241},
+    /* 4529 */ {I_VCMPNLT_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1920, 240},
+    /* 4530 */ {I_VCMPNLT_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+1930, 240},
+    /* 4531 */ {I_VCMPNLT_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+1940, 241},
+    /* 4532 */ {I_VCMPNLT_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1950, 240},
+    /* 4533 */ {I_VCMPNLT_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+1960, 240},
+    /* 4534 */ {I_VCMPNLT_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+1970, 241},
+    /* 4535 */ {I_VCMPNLT_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1980, 241},
+    /* 4536 */ {I_VCMPNLT_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+1990, 241},
+    /* 4537 */ {I_VCMPNLE_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2000, 240},
+    /* 4538 */ {I_VCMPNLE_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2010, 240},
+    /* 4539 */ {I_VCMPNLE_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2020, 241},
+    /* 4540 */ {I_VCMPNLE_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2030, 240},
+    /* 4541 */ {I_VCMPNLE_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2040, 240},
+    /* 4542 */ {I_VCMPNLE_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2050, 241},
+    /* 4543 */ {I_VCMPNLE_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2060, 241},
+    /* 4544 */ {I_VCMPNLE_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2070, 241},
+    /* 4545 */ {I_VCMPORD_SPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2080, 240},
+    /* 4546 */ {I_VCMPORD_SPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2090, 240},
+    /* 4547 */ {I_VCMPORD_SPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2100, 241},
+    /* 4548 */ {I_VCMPORD_SPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2110, 240},
+    /* 4549 */ {I_VCMPORD_SPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2120, 240},
+    /* 4550 */ {I_VCMPORD_SPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2130, 241},
+    /* 4551 */ {I_VCMPORD_SSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2140, 241},
+    /* 4552 */ {I_VCMPORD_SSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2150, 241},
+    /* 4553 */ {I_VCMPEQ_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2160, 240},
+    /* 4554 */ {I_VCMPEQ_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2170, 240},
+    /* 4555 */ {I_VCMPEQ_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2180, 241},
+    /* 4556 */ {I_VCMPEQ_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2190, 240},
+    /* 4557 */ {I_VCMPEQ_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2200, 240},
+    /* 4558 */ {I_VCMPEQ_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2210, 241},
+    /* 4559 */ {I_VCMPEQ_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2220, 241},
+    /* 4560 */ {I_VCMPEQ_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2230, 241},
+    /* 4561 */ {I_VCMPNGE_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2240, 240},
+    /* 4562 */ {I_VCMPNGE_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2250, 240},
+    /* 4563 */ {I_VCMPNGE_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2260, 241},
+    /* 4564 */ {I_VCMPNGE_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2270, 240},
+    /* 4565 */ {I_VCMPNGE_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2280, 240},
+    /* 4566 */ {I_VCMPNGE_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2290, 241},
+    /* 4567 */ {I_VCMPNGE_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2300, 241},
+    /* 4568 */ {I_VCMPNGE_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2310, 241},
+    /* 4569 */ {I_VCMPNGT_UQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2320, 240},
+    /* 4570 */ {I_VCMPNGT_UQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2330, 240},
+    /* 4571 */ {I_VCMPNGT_UQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2340, 241},
+    /* 4572 */ {I_VCMPNGT_UQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2350, 240},
+    /* 4573 */ {I_VCMPNGT_UQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2360, 240},
+    /* 4574 */ {I_VCMPNGT_UQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2370, 241},
+    /* 4575 */ {I_VCMPNGT_UQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2380, 241},
+    /* 4576 */ {I_VCMPNGT_UQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2390, 241},
+    /* 4577 */ {I_VCMPFALSE_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2400, 240},
+    /* 4578 */ {I_VCMPFALSE_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2410, 240},
+    /* 4579 */ {I_VCMPFALSE_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2420, 241},
+    /* 4580 */ {I_VCMPFALSE_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2430, 240},
+    /* 4581 */ {I_VCMPFALSE_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2440, 240},
+    /* 4582 */ {I_VCMPFALSE_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2450, 241},
+    /* 4583 */ {I_VCMPFALSE_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2460, 241},
+    /* 4584 */ {I_VCMPFALSE_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2470, 241},
+    /* 4585 */ {I_VCMPNEQ_OSPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2480, 240},
+    /* 4586 */ {I_VCMPNEQ_OSPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2490, 240},
+    /* 4587 */ {I_VCMPNEQ_OSPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2500, 241},
+    /* 4588 */ {I_VCMPNEQ_OSPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2510, 240},
+    /* 4589 */ {I_VCMPNEQ_OSPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2520, 240},
+    /* 4590 */ {I_VCMPNEQ_OSPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2530, 241},
+    /* 4591 */ {I_VCMPNEQ_OSSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2540, 241},
+    /* 4592 */ {I_VCMPNEQ_OSSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2550, 241},
+    /* 4593 */ {I_VCMPGE_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2560, 240},
+    /* 4594 */ {I_VCMPGE_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2570, 240},
+    /* 4595 */ {I_VCMPGE_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2580, 241},
+    /* 4596 */ {I_VCMPGE_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2590, 240},
+    /* 4597 */ {I_VCMPGE_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2600, 240},
+    /* 4598 */ {I_VCMPGE_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2610, 241},
+    /* 4599 */ {I_VCMPGE_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2620, 241},
+    /* 4600 */ {I_VCMPGE_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2630, 241},
+    /* 4601 */ {I_VCMPGT_OQPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2640, 240},
+    /* 4602 */ {I_VCMPGT_OQPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2650, 240},
+    /* 4603 */ {I_VCMPGT_OQPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2660, 241},
+    /* 4604 */ {I_VCMPGT_OQPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2670, 240},
+    /* 4605 */ {I_VCMPGT_OQPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2680, 240},
+    /* 4606 */ {I_VCMPGT_OQPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2690, 241},
+    /* 4607 */ {I_VCMPGT_OQSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2700, 241},
+    /* 4608 */ {I_VCMPGT_OQSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2710, 241},
+    /* 4609 */ {I_VCMPTRUE_USPD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2720, 240},
+    /* 4610 */ {I_VCMPTRUE_USPD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2730, 240},
+    /* 4611 */ {I_VCMPTRUE_USPD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+2740, 241},
+    /* 4612 */ {I_VCMPTRUE_USPS, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2750, 240},
+    /* 4613 */ {I_VCMPTRUE_USPS, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2760, 240},
+    /* 4614 */ {I_VCMPTRUE_USPS, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+2770, 241},
+    /* 4615 */ {I_VCMPTRUE_USSD, 3, {KREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2780, 241},
+    /* 4616 */ {I_VCMPTRUE_USSS, 3, {KREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+2790, 241},
+    /* 4617 */ {I_VCMPPD, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+8110, 240},
+    /* 4618 */ {I_VCMPPD, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+8119, 240},
+    /* 4619 */ {I_VCMPPD, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B64|SAE,0,0}, nasm_bytecodes+8128, 241},
+    /* 4620 */ {I_VCMPPS, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+8137, 240},
+    /* 4621 */ {I_VCMPPS, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+8146, 240},
+    /* 4622 */ {I_VCMPPS, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B32|SAE,0,0}, nasm_bytecodes+8155, 241},
+    /* 4623 */ {I_VCMPSD, 4, {KREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+8164, 241},
+    /* 4624 */ {I_VCMPSS, 4, {KREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+8173, 241},
+    /* 4625 */ {I_VCOMISD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+16960, 241},
+    /* 4626 */ {I_VCOMISS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+16968, 241},
+    /* 4627 */ {I_VCOMPRESSPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+16976, 240},
+    /* 4628 */ {I_VCOMPRESSPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+16984, 240},
+    /* 4629 */ {I_VCOMPRESSPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+16992, 241},
+    /* 4630 */ {I_VCOMPRESSPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17000, 240},
+    /* 4631 */ {I_VCOMPRESSPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17008, 240},
+    /* 4632 */ {I_VCOMPRESSPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17016, 241},
+    /* 4633 */ {I_VCOMPRESSPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+17024, 240},
+    /* 4634 */ {I_VCOMPRESSPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+17032, 240},
+    /* 4635 */ {I_VCOMPRESSPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+17040, 241},
+    /* 4636 */ {I_VCOMPRESSPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17048, 240},
+    /* 4637 */ {I_VCOMPRESSPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17056, 240},
+    /* 4638 */ {I_VCOMPRESSPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17064, 241},
+    /* 4639 */ {I_VCVTDQ2PD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17072, 240},
+    /* 4640 */ {I_VCVTDQ2PD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17080, 240},
+    /* 4641 */ {I_VCVTDQ2PD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17088, 241},
+    /* 4642 */ {I_VCVTDQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17096, 240},
+    /* 4643 */ {I_VCVTDQ2PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17104, 240},
+    /* 4644 */ {I_VCVTDQ2PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17112, 241},
+    /* 4645 */ {I_VCVTPD2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17120, 240},
+    /* 4646 */ {I_VCVTPD2DQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17128, 240},
+    /* 4647 */ {I_VCVTPD2DQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17136, 241},
+    /* 4648 */ {I_VCVTPD2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17144, 240},
+    /* 4649 */ {I_VCVTPD2PS, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17152, 240},
+    /* 4650 */ {I_VCVTPD2PS, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17160, 241},
+    /* 4651 */ {I_VCVTPD2QQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17168, 242},
+    /* 4652 */ {I_VCVTPD2QQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17176, 242},
+    /* 4653 */ {I_VCVTPD2QQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17184, 243},
+    /* 4654 */ {I_VCVTPD2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17192, 240},
+    /* 4655 */ {I_VCVTPD2UDQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17200, 240},
+    /* 4656 */ {I_VCVTPD2UDQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17208, 241},
+    /* 4657 */ {I_VCVTPD2UQQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17216, 242},
+    /* 4658 */ {I_VCVTPD2UQQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17224, 242},
+    /* 4659 */ {I_VCVTPD2UQQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17232, 243},
+    /* 4660 */ {I_VCVTPH2PS, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17240, 240},
+    /* 4661 */ {I_VCVTPH2PS, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17248, 240},
+    /* 4662 */ {I_VCVTPH2PS, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+17256, 241},
+    /* 4663 */ {I_VCVTPS2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17264, 240},
+    /* 4664 */ {I_VCVTPS2DQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17272, 240},
+    /* 4665 */ {I_VCVTPS2DQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17280, 241},
+    /* 4666 */ {I_VCVTPS2PD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17288, 240},
+    /* 4667 */ {I_VCVTPS2PD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17296, 240},
+    /* 4668 */ {I_VCVTPS2PD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17304, 241},
+    /* 4669 */ {I_VCVTPS2PH, 3, {XMMREG,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8182, 240},
+    /* 4670 */ {I_VCVTPS2PH, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8191, 240},
+    /* 4671 */ {I_VCVTPS2PH, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    /* 4672 */ {I_VCVTPS2PH, 3, {MEMORY|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8182, 240},
+    /* 4673 */ {I_VCVTPS2PH, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8191, 240},
+    /* 4674 */ {I_VCVTPS2PH, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    /* 4675 */ {I_VCVTPS2QQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17312, 242},
+    /* 4676 */ {I_VCVTPS2QQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17320, 242},
+    /* 4677 */ {I_VCVTPS2QQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17328, 243},
+    /* 4678 */ {I_VCVTPS2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17336, 240},
+    /* 4679 */ {I_VCVTPS2UDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17344, 240},
+    /* 4680 */ {I_VCVTPS2UDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17352, 241},
+    /* 4681 */ {I_VCVTPS2UQQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17360, 242},
+    /* 4682 */ {I_VCVTPS2UQQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17368, 242},
+    /* 4683 */ {I_VCVTPS2UQQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17376, 243},
+    /* 4684 */ {I_VCVTQQ2PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17384, 242},
+    /* 4685 */ {I_VCVTQQ2PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17392, 242},
+    /* 4686 */ {I_VCVTQQ2PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17400, 243},
+    /* 4687 */ {I_VCVTQQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17408, 242},
+    /* 4688 */ {I_VCVTQQ2PS, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17416, 242},
+    /* 4689 */ {I_VCVTQQ2PS, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17424, 243},
+    /* 4690 */ {I_VCVTSD2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17432, 241},
+    /* 4691 */ {I_VCVTSD2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17440, 241},
+    /* 4692 */ {I_VCVTSD2SS, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+17448, 241},
+    /* 4693 */ {I_VCVTSD2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17456, 241},
+    /* 4694 */ {I_VCVTSD2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17464, 241},
+    /* 4695 */ {I_VCVTSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17472, 241},
+    /* 4696 */ {I_VCVTSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17480, 241},
+    /* 4697 */ {I_VCVTSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17488, 241},
+    /* 4698 */ {I_VCVTSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17496, 241},
+    /* 4699 */ {I_VCVTSS2SD, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+17504, 241},
+    /* 4700 */ {I_VCVTSS2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17512, 241},
+    /* 4701 */ {I_VCVTSS2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17520, 241},
+    /* 4702 */ {I_VCVTSS2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17528, 241},
+    /* 4703 */ {I_VCVTSS2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17536, 241},
+    /* 4704 */ {I_VCVTTPD2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17544, 240},
+    /* 4705 */ {I_VCVTTPD2DQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17552, 240},
+    /* 4706 */ {I_VCVTTPD2DQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17560, 241},
+    /* 4707 */ {I_VCVTTPD2QQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17568, 242},
+    /* 4708 */ {I_VCVTTPD2QQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17576, 242},
+    /* 4709 */ {I_VCVTTPD2QQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17584, 243},
+    /* 4710 */ {I_VCVTTPD2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17592, 240},
+    /* 4711 */ {I_VCVTTPD2UDQ, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17600, 240},
+    /* 4712 */ {I_VCVTTPD2UDQ, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17608, 241},
+    /* 4713 */ {I_VCVTTPD2UQQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17616, 242},
+    /* 4714 */ {I_VCVTTPD2UQQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17624, 242},
+    /* 4715 */ {I_VCVTTPD2UQQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+17632, 243},
+    /* 4716 */ {I_VCVTTPS2DQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17640, 240},
+    /* 4717 */ {I_VCVTTPS2DQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17648, 240},
+    /* 4718 */ {I_VCVTTPS2DQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17656, 241},
+    /* 4719 */ {I_VCVTTPS2QQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17664, 242},
+    /* 4720 */ {I_VCVTTPS2QQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17672, 242},
+    /* 4721 */ {I_VCVTTPS2QQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17680, 243},
+    /* 4722 */ {I_VCVTTPS2UDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17688, 240},
+    /* 4723 */ {I_VCVTTPS2UDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17696, 240},
+    /* 4724 */ {I_VCVTTPS2UDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17704, 241},
+    /* 4725 */ {I_VCVTTPS2UQQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17712, 242},
+    /* 4726 */ {I_VCVTTPS2UQQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17720, 242},
+    /* 4727 */ {I_VCVTTPS2UQQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+17728, 243},
+    /* 4728 */ {I_VCVTTSD2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17736, 241},
+    /* 4729 */ {I_VCVTTSD2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17744, 241},
+    /* 4730 */ {I_VCVTTSD2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17752, 241},
+    /* 4731 */ {I_VCVTTSD2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17760, 241},
+    /* 4732 */ {I_VCVTTSS2SI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17768, 241},
+    /* 4733 */ {I_VCVTTSS2SI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17776, 241},
+    /* 4734 */ {I_VCVTTSS2USI, 2, {REG_GPR|BITS32,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17784, 241},
+    /* 4735 */ {I_VCVTTSS2USI, 2, {REG_GPR|BITS64,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+17792, 241},
+    /* 4736 */ {I_VCVTUDQ2PD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17800, 240},
+    /* 4737 */ {I_VCVTUDQ2PD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17808, 240},
+    /* 4738 */ {I_VCVTUDQ2PD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17816, 241},
+    /* 4739 */ {I_VCVTUDQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17824, 240},
+    /* 4740 */ {I_VCVTUDQ2PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17832, 240},
+    /* 4741 */ {I_VCVTUDQ2PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+17840, 241},
+    /* 4742 */ {I_VCVTUQQ2PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17848, 242},
+    /* 4743 */ {I_VCVTUQQ2PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17856, 242},
+    /* 4744 */ {I_VCVTUQQ2PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17864, 243},
+    /* 4745 */ {I_VCVTUQQ2PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17872, 242},
+    /* 4746 */ {I_VCVTUQQ2PS, 2, {XMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17880, 242},
+    /* 4747 */ {I_VCVTUQQ2PS, 2, {YMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17888, 243},
+    /* 4748 */ {I_VCVTUSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17896, 241},
+    /* 4749 */ {I_VCVTUSI2SD, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17904, 241},
+    /* 4750 */ {I_VCVTUSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17912, 241},
+    /* 4751 */ {I_VCVTUSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,0,0,0}, nasm_bytecodes+17920, 241},
+    /* 4752 */ {I_VDBPSADBW, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8209, 244},
+    /* 4753 */ {I_VDBPSADBW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8218, 244},
+    /* 4754 */ {I_VDBPSADBW, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8227, 244},
+    /* 4755 */ {I_VDBPSADBW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8236, 244},
+    /* 4756 */ {I_VDBPSADBW, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8245, 245},
+    /* 4757 */ {I_VDBPSADBW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8254, 245},
+    /* 4758 */ {I_VDIVPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+17928, 240},
+    /* 4759 */ {I_VDIVPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17936, 240},
+    /* 4760 */ {I_VDIVPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+17944, 240},
+    /* 4761 */ {I_VDIVPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+17952, 240},
+    /* 4762 */ {I_VDIVPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+17960, 241},
+    /* 4763 */ {I_VDIVPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+17968, 241},
+    /* 4764 */ {I_VDIVPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+17976, 240},
+    /* 4765 */ {I_VDIVPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+17984, 240},
+    /* 4766 */ {I_VDIVPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+17992, 240},
+    /* 4767 */ {I_VDIVPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+18000, 240},
+    /* 4768 */ {I_VDIVPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18008, 241},
+    /* 4769 */ {I_VDIVPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+18016, 241},
+    /* 4770 */ {I_VDIVSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18024, 241},
+    /* 4771 */ {I_VDIVSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+18032, 241},
+    /* 4772 */ {I_VDIVSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18040, 241},
+    /* 4773 */ {I_VDIVSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+18048, 241},
+    /* 4774 */ {I_VEXP2PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+18056, 246},
+    /* 4775 */ {I_VEXP2PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+18064, 246},
+    /* 4776 */ {I_VEXPANDPD, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18072, 240},
+    /* 4777 */ {I_VEXPANDPD, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18080, 240},
+    /* 4778 */ {I_VEXPANDPD, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18088, 241},
+    /* 4779 */ {I_VEXPANDPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18072, 240},
+    /* 4780 */ {I_VEXPANDPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18080, 240},
+    /* 4781 */ {I_VEXPANDPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18088, 241},
+    /* 4782 */ {I_VEXPANDPS, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18096, 240},
+    /* 4783 */ {I_VEXPANDPS, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18104, 240},
+    /* 4784 */ {I_VEXPANDPS, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18112, 241},
+    /* 4785 */ {I_VEXPANDPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18096, 240},
+    /* 4786 */ {I_VEXPANDPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18104, 240},
+    /* 4787 */ {I_VEXPANDPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+18112, 241},
+    /* 4788 */ {I_VEXTRACTF32X4, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8263, 240},
+    /* 4789 */ {I_VEXTRACTF32X4, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8272, 241},
+    /* 4790 */ {I_VEXTRACTF32X4, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8281, 240},
+    /* 4791 */ {I_VEXTRACTF32X4, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8290, 241},
+    /* 4792 */ {I_VEXTRACTF32X8, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8299, 243},
+    /* 4793 */ {I_VEXTRACTF32X8, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8308, 243},
+    /* 4794 */ {I_VEXTRACTF64X2, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8317, 242},
+    /* 4795 */ {I_VEXTRACTF64X2, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8326, 243},
+    /* 4796 */ {I_VEXTRACTF64X2, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8335, 242},
+    /* 4797 */ {I_VEXTRACTF64X2, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8344, 243},
+    /* 4798 */ {I_VEXTRACTF64X4, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8353, 241},
+    /* 4799 */ {I_VEXTRACTF64X4, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8362, 241},
+    /* 4800 */ {I_VEXTRACTI32X4, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8371, 240},
+    /* 4801 */ {I_VEXTRACTI32X4, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8380, 241},
+    /* 4802 */ {I_VEXTRACTI32X4, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8389, 240},
+    /* 4803 */ {I_VEXTRACTI32X4, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8398, 241},
+    /* 4804 */ {I_VEXTRACTI32X8, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8407, 243},
+    /* 4805 */ {I_VEXTRACTI32X8, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8416, 243},
+    /* 4806 */ {I_VEXTRACTI64X2, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8425, 242},
+    /* 4807 */ {I_VEXTRACTI64X2, 3, {XMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8434, 243},
+    /* 4808 */ {I_VEXTRACTI64X2, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8443, 242},
+    /* 4809 */ {I_VEXTRACTI64X2, 3, {MEMORY|BITS128,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8452, 243},
+    /* 4810 */ {I_VEXTRACTI64X4, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8461, 241},
+    /* 4811 */ {I_VEXTRACTI64X4, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8470, 241},
+    /* 4812 */ {I_VEXTRACTPS, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+8479, 241},
+    /* 4813 */ {I_VEXTRACTPS, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+8479, 241},
+    /* 4814 */ {I_VEXTRACTPS, 3, {MEMORY|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+8479, 241},
+    /* 4815 */ {I_VFIXUPIMMPD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8488, 240},
+    /* 4816 */ {I_VFIXUPIMMPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8497, 240},
+    /* 4817 */ {I_VFIXUPIMMPD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+8506, 240},
+    /* 4818 */ {I_VFIXUPIMMPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8515, 240},
+    /* 4819 */ {I_VFIXUPIMMPD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+8524, 241},
+    /* 4820 */ {I_VFIXUPIMMPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+8533, 241},
+    /* 4821 */ {I_VFIXUPIMMPS, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8542, 240},
+    /* 4822 */ {I_VFIXUPIMMPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8551, 240},
+    /* 4823 */ {I_VFIXUPIMMPS, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+8560, 240},
+    /* 4824 */ {I_VFIXUPIMMPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8569, 240},
+    /* 4825 */ {I_VFIXUPIMMPS, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+8578, 241},
+    /* 4826 */ {I_VFIXUPIMMPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+8587, 241},
+    /* 4827 */ {I_VFIXUPIMMSD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8596, 241},
+    /* 4828 */ {I_VFIXUPIMMSD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8605, 241},
+    /* 4829 */ {I_VFIXUPIMMSS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8614, 241},
+    /* 4830 */ {I_VFIXUPIMMSS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8623, 241},
+    /* 4831 */ {I_VFMADD132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18120, 240},
+    /* 4832 */ {I_VFMADD132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18128, 240},
+    /* 4833 */ {I_VFMADD132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18136, 241},
+    /* 4834 */ {I_VFMADD132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18144, 240},
+    /* 4835 */ {I_VFMADD132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18152, 240},
+    /* 4836 */ {I_VFMADD132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18160, 241},
+    /* 4837 */ {I_VFMADD132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18168, 241},
+    /* 4838 */ {I_VFMADD132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18176, 241},
+    /* 4839 */ {I_VFMADD213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18184, 240},
+    /* 4840 */ {I_VFMADD213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18192, 240},
+    /* 4841 */ {I_VFMADD213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18200, 241},
+    /* 4842 */ {I_VFMADD213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18208, 240},
+    /* 4843 */ {I_VFMADD213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18216, 240},
+    /* 4844 */ {I_VFMADD213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18224, 241},
+    /* 4845 */ {I_VFMADD213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18232, 241},
+    /* 4846 */ {I_VFMADD213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18240, 241},
+    /* 4847 */ {I_VFMADD231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18248, 240},
+    /* 4848 */ {I_VFMADD231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18256, 240},
+    /* 4849 */ {I_VFMADD231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18264, 241},
+    /* 4850 */ {I_VFMADD231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18272, 240},
+    /* 4851 */ {I_VFMADD231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18280, 240},
+    /* 4852 */ {I_VFMADD231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18288, 241},
+    /* 4853 */ {I_VFMADD231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18296, 241},
+    /* 4854 */ {I_VFMADD231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18304, 241},
+    /* 4855 */ {I_VFMADDSUB132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18312, 240},
+    /* 4856 */ {I_VFMADDSUB132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18320, 240},
+    /* 4857 */ {I_VFMADDSUB132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18328, 241},
+    /* 4858 */ {I_VFMADDSUB132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18336, 240},
+    /* 4859 */ {I_VFMADDSUB132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18344, 240},
+    /* 4860 */ {I_VFMADDSUB132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18352, 241},
+    /* 4861 */ {I_VFMADDSUB213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18360, 240},
+    /* 4862 */ {I_VFMADDSUB213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18368, 240},
+    /* 4863 */ {I_VFMADDSUB213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18376, 241},
+    /* 4864 */ {I_VFMADDSUB213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18384, 240},
+    /* 4865 */ {I_VFMADDSUB213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18392, 240},
+    /* 4866 */ {I_VFMADDSUB213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18400, 241},
+    /* 4867 */ {I_VFMADDSUB231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18408, 240},
+    /* 4868 */ {I_VFMADDSUB231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18416, 240},
+    /* 4869 */ {I_VFMADDSUB231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18424, 241},
+    /* 4870 */ {I_VFMADDSUB231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18432, 240},
+    /* 4871 */ {I_VFMADDSUB231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18440, 240},
+    /* 4872 */ {I_VFMADDSUB231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18448, 241},
+    /* 4873 */ {I_VFMSUB132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18456, 240},
+    /* 4874 */ {I_VFMSUB132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18464, 240},
+    /* 4875 */ {I_VFMSUB132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18472, 241},
+    /* 4876 */ {I_VFMSUB132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18480, 240},
+    /* 4877 */ {I_VFMSUB132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18488, 240},
+    /* 4878 */ {I_VFMSUB132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18496, 241},
+    /* 4879 */ {I_VFMSUB132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18504, 241},
+    /* 4880 */ {I_VFMSUB132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18512, 241},
+    /* 4881 */ {I_VFMSUB213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18520, 240},
+    /* 4882 */ {I_VFMSUB213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18528, 240},
+    /* 4883 */ {I_VFMSUB213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18536, 241},
+    /* 4884 */ {I_VFMSUB213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18544, 240},
+    /* 4885 */ {I_VFMSUB213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18552, 240},
+    /* 4886 */ {I_VFMSUB213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18560, 241},
+    /* 4887 */ {I_VFMSUB213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18568, 241},
+    /* 4888 */ {I_VFMSUB213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18576, 241},
+    /* 4889 */ {I_VFMSUB231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18584, 240},
+    /* 4890 */ {I_VFMSUB231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18592, 240},
+    /* 4891 */ {I_VFMSUB231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18600, 241},
+    /* 4892 */ {I_VFMSUB231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18608, 240},
+    /* 4893 */ {I_VFMSUB231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18616, 240},
+    /* 4894 */ {I_VFMSUB231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18624, 241},
+    /* 4895 */ {I_VFMSUB231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18632, 241},
+    /* 4896 */ {I_VFMSUB231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18640, 241},
+    /* 4897 */ {I_VFMSUBADD132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18648, 240},
+    /* 4898 */ {I_VFMSUBADD132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18656, 240},
+    /* 4899 */ {I_VFMSUBADD132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18664, 241},
+    /* 4900 */ {I_VFMSUBADD132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18672, 240},
+    /* 4901 */ {I_VFMSUBADD132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18680, 240},
+    /* 4902 */ {I_VFMSUBADD132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18688, 241},
+    /* 4903 */ {I_VFMSUBADD213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18696, 240},
+    /* 4904 */ {I_VFMSUBADD213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18704, 240},
+    /* 4905 */ {I_VFMSUBADD213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18712, 241},
+    /* 4906 */ {I_VFMSUBADD213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18720, 240},
+    /* 4907 */ {I_VFMSUBADD213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18728, 240},
+    /* 4908 */ {I_VFMSUBADD213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18736, 241},
+    /* 4909 */ {I_VFMSUBADD231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18744, 240},
+    /* 4910 */ {I_VFMSUBADD231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18752, 240},
+    /* 4911 */ {I_VFMSUBADD231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18760, 241},
+    /* 4912 */ {I_VFMSUBADD231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18768, 240},
+    /* 4913 */ {I_VFMSUBADD231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18776, 240},
+    /* 4914 */ {I_VFMSUBADD231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18784, 241},
+    /* 4915 */ {I_VFNMADD132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18792, 240},
+    /* 4916 */ {I_VFNMADD132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18800, 240},
+    /* 4917 */ {I_VFNMADD132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18808, 241},
+    /* 4918 */ {I_VFNMADD132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18816, 240},
+    /* 4919 */ {I_VFNMADD132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18824, 240},
+    /* 4920 */ {I_VFNMADD132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18832, 241},
+    /* 4921 */ {I_VFNMADD132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18840, 241},
+    /* 4922 */ {I_VFNMADD132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18848, 241},
+    /* 4923 */ {I_VFNMADD213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18856, 240},
+    /* 4924 */ {I_VFNMADD213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18864, 240},
+    /* 4925 */ {I_VFNMADD213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18872, 241},
+    /* 4926 */ {I_VFNMADD213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18880, 240},
+    /* 4927 */ {I_VFNMADD213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18888, 240},
+    /* 4928 */ {I_VFNMADD213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18896, 241},
+    /* 4929 */ {I_VFNMADD213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18904, 241},
+    /* 4930 */ {I_VFNMADD213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18912, 241},
+    /* 4931 */ {I_VFNMADD231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18920, 240},
+    /* 4932 */ {I_VFNMADD231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18928, 240},
+    /* 4933 */ {I_VFNMADD231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+18936, 241},
+    /* 4934 */ {I_VFNMADD231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18944, 240},
+    /* 4935 */ {I_VFNMADD231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+18952, 240},
+    /* 4936 */ {I_VFNMADD231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+18960, 241},
+    /* 4937 */ {I_VFNMADD231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18968, 241},
+    /* 4938 */ {I_VFNMADD231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+18976, 241},
+    /* 4939 */ {I_VFNMSUB132PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18984, 240},
+    /* 4940 */ {I_VFNMSUB132PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+18992, 240},
+    /* 4941 */ {I_VFNMSUB132PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+19000, 241},
+    /* 4942 */ {I_VFNMSUB132PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19008, 240},
+    /* 4943 */ {I_VFNMSUB132PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19016, 240},
+    /* 4944 */ {I_VFNMSUB132PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+19024, 241},
+    /* 4945 */ {I_VFNMSUB132SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19032, 241},
+    /* 4946 */ {I_VFNMSUB132SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19040, 241},
+    /* 4947 */ {I_VFNMSUB213PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19048, 240},
+    /* 4948 */ {I_VFNMSUB213PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19056, 240},
+    /* 4949 */ {I_VFNMSUB213PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+19064, 241},
+    /* 4950 */ {I_VFNMSUB213PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19072, 240},
+    /* 4951 */ {I_VFNMSUB213PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19080, 240},
+    /* 4952 */ {I_VFNMSUB213PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+19088, 241},
+    /* 4953 */ {I_VFNMSUB213SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19096, 241},
+    /* 4954 */ {I_VFNMSUB213SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19104, 241},
+    /* 4955 */ {I_VFNMSUB231PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19112, 240},
+    /* 4956 */ {I_VFNMSUB231PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19120, 240},
+    /* 4957 */ {I_VFNMSUB231PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+19128, 241},
+    /* 4958 */ {I_VFNMSUB231PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19136, 240},
+    /* 4959 */ {I_VFNMSUB231PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19144, 240},
+    /* 4960 */ {I_VFNMSUB231PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+19152, 241},
+    /* 4961 */ {I_VFNMSUB231SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19160, 241},
+    /* 4962 */ {I_VFNMSUB231SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+19168, 241},
+    /* 4963 */ {I_VFPCLASSPD, 3, {KREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK,B64,0,0,0}, nasm_bytecodes+8632, 242},
+    /* 4964 */ {I_VFPCLASSPD, 3, {KREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK,B64,0,0,0}, nasm_bytecodes+8641, 242},
+    /* 4965 */ {I_VFPCLASSPD, 3, {KREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK,B64,0,0,0}, nasm_bytecodes+8650, 243},
+    /* 4966 */ {I_VFPCLASSPS, 3, {KREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK,B32,0,0,0}, nasm_bytecodes+8659, 242},
+    /* 4967 */ {I_VFPCLASSPS, 3, {KREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK,B32,0,0,0}, nasm_bytecodes+8668, 242},
+    /* 4968 */ {I_VFPCLASSPS, 3, {KREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK,B32,0,0,0}, nasm_bytecodes+8677, 243},
+    /* 4969 */ {I_VFPCLASSSD, 3, {KREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8686, 243},
+    /* 4970 */ {I_VFPCLASSSS, 3, {KREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8695, 243},
+    /* 4971 */ {I_VGATHERDPD, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8704, 240},
+    /* 4972 */ {I_VGATHERDPD, 2, {YMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8713, 240},
+    /* 4973 */ {I_VGATHERDPD, 2, {ZMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8722, 241},
+    /* 4974 */ {I_VGATHERDPS, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8731, 240},
+    /* 4975 */ {I_VGATHERDPS, 2, {YMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8740, 240},
+    /* 4976 */ {I_VGATHERDPS, 2, {ZMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8749, 241},
+    /* 4977 */ {I_VGATHERPF0DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8758, 247},
+    /* 4978 */ {I_VGATHERPF0DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8767, 247},
+    /* 4979 */ {I_VGATHERPF0QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8776, 247},
+    /* 4980 */ {I_VGATHERPF0QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8785, 247},
+    /* 4981 */ {I_VGATHERPF1DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8794, 247},
+    /* 4982 */ {I_VGATHERPF1DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8803, 247},
+    /* 4983 */ {I_VGATHERPF1QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8812, 247},
+    /* 4984 */ {I_VGATHERPF1QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8821, 247},
+    /* 4985 */ {I_VGATHERQPD, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8830, 240},
+    /* 4986 */ {I_VGATHERQPD, 2, {YMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8839, 240},
+    /* 4987 */ {I_VGATHERQPD, 2, {ZMMREG,ZMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8848, 241},
+    /* 4988 */ {I_VGATHERQPS, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8857, 240},
+    /* 4989 */ {I_VGATHERQPS, 2, {XMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8866, 240},
+    /* 4990 */ {I_VGATHERQPS, 2, {YMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8875, 241},
+    /* 4991 */ {I_VGETEXPPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19176, 240},
+    /* 4992 */ {I_VGETEXPPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19184, 240},
+    /* 4993 */ {I_VGETEXPPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+19192, 241},
+    /* 4994 */ {I_VGETEXPPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19200, 240},
+    /* 4995 */ {I_VGETEXPPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19208, 240},
+    /* 4996 */ {I_VGETEXPPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+19216, 241},
+    /* 4997 */ {I_VGETEXPSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19224, 241},
+    /* 4998 */ {I_VGETEXPSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19232, 241},
+    /* 4999 */ {I_VGETMANTPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8884, 240},
+    /* 5000 */ {I_VGETMANTPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+8893, 240},
+    /* 5001 */ {I_VGETMANTPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+8902, 241},
+    /* 5002 */ {I_VGETMANTPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8911, 240},
+    /* 5003 */ {I_VGETMANTPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+8920, 240},
+    /* 5004 */ {I_VGETMANTPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+8929, 241},
+    /* 5005 */ {I_VGETMANTSD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8938, 241},
+    /* 5006 */ {I_VGETMANTSS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+8947, 241},
+    /* 5007 */ {I_VINSERTF32X4, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8956, 240},
+    /* 5008 */ {I_VINSERTF32X4, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8965, 240},
+    /* 5009 */ {I_VINSERTF32X4, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8974, 241},
+    /* 5010 */ {I_VINSERTF32X4, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8983, 241},
+    /* 5011 */ {I_VINSERTF32X8, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8992, 243},
+    /* 5012 */ {I_VINSERTF32X8, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9001, 243},
+    /* 5013 */ {I_VINSERTF64X2, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9010, 242},
+    /* 5014 */ {I_VINSERTF64X2, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9019, 242},
+    /* 5015 */ {I_VINSERTF64X2, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9028, 243},
+    /* 5016 */ {I_VINSERTF64X2, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9037, 243},
+    /* 5017 */ {I_VINSERTF64X4, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9046, 241},
+    /* 5018 */ {I_VINSERTF64X4, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9055, 241},
+    /* 5019 */ {I_VINSERTI32X4, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9064, 240},
+    /* 5020 */ {I_VINSERTI32X4, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9073, 240},
+    /* 5021 */ {I_VINSERTI32X4, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9082, 241},
+    /* 5022 */ {I_VINSERTI32X4, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9091, 241},
+    /* 5023 */ {I_VINSERTI32X8, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9100, 243},
+    /* 5024 */ {I_VINSERTI32X8, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9109, 243},
+    /* 5025 */ {I_VINSERTI64X2, 4, {YMMREG,YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9118, 242},
+    /* 5026 */ {I_VINSERTI64X2, 3, {YMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9127, 242},
+    /* 5027 */ {I_VINSERTI64X2, 4, {ZMMREG,ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9136, 243},
+    /* 5028 */ {I_VINSERTI64X2, 3, {ZMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9145, 243},
+    /* 5029 */ {I_VINSERTI64X4, 4, {ZMMREG,ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9154, 241},
+    /* 5030 */ {I_VINSERTI64X4, 3, {ZMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9163, 241},
+    /* 5031 */ {I_VINSERTPS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9172, 241},
+    /* 5032 */ {I_VINSERTPS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9181, 241},
+    /* 5033 */ {I_VMAXPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19240, 240},
+    /* 5034 */ {I_VMAXPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19248, 240},
+    /* 5035 */ {I_VMAXPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19256, 240},
+    /* 5036 */ {I_VMAXPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19264, 240},
+    /* 5037 */ {I_VMAXPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+19272, 241},
+    /* 5038 */ {I_VMAXPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+19280, 241},
+    /* 5039 */ {I_VMAXPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19288, 240},
+    /* 5040 */ {I_VMAXPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19296, 240},
+    /* 5041 */ {I_VMAXPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19304, 240},
+    /* 5042 */ {I_VMAXPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19312, 240},
+    /* 5043 */ {I_VMAXPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+19320, 241},
+    /* 5044 */ {I_VMAXPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+19328, 241},
+    /* 5045 */ {I_VMAXSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19336, 241},
+    /* 5046 */ {I_VMAXSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19344, 241},
+    /* 5047 */ {I_VMAXSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19352, 241},
+    /* 5048 */ {I_VMAXSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19360, 241},
+    /* 5049 */ {I_VMINPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19368, 240},
+    /* 5050 */ {I_VMINPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19376, 240},
+    /* 5051 */ {I_VMINPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+19384, 240},
+    /* 5052 */ {I_VMINPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+19392, 240},
+    /* 5053 */ {I_VMINPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+19400, 241},
+    /* 5054 */ {I_VMINPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+19408, 241},
+    /* 5055 */ {I_VMINPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19416, 240},
+    /* 5056 */ {I_VMINPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19424, 240},
+    /* 5057 */ {I_VMINPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+19432, 240},
+    /* 5058 */ {I_VMINPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+19440, 240},
+    /* 5059 */ {I_VMINPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+19448, 241},
+    /* 5060 */ {I_VMINPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+19456, 241},
+    /* 5061 */ {I_VMINSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19464, 241},
+    /* 5062 */ {I_VMINSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19472, 241},
+    /* 5063 */ {I_VMINSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+19480, 241},
+    /* 5064 */ {I_VMINSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+19488, 241},
+    /* 5065 */ {I_VMOVAPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19496, 240},
+    /* 5066 */ {I_VMOVAPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19504, 240},
+    /* 5067 */ {I_VMOVAPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19512, 241},
+    /* 5068 */ {I_VMOVAPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19520, 240},
+    /* 5069 */ {I_VMOVAPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19528, 240},
+    /* 5070 */ {I_VMOVAPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19536, 241},
+    /* 5071 */ {I_VMOVAPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19544, 240},
+    /* 5072 */ {I_VMOVAPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19552, 240},
+    /* 5073 */ {I_VMOVAPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19560, 241},
+    /* 5074 */ {I_VMOVAPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19568, 240},
+    /* 5075 */ {I_VMOVAPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19576, 240},
+    /* 5076 */ {I_VMOVAPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19584, 241},
+    /* 5077 */ {I_VMOVAPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19592, 240},
+    /* 5078 */ {I_VMOVAPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19600, 240},
+    /* 5079 */ {I_VMOVAPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19608, 241},
+    /* 5080 */ {I_VMOVAPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19616, 240},
+    /* 5081 */ {I_VMOVAPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19624, 240},
+    /* 5082 */ {I_VMOVAPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+19632, 241},
+    /* 5083 */ {I_VMOVD, 2, {XMMREG,RM_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+19640, 241},
+    /* 5084 */ {I_VMOVD, 2, {RM_GPR|BITS32,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+19648, 241},
+    /* 5085 */ {I_VMOVDDUP, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19656, 240},
+    /* 5086 */ {I_VMOVDDUP, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19664, 240},
+    /* 5087 */ {I_VMOVDDUP, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19672, 241},
+    /* 5088 */ {I_VMOVDQA32, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19680, 240},
+    /* 5089 */ {I_VMOVDQA32, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19688, 240},
+    /* 5090 */ {I_VMOVDQA32, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19696, 241},
+    /* 5091 */ {I_VMOVDQA32, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19704, 240},
+    /* 5092 */ {I_VMOVDQA32, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19712, 240},
+    /* 5093 */ {I_VMOVDQA32, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19720, 241},
+    /* 5094 */ {I_VMOVDQA64, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19728, 240},
+    /* 5095 */ {I_VMOVDQA64, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19736, 240},
+    /* 5096 */ {I_VMOVDQA64, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19744, 241},
+    /* 5097 */ {I_VMOVDQA64, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19752, 240},
+    /* 5098 */ {I_VMOVDQA64, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19760, 240},
+    /* 5099 */ {I_VMOVDQA64, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19768, 241},
+    /* 5100 */ {I_VMOVDQU16, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19776, 244},
+    /* 5101 */ {I_VMOVDQU16, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19784, 244},
+    /* 5102 */ {I_VMOVDQU16, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19792, 245},
+    /* 5103 */ {I_VMOVDQU16, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19800, 244},
+    /* 5104 */ {I_VMOVDQU16, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19808, 244},
+    /* 5105 */ {I_VMOVDQU16, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19816, 245},
+    /* 5106 */ {I_VMOVDQU32, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19824, 240},
+    /* 5107 */ {I_VMOVDQU32, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19832, 240},
+    /* 5108 */ {I_VMOVDQU32, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19840, 241},
+    /* 5109 */ {I_VMOVDQU32, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19848, 240},
+    /* 5110 */ {I_VMOVDQU32, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19856, 240},
+    /* 5111 */ {I_VMOVDQU32, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19864, 241},
+    /* 5112 */ {I_VMOVDQU64, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19872, 240},
+    /* 5113 */ {I_VMOVDQU64, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19880, 240},
+    /* 5114 */ {I_VMOVDQU64, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19888, 241},
+    /* 5115 */ {I_VMOVDQU64, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19896, 240},
+    /* 5116 */ {I_VMOVDQU64, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19904, 240},
+    /* 5117 */ {I_VMOVDQU64, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19912, 241},
+    /* 5118 */ {I_VMOVDQU8, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19920, 244},
+    /* 5119 */ {I_VMOVDQU8, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19928, 244},
+    /* 5120 */ {I_VMOVDQU8, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19936, 245},
+    /* 5121 */ {I_VMOVDQU8, 2, {RM_XMM|BITS128,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19944, 244},
+    /* 5122 */ {I_VMOVDQU8, 2, {RM_YMM|BITS256,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19952, 244},
+    /* 5123 */ {I_VMOVDQU8, 2, {RM_ZMM|BITS512,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+19960, 245},
+    /* 5124 */ {I_VMOVHLPS, 3, {XMMREG,XMMREG,XMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+19968, 241},
+    /* 5125 */ {I_VMOVHLPS, 2, {XMMREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+19976, 241},
+    /* 5126 */ {I_VMOVHPD, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+19984, 241},
+    /* 5127 */ {I_VMOVHPD, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+19992, 241},
+    /* 5128 */ {I_VMOVHPD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20000, 241},
+    /* 5129 */ {I_VMOVHPS, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+20008, 241},
+    /* 5130 */ {I_VMOVHPS, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20016, 241},
+    /* 5131 */ {I_VMOVHPS, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20024, 241},
+    /* 5132 */ {I_VMOVLHPS, 3, {XMMREG,XMMREG,XMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+20032, 241},
+    /* 5133 */ {I_VMOVLHPS, 2, {XMMREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20040, 241},
+    /* 5134 */ {I_VMOVLPD, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+20048, 241},
+    /* 5135 */ {I_VMOVLPD, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20056, 241},
+    /* 5136 */ {I_VMOVLPD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20064, 241},
+    /* 5137 */ {I_VMOVLPS, 3, {XMMREG,XMMREG,MEMORY|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+20072, 241},
+    /* 5138 */ {I_VMOVLPS, 2, {XMMREG,MEMORY|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20080, 241},
+    /* 5139 */ {I_VMOVLPS, 2, {MEMORY|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20088, 241},
+    /* 5140 */ {I_VMOVNTDQ, 2, {MEMORY|BITS128,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20096, 240},
+    /* 5141 */ {I_VMOVNTDQ, 2, {MEMORY|BITS256,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20104, 240},
+    /* 5142 */ {I_VMOVNTDQ, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20112, 241},
+    /* 5143 */ {I_VMOVNTDQA, 2, {XMMREG,MEMORY|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+20120, 240},
+    /* 5144 */ {I_VMOVNTDQA, 2, {YMMREG,MEMORY|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+20128, 240},
+    /* 5145 */ {I_VMOVNTDQA, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+20136, 241},
+    /* 5146 */ {I_VMOVNTPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20144, 240},
+    /* 5147 */ {I_VMOVNTPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20152, 240},
+    /* 5148 */ {I_VMOVNTPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20160, 241},
+    /* 5149 */ {I_VMOVNTPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20168, 240},
+    /* 5150 */ {I_VMOVNTPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20176, 240},
+    /* 5151 */ {I_VMOVNTPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20184, 241},
+    /* 5152 */ {I_VMOVQ, 2, {XMMREG,RM_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20192, 241},
+    /* 5153 */ {I_VMOVQ, 2, {RM_GPR|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20200, 241},
+    /* 5154 */ {I_VMOVQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+20208, 241},
+    /* 5155 */ {I_VMOVQ, 2, {RM_XMM|BITS64,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+20216, 241},
+    /* 5156 */ {I_VMOVSD, 2, {XMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20224, 241},
+    /* 5157 */ {I_VMOVSD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20232, 241},
+    /* 5158 */ {I_VMOVSD, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20240, 241},
+    /* 5159 */ {I_VMOVSD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20248, 241},
+    /* 5160 */ {I_VMOVSD, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20256, 241},
+    /* 5161 */ {I_VMOVSD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20264, 241},
+    /* 5162 */ {I_VMOVSHDUP, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20272, 240},
+    /* 5163 */ {I_VMOVSHDUP, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20280, 240},
+    /* 5164 */ {I_VMOVSHDUP, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20288, 241},
+    /* 5165 */ {I_VMOVSLDUP, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20296, 240},
+    /* 5166 */ {I_VMOVSLDUP, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20304, 240},
+    /* 5167 */ {I_VMOVSLDUP, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20312, 241},
+    /* 5168 */ {I_VMOVSS, 2, {XMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20320, 241},
+    /* 5169 */ {I_VMOVSS, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20328, 241},
+    /* 5170 */ {I_VMOVSS, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20336, 241},
+    /* 5171 */ {I_VMOVSS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20344, 241},
+    /* 5172 */ {I_VMOVSS, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20352, 241},
+    /* 5173 */ {I_VMOVSS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20360, 241},
+    /* 5174 */ {I_VMOVUPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20368, 240},
+    /* 5175 */ {I_VMOVUPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20376, 240},
+    /* 5176 */ {I_VMOVUPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20384, 241},
+    /* 5177 */ {I_VMOVUPD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20392, 240},
+    /* 5178 */ {I_VMOVUPD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20400, 240},
+    /* 5179 */ {I_VMOVUPD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20408, 241},
+    /* 5180 */ {I_VMOVUPD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20416, 240},
+    /* 5181 */ {I_VMOVUPD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20424, 240},
+    /* 5182 */ {I_VMOVUPD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20432, 241},
+    /* 5183 */ {I_VMOVUPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20440, 240},
+    /* 5184 */ {I_VMOVUPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20448, 240},
+    /* 5185 */ {I_VMOVUPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20456, 241},
+    /* 5186 */ {I_VMOVUPS, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20464, 240},
+    /* 5187 */ {I_VMOVUPS, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20472, 240},
+    /* 5188 */ {I_VMOVUPS, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20480, 241},
+    /* 5189 */ {I_VMOVUPS, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20488, 240},
+    /* 5190 */ {I_VMOVUPS, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20496, 240},
+    /* 5191 */ {I_VMOVUPS, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+20504, 241},
+    /* 5192 */ {I_VMULPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20512, 240},
+    /* 5193 */ {I_VMULPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20520, 240},
+    /* 5194 */ {I_VMULPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20528, 240},
+    /* 5195 */ {I_VMULPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20536, 240},
+    /* 5196 */ {I_VMULPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+20544, 241},
+    /* 5197 */ {I_VMULPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+20552, 241},
+    /* 5198 */ {I_VMULPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20560, 240},
+    /* 5199 */ {I_VMULPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20568, 240},
+    /* 5200 */ {I_VMULPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20576, 240},
+    /* 5201 */ {I_VMULPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20584, 240},
+    /* 5202 */ {I_VMULPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+20592, 241},
+    /* 5203 */ {I_VMULPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+20600, 241},
+    /* 5204 */ {I_VMULSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+20608, 241},
+    /* 5205 */ {I_VMULSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+20616, 241},
+    /* 5206 */ {I_VMULSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+20624, 241},
+    /* 5207 */ {I_VMULSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+20632, 241},
+    /* 5208 */ {I_VORPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20640, 242},
+    /* 5209 */ {I_VORPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20648, 242},
+    /* 5210 */ {I_VORPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20656, 242},
+    /* 5211 */ {I_VORPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20664, 242},
+    /* 5212 */ {I_VORPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+20672, 243},
+    /* 5213 */ {I_VORPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20680, 243},
+    /* 5214 */ {I_VORPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20688, 242},
+    /* 5215 */ {I_VORPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20696, 242},
+    /* 5216 */ {I_VORPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20704, 242},
+    /* 5217 */ {I_VORPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20712, 242},
+    /* 5218 */ {I_VORPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20720, 243},
+    /* 5219 */ {I_VORPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20728, 243},
+    /* 5220 */ {I_VPABSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20736, 244},
+    /* 5221 */ {I_VPABSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20744, 244},
+    /* 5222 */ {I_VPABSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20752, 245},
+    /* 5223 */ {I_VPABSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20760, 240},
+    /* 5224 */ {I_VPABSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20768, 240},
+    /* 5225 */ {I_VPABSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20776, 241},
+    /* 5226 */ {I_VPABSQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20784, 240},
+    /* 5227 */ {I_VPABSQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20792, 240},
+    /* 5228 */ {I_VPABSQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+20800, 241},
+    /* 5229 */ {I_VPABSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20808, 244},
+    /* 5230 */ {I_VPABSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20816, 244},
+    /* 5231 */ {I_VPABSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20824, 245},
+    /* 5232 */ {I_VPACKSSDW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20832, 244},
+    /* 5233 */ {I_VPACKSSDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20840, 244},
+    /* 5234 */ {I_VPACKSSDW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20848, 244},
+    /* 5235 */ {I_VPACKSSDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20856, 244},
+    /* 5236 */ {I_VPACKSSDW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20864, 245},
+    /* 5237 */ {I_VPACKSSDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20872, 245},
+    /* 5238 */ {I_VPACKSSWB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20880, 244},
+    /* 5239 */ {I_VPACKSSWB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20888, 244},
+    /* 5240 */ {I_VPACKSSWB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20896, 244},
+    /* 5241 */ {I_VPACKSSWB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20904, 244},
+    /* 5242 */ {I_VPACKSSWB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20912, 245},
+    /* 5243 */ {I_VPACKSSWB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20920, 245},
+    /* 5244 */ {I_VPACKUSDW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20928, 244},
+    /* 5245 */ {I_VPACKUSDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20936, 244},
+    /* 5246 */ {I_VPACKUSDW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20944, 244},
+    /* 5247 */ {I_VPACKUSDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20952, 244},
+    /* 5248 */ {I_VPACKUSDW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+20960, 245},
+    /* 5249 */ {I_VPACKUSDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+20968, 245},
+    /* 5250 */ {I_VPACKUSWB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20976, 244},
+    /* 5251 */ {I_VPACKUSWB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20984, 244},
+    /* 5252 */ {I_VPACKUSWB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+20992, 244},
+    /* 5253 */ {I_VPACKUSWB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21000, 244},
+    /* 5254 */ {I_VPACKUSWB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21008, 245},
+    /* 5255 */ {I_VPACKUSWB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21016, 245},
+    /* 5256 */ {I_VPADDB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21024, 244},
+    /* 5257 */ {I_VPADDB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21032, 244},
+    /* 5258 */ {I_VPADDB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21040, 244},
+    /* 5259 */ {I_VPADDB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21048, 244},
+    /* 5260 */ {I_VPADDB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21056, 245},
+    /* 5261 */ {I_VPADDB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21064, 245},
+    /* 5262 */ {I_VPADDD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21072, 240},
+    /* 5263 */ {I_VPADDD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21080, 240},
+    /* 5264 */ {I_VPADDD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21088, 240},
+    /* 5265 */ {I_VPADDD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21096, 240},
+    /* 5266 */ {I_VPADDD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21104, 241},
+    /* 5267 */ {I_VPADDD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21112, 241},
+    /* 5268 */ {I_VPADDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21120, 240},
+    /* 5269 */ {I_VPADDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21128, 240},
+    /* 5270 */ {I_VPADDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21136, 240},
+    /* 5271 */ {I_VPADDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21144, 240},
+    /* 5272 */ {I_VPADDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21152, 241},
+    /* 5273 */ {I_VPADDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21160, 241},
+    /* 5274 */ {I_VPADDSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21168, 244},
+    /* 5275 */ {I_VPADDSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21176, 244},
+    /* 5276 */ {I_VPADDSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21184, 244},
+    /* 5277 */ {I_VPADDSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21192, 244},
+    /* 5278 */ {I_VPADDSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21200, 245},
+    /* 5279 */ {I_VPADDSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21208, 245},
+    /* 5280 */ {I_VPADDSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21216, 244},
+    /* 5281 */ {I_VPADDSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21224, 244},
+    /* 5282 */ {I_VPADDSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21232, 244},
+    /* 5283 */ {I_VPADDSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21240, 244},
+    /* 5284 */ {I_VPADDSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21248, 245},
+    /* 5285 */ {I_VPADDSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21256, 245},
+    /* 5286 */ {I_VPADDUSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21264, 244},
+    /* 5287 */ {I_VPADDUSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21272, 244},
+    /* 5288 */ {I_VPADDUSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21280, 244},
+    /* 5289 */ {I_VPADDUSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21288, 244},
+    /* 5290 */ {I_VPADDUSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21296, 245},
+    /* 5291 */ {I_VPADDUSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21304, 245},
+    /* 5292 */ {I_VPADDUSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21312, 244},
+    /* 5293 */ {I_VPADDUSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21320, 244},
+    /* 5294 */ {I_VPADDUSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21328, 244},
+    /* 5295 */ {I_VPADDUSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21336, 244},
+    /* 5296 */ {I_VPADDUSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21344, 245},
+    /* 5297 */ {I_VPADDUSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21352, 245},
+    /* 5298 */ {I_VPADDW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21360, 244},
+    /* 5299 */ {I_VPADDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21368, 244},
+    /* 5300 */ {I_VPADDW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21376, 244},
+    /* 5301 */ {I_VPADDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21384, 244},
+    /* 5302 */ {I_VPADDW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21392, 245},
+    /* 5303 */ {I_VPADDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21400, 245},
+    /* 5304 */ {I_VPALIGNR, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9190, 244},
+    /* 5305 */ {I_VPALIGNR, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9199, 244},
+    /* 5306 */ {I_VPALIGNR, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9208, 244},
+    /* 5307 */ {I_VPALIGNR, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9217, 244},
+    /* 5308 */ {I_VPALIGNR, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9226, 245},
+    /* 5309 */ {I_VPALIGNR, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9235, 245},
+    /* 5310 */ {I_VPANDD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21408, 240},
+    /* 5311 */ {I_VPANDD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21416, 240},
+    /* 5312 */ {I_VPANDD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21424, 240},
+    /* 5313 */ {I_VPANDD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21432, 240},
+    /* 5314 */ {I_VPANDD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21440, 241},
+    /* 5315 */ {I_VPANDD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21448, 241},
+    /* 5316 */ {I_VPANDND, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21456, 240},
+    /* 5317 */ {I_VPANDND, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21464, 240},
+    /* 5318 */ {I_VPANDND, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21472, 240},
+    /* 5319 */ {I_VPANDND, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21480, 240},
+    /* 5320 */ {I_VPANDND, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21488, 241},
+    /* 5321 */ {I_VPANDND, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+21496, 241},
+    /* 5322 */ {I_VPANDNQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21504, 240},
+    /* 5323 */ {I_VPANDNQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21512, 240},
+    /* 5324 */ {I_VPANDNQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21520, 240},
+    /* 5325 */ {I_VPANDNQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21528, 240},
+    /* 5326 */ {I_VPANDNQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21536, 241},
+    /* 5327 */ {I_VPANDNQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21544, 241},
+    /* 5328 */ {I_VPANDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21552, 240},
+    /* 5329 */ {I_VPANDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21560, 240},
+    /* 5330 */ {I_VPANDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21568, 240},
+    /* 5331 */ {I_VPANDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21576, 240},
+    /* 5332 */ {I_VPANDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21584, 241},
+    /* 5333 */ {I_VPANDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+21592, 241},
+    /* 5334 */ {I_VPAVGB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21600, 244},
+    /* 5335 */ {I_VPAVGB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21608, 244},
+    /* 5336 */ {I_VPAVGB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21616, 244},
+    /* 5337 */ {I_VPAVGB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21624, 244},
+    /* 5338 */ {I_VPAVGB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21632, 245},
+    /* 5339 */ {I_VPAVGB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21640, 245},
+    /* 5340 */ {I_VPAVGW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21648, 244},
+    /* 5341 */ {I_VPAVGW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21656, 244},
+    /* 5342 */ {I_VPAVGW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21664, 244},
+    /* 5343 */ {I_VPAVGW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21672, 244},
+    /* 5344 */ {I_VPAVGW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21680, 245},
+    /* 5345 */ {I_VPAVGW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21688, 245},
+    /* 5346 */ {I_VPBLENDMB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21696, 244},
+    /* 5347 */ {I_VPBLENDMB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21704, 244},
+    /* 5348 */ {I_VPBLENDMB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21712, 245},
+    /* 5349 */ {I_VPBLENDMD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21720, 240},
+    /* 5350 */ {I_VPBLENDMD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21728, 240},
+    /* 5351 */ {I_VPBLENDMD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+21736, 241},
+    /* 5352 */ {I_VPBLENDMQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21744, 240},
+    /* 5353 */ {I_VPBLENDMQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21752, 240},
+    /* 5354 */ {I_VPBLENDMQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+21760, 241},
+    /* 5355 */ {I_VPBLENDMW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21768, 244},
+    /* 5356 */ {I_VPBLENDMW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21776, 244},
+    /* 5357 */ {I_VPBLENDMW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21784, 245},
+    /* 5358 */ {I_VPBROADCASTB, 2, {XMMREG,RM_XMM|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21792, 244},
+    /* 5359 */ {I_VPBROADCASTB, 2, {YMMREG,RM_XMM|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21800, 244},
+    /* 5360 */ {I_VPBROADCASTB, 2, {ZMMREG,RM_XMM|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21808, 245},
+    /* 5361 */ {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    /* 5362 */ {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    /* 5363 */ {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    /* 5364 */ {I_VPBROADCASTB, 2, {XMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21816, 244},
+    /* 5365 */ {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    /* 5366 */ {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    /* 5367 */ {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    /* 5368 */ {I_VPBROADCASTB, 2, {YMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21824, 244},
+    /* 5369 */ {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    /* 5370 */ {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    /* 5371 */ {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    /* 5372 */ {I_VPBROADCASTB, 2, {ZMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21832, 245},
+    /* 5373 */ {I_VPBROADCASTD, 2, {XMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21840, 240},
+    /* 5374 */ {I_VPBROADCASTD, 2, {YMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21848, 240},
+    /* 5375 */ {I_VPBROADCASTD, 2, {ZMMREG,MEMORY|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21856, 241},
+    /* 5376 */ {I_VPBROADCASTD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21864, 240},
+    /* 5377 */ {I_VPBROADCASTD, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21872, 240},
+    /* 5378 */ {I_VPBROADCASTD, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21880, 241},
+    /* 5379 */ {I_VPBROADCASTD, 2, {XMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21888, 240},
+    /* 5380 */ {I_VPBROADCASTD, 2, {YMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21896, 240},
+    /* 5381 */ {I_VPBROADCASTD, 2, {ZMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21904, 241},
+    /* 5382 */ {I_VPBROADCASTMB2Q, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21912, 248},
+    /* 5383 */ {I_VPBROADCASTMB2Q, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21920, 248},
+    /* 5384 */ {I_VPBROADCASTMB2Q, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21928, 249},
+    /* 5385 */ {I_VPBROADCASTMW2D, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21936, 248},
+    /* 5386 */ {I_VPBROADCASTMW2D, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21944, 248},
+    /* 5387 */ {I_VPBROADCASTMW2D, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+21952, 249},
+    /* 5388 */ {I_VPBROADCASTQ, 2, {XMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21960, 240},
+    /* 5389 */ {I_VPBROADCASTQ, 2, {YMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21968, 240},
+    /* 5390 */ {I_VPBROADCASTQ, 2, {ZMMREG,MEMORY|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21976, 241},
+    /* 5391 */ {I_VPBROADCASTQ, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21984, 240},
+    /* 5392 */ {I_VPBROADCASTQ, 2, {YMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+21992, 240},
+    /* 5393 */ {I_VPBROADCASTQ, 2, {ZMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22000, 241},
+    /* 5394 */ {I_VPBROADCASTQ, 2, {XMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22008, 240},
+    /* 5395 */ {I_VPBROADCASTQ, 2, {YMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22016, 240},
+    /* 5396 */ {I_VPBROADCASTQ, 2, {ZMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22024, 241},
+    /* 5397 */ {I_VPBROADCASTW, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22032, 244},
+    /* 5398 */ {I_VPBROADCASTW, 2, {YMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22040, 244},
+    /* 5399 */ {I_VPBROADCASTW, 2, {ZMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22048, 245},
+    /* 5400 */ {I_VPBROADCASTW, 2, {XMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22056, 244},
+    /* 5401 */ {I_VPBROADCASTW, 2, {XMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22056, 244},
+    /* 5402 */ {I_VPBROADCASTW, 2, {XMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22056, 244},
+    /* 5403 */ {I_VPBROADCASTW, 2, {YMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22064, 244},
+    /* 5404 */ {I_VPBROADCASTW, 2, {YMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22064, 244},
+    /* 5405 */ {I_VPBROADCASTW, 2, {YMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22064, 244},
+    /* 5406 */ {I_VPBROADCASTW, 2, {ZMMREG,REG_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22072, 245},
+    /* 5407 */ {I_VPBROADCASTW, 2, {ZMMREG,REG_GPR|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22072, 245},
+    /* 5408 */ {I_VPBROADCASTW, 2, {ZMMREG,REG_GPR|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22072, 245},
+    /* 5409 */ {I_VPCMPEQB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22080, 244},
+    /* 5410 */ {I_VPCMPEQB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22088, 244},
+    /* 5411 */ {I_VPCMPEQB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22096, 245},
+    /* 5412 */ {I_VPCMPEQD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22104, 240},
+    /* 5413 */ {I_VPCMPEQD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22112, 240},
+    /* 5414 */ {I_VPCMPEQD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22120, 241},
+    /* 5415 */ {I_VPCMPEQQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22128, 240},
+    /* 5416 */ {I_VPCMPEQQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22136, 240},
+    /* 5417 */ {I_VPCMPEQQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22144, 241},
+    /* 5418 */ {I_VPCMPEQW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22152, 244},
+    /* 5419 */ {I_VPCMPEQW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22160, 244},
+    /* 5420 */ {I_VPCMPEQW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22168, 245},
+    /* 5421 */ {I_VPCMPGTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22176, 244},
+    /* 5422 */ {I_VPCMPGTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22184, 244},
+    /* 5423 */ {I_VPCMPGTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22192, 245},
+    /* 5424 */ {I_VPCMPGTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22200, 240},
+    /* 5425 */ {I_VPCMPGTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22208, 240},
+    /* 5426 */ {I_VPCMPGTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+22216, 241},
+    /* 5427 */ {I_VPCMPGTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22224, 240},
+    /* 5428 */ {I_VPCMPGTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22232, 240},
+    /* 5429 */ {I_VPCMPGTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+22240, 241},
+    /* 5430 */ {I_VPCMPGTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22248, 244},
+    /* 5431 */ {I_VPCMPGTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22256, 244},
+    /* 5432 */ {I_VPCMPGTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22264, 245},
+    /* 5433 */ {I_VPCMPEQB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2800, 244},
+    /* 5434 */ {I_VPCMPEQB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2810, 244},
+    /* 5435 */ {I_VPCMPEQB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2820, 245},
+    /* 5436 */ {I_VPCMPEQD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2830, 240},
+    /* 5437 */ {I_VPCMPEQD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2840, 240},
+    /* 5438 */ {I_VPCMPEQD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2850, 241},
+    /* 5439 */ {I_VPCMPEQQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2860, 240},
+    /* 5440 */ {I_VPCMPEQQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2870, 240},
+    /* 5441 */ {I_VPCMPEQQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2880, 241},
+    /* 5442 */ {I_VPCMPEQUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2890, 244},
+    /* 5443 */ {I_VPCMPEQUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2900, 244},
+    /* 5444 */ {I_VPCMPEQUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2910, 245},
+    /* 5445 */ {I_VPCMPEQUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2920, 240},
+    /* 5446 */ {I_VPCMPEQUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2930, 240},
+    /* 5447 */ {I_VPCMPEQUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+2940, 241},
+    /* 5448 */ {I_VPCMPEQUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2950, 240},
+    /* 5449 */ {I_VPCMPEQUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2960, 240},
+    /* 5450 */ {I_VPCMPEQUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+2970, 241},
+    /* 5451 */ {I_VPCMPEQUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2980, 244},
+    /* 5452 */ {I_VPCMPEQUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+2990, 244},
+    /* 5453 */ {I_VPCMPEQUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3000, 245},
+    /* 5454 */ {I_VPCMPEQW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3010, 244},
+    /* 5455 */ {I_VPCMPEQW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3020, 244},
+    /* 5456 */ {I_VPCMPEQW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3030, 245},
+    /* 5457 */ {I_VPCMPGEB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3040, 244},
+    /* 5458 */ {I_VPCMPGEB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3050, 244},
+    /* 5459 */ {I_VPCMPGEB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3060, 245},
+    /* 5460 */ {I_VPCMPGED, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3070, 240},
+    /* 5461 */ {I_VPCMPGED, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3080, 240},
+    /* 5462 */ {I_VPCMPGED, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3090, 241},
+    /* 5463 */ {I_VPCMPGEQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3100, 240},
+    /* 5464 */ {I_VPCMPGEQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3110, 240},
+    /* 5465 */ {I_VPCMPGEQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3120, 241},
+    /* 5466 */ {I_VPCMPGEUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3130, 244},
+    /* 5467 */ {I_VPCMPGEUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3140, 244},
+    /* 5468 */ {I_VPCMPGEUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3150, 245},
+    /* 5469 */ {I_VPCMPGEUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3160, 240},
+    /* 5470 */ {I_VPCMPGEUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3170, 240},
+    /* 5471 */ {I_VPCMPGEUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3180, 241},
+    /* 5472 */ {I_VPCMPGEUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3190, 240},
+    /* 5473 */ {I_VPCMPGEUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3200, 240},
+    /* 5474 */ {I_VPCMPGEUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3210, 241},
+    /* 5475 */ {I_VPCMPGEUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3220, 244},
+    /* 5476 */ {I_VPCMPGEUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3230, 244},
+    /* 5477 */ {I_VPCMPGEUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3240, 245},
+    /* 5478 */ {I_VPCMPGEW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3250, 244},
+    /* 5479 */ {I_VPCMPGEW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3260, 244},
+    /* 5480 */ {I_VPCMPGEW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3270, 245},
+    /* 5481 */ {I_VPCMPGTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3280, 244},
+    /* 5482 */ {I_VPCMPGTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3290, 244},
+    /* 5483 */ {I_VPCMPGTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3300, 245},
+    /* 5484 */ {I_VPCMPGTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3310, 240},
+    /* 5485 */ {I_VPCMPGTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3320, 240},
+    /* 5486 */ {I_VPCMPGTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3330, 241},
+    /* 5487 */ {I_VPCMPGTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3340, 240},
+    /* 5488 */ {I_VPCMPGTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3350, 240},
+    /* 5489 */ {I_VPCMPGTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3360, 241},
+    /* 5490 */ {I_VPCMPGTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3370, 244},
+    /* 5491 */ {I_VPCMPGTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3380, 244},
+    /* 5492 */ {I_VPCMPGTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3390, 245},
+    /* 5493 */ {I_VPCMPGTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3400, 240},
+    /* 5494 */ {I_VPCMPGTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3410, 240},
+    /* 5495 */ {I_VPCMPGTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3420, 241},
+    /* 5496 */ {I_VPCMPGTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3430, 240},
+    /* 5497 */ {I_VPCMPGTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3440, 240},
+    /* 5498 */ {I_VPCMPGTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3450, 241},
+    /* 5499 */ {I_VPCMPGTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3460, 244},
+    /* 5500 */ {I_VPCMPGTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3470, 244},
+    /* 5501 */ {I_VPCMPGTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3480, 245},
+    /* 5502 */ {I_VPCMPGTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3490, 244},
+    /* 5503 */ {I_VPCMPGTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3500, 244},
+    /* 5504 */ {I_VPCMPGTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3510, 245},
+    /* 5505 */ {I_VPCMPLEB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3520, 244},
+    /* 5506 */ {I_VPCMPLEB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3530, 244},
+    /* 5507 */ {I_VPCMPLEB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3540, 245},
+    /* 5508 */ {I_VPCMPLED, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3550, 240},
+    /* 5509 */ {I_VPCMPLED, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3560, 240},
+    /* 5510 */ {I_VPCMPLED, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3570, 241},
+    /* 5511 */ {I_VPCMPLEQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3580, 240},
+    /* 5512 */ {I_VPCMPLEQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3590, 240},
+    /* 5513 */ {I_VPCMPLEQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3600, 241},
+    /* 5514 */ {I_VPCMPLEUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3610, 244},
+    /* 5515 */ {I_VPCMPLEUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3620, 244},
+    /* 5516 */ {I_VPCMPLEUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3630, 245},
+    /* 5517 */ {I_VPCMPLEUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3640, 240},
+    /* 5518 */ {I_VPCMPLEUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3650, 240},
+    /* 5519 */ {I_VPCMPLEUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3660, 241},
+    /* 5520 */ {I_VPCMPLEUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3670, 240},
+    /* 5521 */ {I_VPCMPLEUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3680, 240},
+    /* 5522 */ {I_VPCMPLEUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3690, 241},
+    /* 5523 */ {I_VPCMPLEUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3700, 244},
+    /* 5524 */ {I_VPCMPLEUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3710, 244},
+    /* 5525 */ {I_VPCMPLEUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3720, 245},
+    /* 5526 */ {I_VPCMPLEW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3730, 244},
+    /* 5527 */ {I_VPCMPLEW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3740, 244},
+    /* 5528 */ {I_VPCMPLEW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3750, 245},
+    /* 5529 */ {I_VPCMPLTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3760, 244},
+    /* 5530 */ {I_VPCMPLTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3770, 244},
+    /* 5531 */ {I_VPCMPLTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3780, 245},
+    /* 5532 */ {I_VPCMPLTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3790, 240},
+    /* 5533 */ {I_VPCMPLTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3800, 240},
+    /* 5534 */ {I_VPCMPLTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3810, 241},
+    /* 5535 */ {I_VPCMPLTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3820, 240},
+    /* 5536 */ {I_VPCMPLTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3830, 240},
+    /* 5537 */ {I_VPCMPLTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3840, 241},
+    /* 5538 */ {I_VPCMPLTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3850, 244},
+    /* 5539 */ {I_VPCMPLTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3860, 244},
+    /* 5540 */ {I_VPCMPLTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3870, 245},
+    /* 5541 */ {I_VPCMPLTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3880, 240},
+    /* 5542 */ {I_VPCMPLTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3890, 240},
+    /* 5543 */ {I_VPCMPLTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3900, 241},
+    /* 5544 */ {I_VPCMPLTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3910, 240},
+    /* 5545 */ {I_VPCMPLTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3920, 240},
+    /* 5546 */ {I_VPCMPLTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3930, 241},
+    /* 5547 */ {I_VPCMPLTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3940, 244},
+    /* 5548 */ {I_VPCMPLTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3950, 244},
+    /* 5549 */ {I_VPCMPLTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3960, 245},
+    /* 5550 */ {I_VPCMPLTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3970, 244},
+    /* 5551 */ {I_VPCMPLTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3980, 244},
+    /* 5552 */ {I_VPCMPLTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3990, 245},
+    /* 5553 */ {I_VPCMPNEQB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4000, 244},
+    /* 5554 */ {I_VPCMPNEQB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4010, 244},
+    /* 5555 */ {I_VPCMPNEQB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4020, 245},
+    /* 5556 */ {I_VPCMPNEQD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4030, 240},
+    /* 5557 */ {I_VPCMPNEQD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4040, 240},
+    /* 5558 */ {I_VPCMPNEQD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4050, 241},
+    /* 5559 */ {I_VPCMPNEQQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4060, 240},
+    /* 5560 */ {I_VPCMPNEQQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4070, 240},
+    /* 5561 */ {I_VPCMPNEQQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4080, 241},
+    /* 5562 */ {I_VPCMPNEQUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4090, 244},
+    /* 5563 */ {I_VPCMPNEQUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4100, 244},
+    /* 5564 */ {I_VPCMPNEQUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4110, 245},
+    /* 5565 */ {I_VPCMPNEQUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4120, 240},
+    /* 5566 */ {I_VPCMPNEQUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4130, 240},
+    /* 5567 */ {I_VPCMPNEQUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+4140, 241},
+    /* 5568 */ {I_VPCMPNEQUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4150, 240},
+    /* 5569 */ {I_VPCMPNEQUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4160, 240},
+    /* 5570 */ {I_VPCMPNEQUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+4170, 241},
+    /* 5571 */ {I_VPCMPNEQUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4180, 244},
+    /* 5572 */ {I_VPCMPNEQUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4190, 244},
+    /* 5573 */ {I_VPCMPNEQUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4200, 245},
+    /* 5574 */ {I_VPCMPNEQW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4210, 244},
+    /* 5575 */ {I_VPCMPNEQW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4220, 244},
+    /* 5576 */ {I_VPCMPNEQW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+4230, 245},
+    /* 5577 */ {I_VPCMPNGTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3520, 244},
+    /* 5578 */ {I_VPCMPNGTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3530, 244},
+    /* 5579 */ {I_VPCMPNGTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3540, 245},
+    /* 5580 */ {I_VPCMPNGTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3550, 240},
+    /* 5581 */ {I_VPCMPNGTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3560, 240},
+    /* 5582 */ {I_VPCMPNGTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3570, 241},
+    /* 5583 */ {I_VPCMPNGTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3580, 240},
+    /* 5584 */ {I_VPCMPNGTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3590, 240},
+    /* 5585 */ {I_VPCMPNGTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3600, 241},
+    /* 5586 */ {I_VPCMPNGTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3610, 244},
+    /* 5587 */ {I_VPCMPNGTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3620, 244},
+    /* 5588 */ {I_VPCMPNGTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3630, 245},
+    /* 5589 */ {I_VPCMPNGTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3640, 240},
+    /* 5590 */ {I_VPCMPNGTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3650, 240},
+    /* 5591 */ {I_VPCMPNGTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3660, 241},
+    /* 5592 */ {I_VPCMPNGTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3670, 240},
+    /* 5593 */ {I_VPCMPNGTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3680, 240},
+    /* 5594 */ {I_VPCMPNGTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3690, 241},
+    /* 5595 */ {I_VPCMPNGTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3700, 244},
+    /* 5596 */ {I_VPCMPNGTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3710, 244},
+    /* 5597 */ {I_VPCMPNGTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3720, 245},
+    /* 5598 */ {I_VPCMPNGTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3730, 244},
+    /* 5599 */ {I_VPCMPNGTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3740, 244},
+    /* 5600 */ {I_VPCMPNGTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3750, 245},
+    /* 5601 */ {I_VPCMPNLEB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3280, 244},
+    /* 5602 */ {I_VPCMPNLEB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3290, 244},
+    /* 5603 */ {I_VPCMPNLEB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3300, 245},
+    /* 5604 */ {I_VPCMPNLED, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3310, 240},
+    /* 5605 */ {I_VPCMPNLED, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3320, 240},
+    /* 5606 */ {I_VPCMPNLED, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3330, 241},
+    /* 5607 */ {I_VPCMPNLEQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3340, 240},
+    /* 5608 */ {I_VPCMPNLEQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3350, 240},
+    /* 5609 */ {I_VPCMPNLEQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3360, 241},
+    /* 5610 */ {I_VPCMPNLEUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3370, 244},
+    /* 5611 */ {I_VPCMPNLEUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3380, 244},
+    /* 5612 */ {I_VPCMPNLEUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3390, 245},
+    /* 5613 */ {I_VPCMPNLEUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3400, 240},
+    /* 5614 */ {I_VPCMPNLEUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3410, 240},
+    /* 5615 */ {I_VPCMPNLEUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3420, 241},
+    /* 5616 */ {I_VPCMPNLEUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3430, 240},
+    /* 5617 */ {I_VPCMPNLEUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3440, 240},
+    /* 5618 */ {I_VPCMPNLEUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3450, 241},
+    /* 5619 */ {I_VPCMPNLEUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3460, 244},
+    /* 5620 */ {I_VPCMPNLEUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3470, 244},
+    /* 5621 */ {I_VPCMPNLEUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3480, 245},
+    /* 5622 */ {I_VPCMPNLEW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3490, 244},
+    /* 5623 */ {I_VPCMPNLEW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3500, 244},
+    /* 5624 */ {I_VPCMPNLEW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3510, 245},
+    /* 5625 */ {I_VPCMPNLTB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3040, 244},
+    /* 5626 */ {I_VPCMPNLTB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3050, 244},
+    /* 5627 */ {I_VPCMPNLTB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3060, 245},
+    /* 5628 */ {I_VPCMPNLTD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3070, 240},
+    /* 5629 */ {I_VPCMPNLTD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3080, 240},
+    /* 5630 */ {I_VPCMPNLTD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3090, 241},
+    /* 5631 */ {I_VPCMPNLTQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3100, 240},
+    /* 5632 */ {I_VPCMPNLTQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3110, 240},
+    /* 5633 */ {I_VPCMPNLTQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3120, 241},
+    /* 5634 */ {I_VPCMPNLTUB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3130, 244},
+    /* 5635 */ {I_VPCMPNLTUB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3140, 244},
+    /* 5636 */ {I_VPCMPNLTUB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3150, 245},
+    /* 5637 */ {I_VPCMPNLTUD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3160, 240},
+    /* 5638 */ {I_VPCMPNLTUD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3170, 240},
+    /* 5639 */ {I_VPCMPNLTUD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+3180, 241},
+    /* 5640 */ {I_VPCMPNLTUQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3190, 240},
+    /* 5641 */ {I_VPCMPNLTUQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3200, 240},
+    /* 5642 */ {I_VPCMPNLTUQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+3210, 241},
+    /* 5643 */ {I_VPCMPNLTUW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3220, 244},
+    /* 5644 */ {I_VPCMPNLTUW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3230, 244},
+    /* 5645 */ {I_VPCMPNLTUW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3240, 245},
+    /* 5646 */ {I_VPCMPNLTW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3250, 244},
+    /* 5647 */ {I_VPCMPNLTW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3260, 244},
+    /* 5648 */ {I_VPCMPNLTW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+3270, 245},
+    /* 5649 */ {I_VPCMPB, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9244, 244},
+    /* 5650 */ {I_VPCMPB, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9253, 244},
+    /* 5651 */ {I_VPCMPB, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9262, 245},
+    /* 5652 */ {I_VPCMPD, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9271, 240},
+    /* 5653 */ {I_VPCMPD, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9280, 240},
+    /* 5654 */ {I_VPCMPD, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9289, 241},
+    /* 5655 */ {I_VPCMPQ, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9298, 240},
+    /* 5656 */ {I_VPCMPQ, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9307, 240},
+    /* 5657 */ {I_VPCMPQ, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9316, 241},
+    /* 5658 */ {I_VPCMPUB, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9325, 244},
+    /* 5659 */ {I_VPCMPUB, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9334, 244},
+    /* 5660 */ {I_VPCMPUB, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9343, 245},
+    /* 5661 */ {I_VPCMPUD, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9352, 240},
+    /* 5662 */ {I_VPCMPUD, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9361, 240},
+    /* 5663 */ {I_VPCMPUD, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B32,0,0}, nasm_bytecodes+9370, 241},
+    /* 5664 */ {I_VPCMPUQ, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9379, 240},
+    /* 5665 */ {I_VPCMPUQ, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9388, 240},
+    /* 5666 */ {I_VPCMPUQ, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,B64,0,0}, nasm_bytecodes+9397, 241},
+    /* 5667 */ {I_VPCMPUW, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9406, 244},
+    /* 5668 */ {I_VPCMPUW, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9415, 244},
+    /* 5669 */ {I_VPCMPUW, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9424, 245},
+    /* 5670 */ {I_VPCMPW, 4, {KREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9433, 244},
+    /* 5671 */ {I_VPCMPW, 4, {KREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9442, 244},
+    /* 5672 */ {I_VPCMPW, 4, {KREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK,0,0,0,0}, nasm_bytecodes+9451, 245},
+    /* 5673 */ {I_VPCOMPRESSD, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22272, 240},
+    /* 5674 */ {I_VPCOMPRESSD, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22280, 240},
+    /* 5675 */ {I_VPCOMPRESSD, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22288, 241},
+    /* 5676 */ {I_VPCOMPRESSD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22296, 240},
+    /* 5677 */ {I_VPCOMPRESSD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22304, 240},
+    /* 5678 */ {I_VPCOMPRESSD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22312, 241},
+    /* 5679 */ {I_VPCOMPRESSQ, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22320, 240},
+    /* 5680 */ {I_VPCOMPRESSQ, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22328, 240},
+    /* 5681 */ {I_VPCOMPRESSQ, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+22336, 241},
+    /* 5682 */ {I_VPCOMPRESSQ, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22344, 240},
+    /* 5683 */ {I_VPCOMPRESSQ, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22352, 240},
+    /* 5684 */ {I_VPCOMPRESSQ, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22360, 241},
+    /* 5685 */ {I_VPCONFLICTD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22368, 248},
+    /* 5686 */ {I_VPCONFLICTD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22376, 248},
+    /* 5687 */ {I_VPCONFLICTD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22384, 249},
+    /* 5688 */ {I_VPCONFLICTQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22392, 248},
+    /* 5689 */ {I_VPCONFLICTQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22400, 248},
+    /* 5690 */ {I_VPCONFLICTQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22408, 249},
+    /* 5691 */ {I_VPERMB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22416, 250},
+    /* 5692 */ {I_VPERMB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22424, 250},
+    /* 5693 */ {I_VPERMB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22432, 250},
+    /* 5694 */ {I_VPERMB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22440, 250},
+    /* 5695 */ {I_VPERMB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22448, 251},
+    /* 5696 */ {I_VPERMB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22456, 251},
+    /* 5697 */ {I_VPERMD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22464, 240},
+    /* 5698 */ {I_VPERMD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22472, 240},
+    /* 5699 */ {I_VPERMD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22480, 241},
+    /* 5700 */ {I_VPERMD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22488, 241},
+    /* 5701 */ {I_VPERMI2B, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22496, 250},
+    /* 5702 */ {I_VPERMI2B, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22504, 250},
+    /* 5703 */ {I_VPERMI2B, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22512, 251},
+    /* 5704 */ {I_VPERMI2D, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22520, 240},
+    /* 5705 */ {I_VPERMI2D, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22528, 240},
+    /* 5706 */ {I_VPERMI2D, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22536, 241},
+    /* 5707 */ {I_VPERMI2PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22544, 240},
+    /* 5708 */ {I_VPERMI2PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22552, 240},
+    /* 5709 */ {I_VPERMI2PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22560, 241},
+    /* 5710 */ {I_VPERMI2PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22568, 240},
+    /* 5711 */ {I_VPERMI2PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22576, 240},
+    /* 5712 */ {I_VPERMI2PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22584, 241},
+    /* 5713 */ {I_VPERMI2Q, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22592, 240},
+    /* 5714 */ {I_VPERMI2Q, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22600, 240},
+    /* 5715 */ {I_VPERMI2Q, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22608, 241},
+    /* 5716 */ {I_VPERMI2W, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22616, 244},
+    /* 5717 */ {I_VPERMI2W, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22624, 244},
+    /* 5718 */ {I_VPERMI2W, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22632, 245},
+    /* 5719 */ {I_VPERMILPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9460, 240},
+    /* 5720 */ {I_VPERMILPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9469, 240},
+    /* 5721 */ {I_VPERMILPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9478, 241},
+    /* 5722 */ {I_VPERMILPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22640, 240},
+    /* 5723 */ {I_VPERMILPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22648, 240},
+    /* 5724 */ {I_VPERMILPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22656, 240},
+    /* 5725 */ {I_VPERMILPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22664, 240},
+    /* 5726 */ {I_VPERMILPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22672, 241},
+    /* 5727 */ {I_VPERMILPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22680, 241},
+    /* 5728 */ {I_VPERMILPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9487, 240},
+    /* 5729 */ {I_VPERMILPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9496, 240},
+    /* 5730 */ {I_VPERMILPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9505, 241},
+    /* 5731 */ {I_VPERMILPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22688, 240},
+    /* 5732 */ {I_VPERMILPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22696, 240},
+    /* 5733 */ {I_VPERMILPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22704, 240},
+    /* 5734 */ {I_VPERMILPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22712, 240},
+    /* 5735 */ {I_VPERMILPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22720, 241},
+    /* 5736 */ {I_VPERMILPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22728, 241},
+    /* 5737 */ {I_VPERMPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9514, 240},
+    /* 5738 */ {I_VPERMPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9523, 241},
+    /* 5739 */ {I_VPERMPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22736, 240},
+    /* 5740 */ {I_VPERMPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22744, 240},
+    /* 5741 */ {I_VPERMPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22752, 241},
+    /* 5742 */ {I_VPERMPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22760, 241},
+    /* 5743 */ {I_VPERMPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22768, 240},
+    /* 5744 */ {I_VPERMPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22776, 240},
+    /* 5745 */ {I_VPERMPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22784, 241},
+    /* 5746 */ {I_VPERMPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+22792, 241},
+    /* 5747 */ {I_VPERMQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9532, 240},
+    /* 5748 */ {I_VPERMQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9541, 241},
+    /* 5749 */ {I_VPERMQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22800, 240},
+    /* 5750 */ {I_VPERMQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22808, 240},
+    /* 5751 */ {I_VPERMQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22816, 241},
+    /* 5752 */ {I_VPERMQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+22824, 241},
+    /* 5753 */ {I_VPERMT2B, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22832, 250},
+    /* 5754 */ {I_VPERMT2B, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22840, 250},
+    /* 5755 */ {I_VPERMT2B, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22848, 251},
+    /* 5756 */ {I_VPERMT2D, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22856, 240},
+    /* 5757 */ {I_VPERMT2D, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22864, 240},
+    /* 5758 */ {I_VPERMT2D, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22872, 241},
+    /* 5759 */ {I_VPERMT2PD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22880, 240},
+    /* 5760 */ {I_VPERMT2PD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22888, 240},
+    /* 5761 */ {I_VPERMT2PD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22896, 241},
+    /* 5762 */ {I_VPERMT2PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22904, 240},
+    /* 5763 */ {I_VPERMT2PS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22912, 240},
+    /* 5764 */ {I_VPERMT2PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+22920, 241},
+    /* 5765 */ {I_VPERMT2Q, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22928, 240},
+    /* 5766 */ {I_VPERMT2Q, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22936, 240},
+    /* 5767 */ {I_VPERMT2Q, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+22944, 241},
+    /* 5768 */ {I_VPERMT2W, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22952, 244},
+    /* 5769 */ {I_VPERMT2W, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22960, 244},
+    /* 5770 */ {I_VPERMT2W, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22968, 245},
+    /* 5771 */ {I_VPERMW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22976, 244},
+    /* 5772 */ {I_VPERMW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22984, 244},
+    /* 5773 */ {I_VPERMW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+22992, 244},
+    /* 5774 */ {I_VPERMW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23000, 244},
+    /* 5775 */ {I_VPERMW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23008, 245},
+    /* 5776 */ {I_VPERMW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23016, 245},
+    /* 5777 */ {I_VPEXPANDD, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23024, 240},
+    /* 5778 */ {I_VPEXPANDD, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23032, 240},
+    /* 5779 */ {I_VPEXPANDD, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23040, 241},
+    /* 5780 */ {I_VPEXPANDD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23024, 240},
+    /* 5781 */ {I_VPEXPANDD, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23032, 240},
+    /* 5782 */ {I_VPEXPANDD, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23040, 241},
+    /* 5783 */ {I_VPEXPANDQ, 2, {XMMREG,MEMORY|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23048, 240},
+    /* 5784 */ {I_VPEXPANDQ, 2, {YMMREG,MEMORY|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23056, 240},
+    /* 5785 */ {I_VPEXPANDQ, 2, {ZMMREG,MEMORY|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23064, 241},
+    /* 5786 */ {I_VPEXPANDQ, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23048, 240},
+    /* 5787 */ {I_VPEXPANDQ, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23056, 240},
+    /* 5788 */ {I_VPEXPANDQ, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23064, 241},
+    /* 5789 */ {I_VPEXTRB, 3, {REG_GPR|BITS8,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    /* 5790 */ {I_VPEXTRB, 3, {REG_GPR|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    /* 5791 */ {I_VPEXTRB, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    /* 5792 */ {I_VPEXTRB, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    /* 5793 */ {I_VPEXTRB, 3, {MEMORY|BITS8,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9550, 245},
+    /* 5794 */ {I_VPEXTRD, 3, {RM_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9559, 243},
+    /* 5795 */ {I_VPEXTRQ, 3, {RM_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9568, 243},
+    /* 5796 */ {I_VPEXTRW, 3, {REG_GPR|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    /* 5797 */ {I_VPEXTRW, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    /* 5798 */ {I_VPEXTRW, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    /* 5799 */ {I_VPEXTRW, 3, {MEMORY|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9577, 245},
+    /* 5800 */ {I_VPEXTRW, 3, {REG_GPR|BITS16,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9586, 245},
+    /* 5801 */ {I_VPEXTRW, 3, {REG_GPR|BITS32,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9586, 245},
+    /* 5802 */ {I_VPEXTRW, 3, {REG_GPR|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9586, 245},
+    /* 5803 */ {I_VPGATHERDD, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9595, 240},
+    /* 5804 */ {I_VPGATHERDD, 2, {YMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9604, 240},
+    /* 5805 */ {I_VPGATHERDD, 2, {ZMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9613, 241},
+    /* 5806 */ {I_VPGATHERDQ, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9622, 240},
+    /* 5807 */ {I_VPGATHERDQ, 2, {YMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9631, 240},
+    /* 5808 */ {I_VPGATHERDQ, 2, {ZMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9640, 241},
+    /* 5809 */ {I_VPGATHERQD, 2, {XMMREG,XMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9649, 240},
+    /* 5810 */ {I_VPGATHERQD, 2, {XMMREG,YMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9658, 240},
+    /* 5811 */ {I_VPGATHERQD, 2, {YMMREG,ZMEM|BITS32,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9667, 241},
+    /* 5812 */ {I_VPGATHERQQ, 2, {XMMREG,XMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9676, 240},
+    /* 5813 */ {I_VPGATHERQQ, 2, {YMMREG,YMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9685, 240},
+    /* 5814 */ {I_VPGATHERQQ, 2, {ZMMREG,ZMEM|BITS64,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9694, 241},
+    /* 5815 */ {I_VPINSRB, 4, {XMMREG,XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9703, 245},
+    /* 5816 */ {I_VPINSRB, 3, {XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9712, 245},
+    /* 5817 */ {I_VPINSRB, 4, {XMMREG,XMMREG,MEMORY|BITS8,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9703, 245},
+    /* 5818 */ {I_VPINSRB, 3, {XMMREG,MEMORY|BITS8,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9712, 245},
+    /* 5819 */ {I_VPINSRD, 4, {XMMREG,XMMREG,RM_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9721, 243},
+    /* 5820 */ {I_VPINSRD, 3, {XMMREG,RM_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9730, 243},
+    /* 5821 */ {I_VPINSRQ, 4, {XMMREG,XMMREG,RM_GPR|BITS64,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9739, 243},
+    /* 5822 */ {I_VPINSRQ, 3, {XMMREG,RM_GPR|BITS64,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9748, 243},
+    /* 5823 */ {I_VPINSRW, 4, {XMMREG,XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9757, 245},
+    /* 5824 */ {I_VPINSRW, 3, {XMMREG,REG_GPR|BITS32,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9766, 245},
+    /* 5825 */ {I_VPINSRW, 4, {XMMREG,XMMREG,MEMORY|BITS16,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+9757, 245},
+    /* 5826 */ {I_VPINSRW, 3, {XMMREG,MEMORY|BITS16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+9766, 245},
+    /* 5827 */ {I_VPLZCNTD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23072, 248},
+    /* 5828 */ {I_VPLZCNTD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23080, 248},
+    /* 5829 */ {I_VPLZCNTD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23088, 249},
+    /* 5830 */ {I_VPLZCNTQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23096, 248},
+    /* 5831 */ {I_VPLZCNTQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23104, 248},
+    /* 5832 */ {I_VPLZCNTQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23112, 249},
+    /* 5833 */ {I_VPMADD52HUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23120, 252},
+    /* 5834 */ {I_VPMADD52HUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23128, 252},
+    /* 5835 */ {I_VPMADD52HUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23136, 253},
+    /* 5836 */ {I_VPMADD52LUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23144, 252},
+    /* 5837 */ {I_VPMADD52LUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23152, 252},
+    /* 5838 */ {I_VPMADD52LUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23160, 253},
+    /* 5839 */ {I_VPMADDUBSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23168, 244},
+    /* 5840 */ {I_VPMADDUBSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23176, 244},
+    /* 5841 */ {I_VPMADDUBSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23184, 244},
+    /* 5842 */ {I_VPMADDUBSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23192, 244},
+    /* 5843 */ {I_VPMADDUBSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23200, 245},
+    /* 5844 */ {I_VPMADDUBSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23208, 245},
+    /* 5845 */ {I_VPMADDWD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23216, 244},
+    /* 5846 */ {I_VPMADDWD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23224, 244},
+    /* 5847 */ {I_VPMADDWD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23232, 244},
+    /* 5848 */ {I_VPMADDWD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23240, 244},
+    /* 5849 */ {I_VPMADDWD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23248, 245},
+    /* 5850 */ {I_VPMADDWD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23256, 245},
+    /* 5851 */ {I_VPMAXSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23264, 244},
+    /* 5852 */ {I_VPMAXSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23272, 244},
+    /* 5853 */ {I_VPMAXSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23280, 244},
+    /* 5854 */ {I_VPMAXSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23288, 244},
+    /* 5855 */ {I_VPMAXSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23296, 245},
+    /* 5856 */ {I_VPMAXSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23304, 245},
+    /* 5857 */ {I_VPMAXSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23312, 240},
+    /* 5858 */ {I_VPMAXSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23320, 240},
+    /* 5859 */ {I_VPMAXSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23328, 240},
+    /* 5860 */ {I_VPMAXSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23336, 240},
+    /* 5861 */ {I_VPMAXSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23344, 241},
+    /* 5862 */ {I_VPMAXSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23352, 241},
+    /* 5863 */ {I_VPMAXSQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23360, 240},
+    /* 5864 */ {I_VPMAXSQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23368, 240},
+    /* 5865 */ {I_VPMAXSQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23376, 240},
+    /* 5866 */ {I_VPMAXSQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23384, 240},
+    /* 5867 */ {I_VPMAXSQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23392, 241},
+    /* 5868 */ {I_VPMAXSQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23400, 241},
+    /* 5869 */ {I_VPMAXSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23408, 244},
+    /* 5870 */ {I_VPMAXSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23416, 244},
+    /* 5871 */ {I_VPMAXSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23424, 244},
+    /* 5872 */ {I_VPMAXSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23432, 244},
+    /* 5873 */ {I_VPMAXSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23440, 245},
+    /* 5874 */ {I_VPMAXSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23448, 245},
+    /* 5875 */ {I_VPMAXUB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23456, 244},
+    /* 5876 */ {I_VPMAXUB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23464, 244},
+    /* 5877 */ {I_VPMAXUB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23472, 244},
+    /* 5878 */ {I_VPMAXUB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23480, 244},
+    /* 5879 */ {I_VPMAXUB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23488, 245},
+    /* 5880 */ {I_VPMAXUB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23496, 245},
+    /* 5881 */ {I_VPMAXUD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23504, 240},
+    /* 5882 */ {I_VPMAXUD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23512, 240},
+    /* 5883 */ {I_VPMAXUD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23520, 240},
+    /* 5884 */ {I_VPMAXUD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23528, 240},
+    /* 5885 */ {I_VPMAXUD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23536, 241},
+    /* 5886 */ {I_VPMAXUD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23544, 241},
+    /* 5887 */ {I_VPMAXUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23552, 240},
+    /* 5888 */ {I_VPMAXUQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23560, 240},
+    /* 5889 */ {I_VPMAXUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23568, 240},
+    /* 5890 */ {I_VPMAXUQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23576, 240},
+    /* 5891 */ {I_VPMAXUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23584, 241},
+    /* 5892 */ {I_VPMAXUQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23592, 241},
+    /* 5893 */ {I_VPMAXUW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23600, 244},
+    /* 5894 */ {I_VPMAXUW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23608, 244},
+    /* 5895 */ {I_VPMAXUW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23616, 244},
+    /* 5896 */ {I_VPMAXUW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23624, 244},
+    /* 5897 */ {I_VPMAXUW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23632, 245},
+    /* 5898 */ {I_VPMAXUW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23640, 245},
+    /* 5899 */ {I_VPMINSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23648, 244},
+    /* 5900 */ {I_VPMINSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23656, 244},
+    /* 5901 */ {I_VPMINSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23664, 244},
+    /* 5902 */ {I_VPMINSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23672, 244},
+    /* 5903 */ {I_VPMINSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23680, 245},
+    /* 5904 */ {I_VPMINSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23688, 245},
+    /* 5905 */ {I_VPMINSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23696, 240},
+    /* 5906 */ {I_VPMINSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23704, 240},
+    /* 5907 */ {I_VPMINSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23712, 240},
+    /* 5908 */ {I_VPMINSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23720, 240},
+    /* 5909 */ {I_VPMINSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23728, 241},
+    /* 5910 */ {I_VPMINSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23736, 241},
+    /* 5911 */ {I_VPMINSQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23744, 240},
+    /* 5912 */ {I_VPMINSQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23752, 240},
+    /* 5913 */ {I_VPMINSQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23760, 240},
+    /* 5914 */ {I_VPMINSQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23768, 240},
+    /* 5915 */ {I_VPMINSQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23776, 241},
+    /* 5916 */ {I_VPMINSQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23784, 241},
+    /* 5917 */ {I_VPMINSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23792, 244},
+    /* 5918 */ {I_VPMINSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23800, 244},
+    /* 5919 */ {I_VPMINSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23808, 244},
+    /* 5920 */ {I_VPMINSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23816, 244},
+    /* 5921 */ {I_VPMINSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23824, 245},
+    /* 5922 */ {I_VPMINSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23832, 245},
+    /* 5923 */ {I_VPMINUB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23840, 244},
+    /* 5924 */ {I_VPMINUB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23848, 244},
+    /* 5925 */ {I_VPMINUB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23856, 244},
+    /* 5926 */ {I_VPMINUB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23864, 244},
+    /* 5927 */ {I_VPMINUB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23872, 245},
+    /* 5928 */ {I_VPMINUB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23880, 245},
+    /* 5929 */ {I_VPMINUD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23888, 240},
+    /* 5930 */ {I_VPMINUD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23896, 240},
+    /* 5931 */ {I_VPMINUD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23904, 240},
+    /* 5932 */ {I_VPMINUD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23912, 240},
+    /* 5933 */ {I_VPMINUD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+23920, 241},
+    /* 5934 */ {I_VPMINUD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+23928, 241},
+    /* 5935 */ {I_VPMINUQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23936, 240},
+    /* 5936 */ {I_VPMINUQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23944, 240},
+    /* 5937 */ {I_VPMINUQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23952, 240},
+    /* 5938 */ {I_VPMINUQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23960, 240},
+    /* 5939 */ {I_VPMINUQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+23968, 241},
+    /* 5940 */ {I_VPMINUQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+23976, 241},
+    /* 5941 */ {I_VPMINUW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23984, 244},
+    /* 5942 */ {I_VPMINUW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+23992, 244},
+    /* 5943 */ {I_VPMINUW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24000, 244},
+    /* 5944 */ {I_VPMINUW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24008, 244},
+    /* 5945 */ {I_VPMINUW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24016, 245},
+    /* 5946 */ {I_VPMINUW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24024, 245},
+    /* 5947 */ {I_VPMOVB2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24032, 244},
+    /* 5948 */ {I_VPMOVB2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24040, 244},
+    /* 5949 */ {I_VPMOVB2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24048, 245},
+    /* 5950 */ {I_VPMOVD2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24056, 242},
+    /* 5951 */ {I_VPMOVD2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24064, 242},
+    /* 5952 */ {I_VPMOVD2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24072, 243},
+    /* 5953 */ {I_VPMOVDB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24080, 240},
+    /* 5954 */ {I_VPMOVDB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24088, 240},
+    /* 5955 */ {I_VPMOVDB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24096, 241},
+    /* 5956 */ {I_VPMOVDB, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24104, 240},
+    /* 5957 */ {I_VPMOVDB, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24112, 240},
+    /* 5958 */ {I_VPMOVDB, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24120, 241},
+    /* 5959 */ {I_VPMOVDW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24128, 240},
+    /* 5960 */ {I_VPMOVDW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24136, 240},
+    /* 5961 */ {I_VPMOVDW, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24144, 241},
+    /* 5962 */ {I_VPMOVDW, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24152, 240},
+    /* 5963 */ {I_VPMOVDW, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24160, 240},
+    /* 5964 */ {I_VPMOVDW, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24168, 241},
+    /* 5965 */ {I_VPMOVM2B, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24176, 244},
+    /* 5966 */ {I_VPMOVM2B, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24184, 244},
+    /* 5967 */ {I_VPMOVM2B, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24192, 245},
+    /* 5968 */ {I_VPMOVM2D, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24200, 242},
+    /* 5969 */ {I_VPMOVM2D, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24208, 242},
+    /* 5970 */ {I_VPMOVM2D, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24216, 243},
+    /* 5971 */ {I_VPMOVM2Q, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24224, 242},
+    /* 5972 */ {I_VPMOVM2Q, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24232, 242},
+    /* 5973 */ {I_VPMOVM2Q, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24240, 243},
+    /* 5974 */ {I_VPMOVM2W, 2, {XMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24248, 244},
+    /* 5975 */ {I_VPMOVM2W, 2, {YMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24256, 244},
+    /* 5976 */ {I_VPMOVM2W, 2, {ZMMREG,KREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24264, 245},
+    /* 5977 */ {I_VPMOVQ2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24272, 242},
+    /* 5978 */ {I_VPMOVQ2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24280, 242},
+    /* 5979 */ {I_VPMOVQ2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+24288, 243},
+    /* 5980 */ {I_VPMOVQB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24296, 240},
+    /* 5981 */ {I_VPMOVQB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24304, 240},
+    /* 5982 */ {I_VPMOVQB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24312, 241},
+    /* 5983 */ {I_VPMOVQB, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24320, 240},
+    /* 5984 */ {I_VPMOVQB, 2, {MEMORY|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24328, 240},
+    /* 5985 */ {I_VPMOVQB, 2, {MEMORY|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24336, 241},
+    /* 5986 */ {I_VPMOVQD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24344, 240},
+    /* 5987 */ {I_VPMOVQD, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24352, 240},
+    /* 5988 */ {I_VPMOVQD, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24360, 241},
+    /* 5989 */ {I_VPMOVQD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24368, 240},
+    /* 5990 */ {I_VPMOVQD, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24376, 240},
+    /* 5991 */ {I_VPMOVQD, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24384, 241},
+    /* 5992 */ {I_VPMOVQW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24392, 240},
+    /* 5993 */ {I_VPMOVQW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24400, 240},
+    /* 5994 */ {I_VPMOVQW, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24408, 241},
+    /* 5995 */ {I_VPMOVQW, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24416, 240},
+    /* 5996 */ {I_VPMOVQW, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24424, 240},
+    /* 5997 */ {I_VPMOVQW, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24432, 241},
+    /* 5998 */ {I_VPMOVSDB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24440, 240},
+    /* 5999 */ {I_VPMOVSDB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24448, 240},
+    /* 6000 */ {I_VPMOVSDB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24456, 241},
+    /* 6001 */ {I_VPMOVSDB, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24464, 240},
+    /* 6002 */ {I_VPMOVSDB, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24472, 240},
+    /* 6003 */ {I_VPMOVSDB, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24480, 241},
+    /* 6004 */ {I_VPMOVSDW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24488, 240},
+    /* 6005 */ {I_VPMOVSDW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24496, 240},
+    /* 6006 */ {I_VPMOVSDW, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24504, 241},
+    /* 6007 */ {I_VPMOVSDW, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24512, 240},
+    /* 6008 */ {I_VPMOVSDW, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24520, 240},
+    /* 6009 */ {I_VPMOVSDW, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24528, 241},
+    /* 6010 */ {I_VPMOVSQB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24536, 240},
+    /* 6011 */ {I_VPMOVSQB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24544, 240},
+    /* 6012 */ {I_VPMOVSQB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24552, 241},
+    /* 6013 */ {I_VPMOVSQB, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24560, 240},
+    /* 6014 */ {I_VPMOVSQB, 2, {MEMORY|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24568, 240},
+    /* 6015 */ {I_VPMOVSQB, 2, {MEMORY|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24576, 241},
+    /* 6016 */ {I_VPMOVSQD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24584, 240},
+    /* 6017 */ {I_VPMOVSQD, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24592, 240},
+    /* 6018 */ {I_VPMOVSQD, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24600, 241},
+    /* 6019 */ {I_VPMOVSQD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24608, 240},
+    /* 6020 */ {I_VPMOVSQD, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24616, 240},
+    /* 6021 */ {I_VPMOVSQD, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24624, 241},
+    /* 6022 */ {I_VPMOVSQW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24632, 240},
+    /* 6023 */ {I_VPMOVSQW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24640, 240},
+    /* 6024 */ {I_VPMOVSQW, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24648, 241},
+    /* 6025 */ {I_VPMOVSQW, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24656, 240},
+    /* 6026 */ {I_VPMOVSQW, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24664, 240},
+    /* 6027 */ {I_VPMOVSQW, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24672, 241},
+    /* 6028 */ {I_VPMOVSWB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24680, 244},
+    /* 6029 */ {I_VPMOVSWB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24688, 244},
+    /* 6030 */ {I_VPMOVSWB, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24696, 245},
+    /* 6031 */ {I_VPMOVSWB, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24704, 244},
+    /* 6032 */ {I_VPMOVSWB, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24712, 244},
+    /* 6033 */ {I_VPMOVSWB, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24720, 245},
+    /* 6034 */ {I_VPMOVSXBD, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24728, 240},
+    /* 6035 */ {I_VPMOVSXBD, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24736, 240},
+    /* 6036 */ {I_VPMOVSXBD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24744, 241},
+    /* 6037 */ {I_VPMOVSXBQ, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24752, 240},
+    /* 6038 */ {I_VPMOVSXBQ, 2, {YMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24760, 240},
+    /* 6039 */ {I_VPMOVSXBQ, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24768, 241},
+    /* 6040 */ {I_VPMOVSXBW, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24776, 244},
+    /* 6041 */ {I_VPMOVSXBW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24784, 244},
+    /* 6042 */ {I_VPMOVSXBW, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24792, 245},
+    /* 6043 */ {I_VPMOVSXDQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24800, 240},
+    /* 6044 */ {I_VPMOVSXDQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24808, 240},
+    /* 6045 */ {I_VPMOVSXDQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24816, 241},
+    /* 6046 */ {I_VPMOVSXWD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24824, 240},
+    /* 6047 */ {I_VPMOVSXWD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24832, 240},
+    /* 6048 */ {I_VPMOVSXWD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24840, 241},
+    /* 6049 */ {I_VPMOVSXWQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24848, 240},
+    /* 6050 */ {I_VPMOVSXWQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24856, 240},
+    /* 6051 */ {I_VPMOVSXWQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24864, 241},
+    /* 6052 */ {I_VPMOVUSDB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24872, 240},
+    /* 6053 */ {I_VPMOVUSDB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24880, 240},
+    /* 6054 */ {I_VPMOVUSDB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24888, 241},
+    /* 6055 */ {I_VPMOVUSDB, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24896, 240},
+    /* 6056 */ {I_VPMOVUSDB, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24904, 240},
+    /* 6057 */ {I_VPMOVUSDB, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24912, 241},
+    /* 6058 */ {I_VPMOVUSDW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24920, 240},
+    /* 6059 */ {I_VPMOVUSDW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24928, 240},
+    /* 6060 */ {I_VPMOVUSDW, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24936, 241},
+    /* 6061 */ {I_VPMOVUSDW, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24944, 240},
+    /* 6062 */ {I_VPMOVUSDW, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24952, 240},
+    /* 6063 */ {I_VPMOVUSDW, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24960, 241},
+    /* 6064 */ {I_VPMOVUSQB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24968, 240},
+    /* 6065 */ {I_VPMOVUSQB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24976, 240},
+    /* 6066 */ {I_VPMOVUSQB, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+24984, 241},
+    /* 6067 */ {I_VPMOVUSQB, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+24992, 240},
+    /* 6068 */ {I_VPMOVUSQB, 2, {MEMORY|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25000, 240},
+    /* 6069 */ {I_VPMOVUSQB, 2, {MEMORY|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25008, 241},
+    /* 6070 */ {I_VPMOVUSQD, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25016, 240},
+    /* 6071 */ {I_VPMOVUSQD, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25024, 240},
+    /* 6072 */ {I_VPMOVUSQD, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25032, 241},
+    /* 6073 */ {I_VPMOVUSQD, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25040, 240},
+    /* 6074 */ {I_VPMOVUSQD, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25048, 240},
+    /* 6075 */ {I_VPMOVUSQD, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25056, 241},
+    /* 6076 */ {I_VPMOVUSQW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25064, 240},
+    /* 6077 */ {I_VPMOVUSQW, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25072, 240},
+    /* 6078 */ {I_VPMOVUSQW, 2, {XMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25080, 241},
+    /* 6079 */ {I_VPMOVUSQW, 2, {MEMORY|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25088, 240},
+    /* 6080 */ {I_VPMOVUSQW, 2, {MEMORY|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25096, 240},
+    /* 6081 */ {I_VPMOVUSQW, 2, {MEMORY|BITS128,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25104, 241},
+    /* 6082 */ {I_VPMOVUSWB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25112, 244},
+    /* 6083 */ {I_VPMOVUSWB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25120, 244},
+    /* 6084 */ {I_VPMOVUSWB, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25128, 245},
+    /* 6085 */ {I_VPMOVUSWB, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25136, 244},
+    /* 6086 */ {I_VPMOVUSWB, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25144, 244},
+    /* 6087 */ {I_VPMOVUSWB, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25152, 245},
+    /* 6088 */ {I_VPMOVW2M, 2, {KREG,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+25160, 244},
+    /* 6089 */ {I_VPMOVW2M, 2, {KREG,YMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+25168, 244},
+    /* 6090 */ {I_VPMOVW2M, 2, {KREG,ZMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+25176, 245},
+    /* 6091 */ {I_VPMOVWB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25184, 244},
+    /* 6092 */ {I_VPMOVWB, 2, {XMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25192, 244},
+    /* 6093 */ {I_VPMOVWB, 2, {YMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25200, 245},
+    /* 6094 */ {I_VPMOVWB, 2, {MEMORY|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25208, 244},
+    /* 6095 */ {I_VPMOVWB, 2, {MEMORY|BITS128,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25216, 244},
+    /* 6096 */ {I_VPMOVWB, 2, {MEMORY|BITS256,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+25224, 245},
+    /* 6097 */ {I_VPMOVZXBD, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25232, 240},
+    /* 6098 */ {I_VPMOVZXBD, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25240, 240},
+    /* 6099 */ {I_VPMOVZXBD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25248, 241},
+    /* 6100 */ {I_VPMOVZXBQ, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25256, 240},
+    /* 6101 */ {I_VPMOVZXBQ, 2, {YMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25264, 240},
+    /* 6102 */ {I_VPMOVZXBQ, 2, {ZMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25272, 241},
+    /* 6103 */ {I_VPMOVZXBW, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25280, 244},
+    /* 6104 */ {I_VPMOVZXBW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25288, 244},
+    /* 6105 */ {I_VPMOVZXBW, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25296, 245},
+    /* 6106 */ {I_VPMOVZXDQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25304, 240},
+    /* 6107 */ {I_VPMOVZXDQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25312, 240},
+    /* 6108 */ {I_VPMOVZXDQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25320, 241},
+    /* 6109 */ {I_VPMOVZXWD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25328, 240},
+    /* 6110 */ {I_VPMOVZXWD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25336, 240},
+    /* 6111 */ {I_VPMOVZXWD, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25344, 241},
+    /* 6112 */ {I_VPMOVZXWQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25352, 240},
+    /* 6113 */ {I_VPMOVZXWQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25360, 240},
+    /* 6114 */ {I_VPMOVZXWQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25368, 241},
+    /* 6115 */ {I_VPMULDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25376, 240},
+    /* 6116 */ {I_VPMULDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25384, 240},
+    /* 6117 */ {I_VPMULDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25392, 240},
+    /* 6118 */ {I_VPMULDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25400, 240},
+    /* 6119 */ {I_VPMULDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25408, 241},
+    /* 6120 */ {I_VPMULDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25416, 241},
+    /* 6121 */ {I_VPMULHRSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25424, 244},
+    /* 6122 */ {I_VPMULHRSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25432, 244},
+    /* 6123 */ {I_VPMULHRSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25440, 244},
+    /* 6124 */ {I_VPMULHRSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25448, 244},
+    /* 6125 */ {I_VPMULHRSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25456, 245},
+    /* 6126 */ {I_VPMULHRSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25464, 245},
+    /* 6127 */ {I_VPMULHUW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25472, 244},
+    /* 6128 */ {I_VPMULHUW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25480, 244},
+    /* 6129 */ {I_VPMULHUW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25488, 244},
+    /* 6130 */ {I_VPMULHUW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25496, 244},
+    /* 6131 */ {I_VPMULHUW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25504, 245},
+    /* 6132 */ {I_VPMULHUW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25512, 245},
+    /* 6133 */ {I_VPMULHW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25520, 244},
+    /* 6134 */ {I_VPMULHW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25528, 244},
+    /* 6135 */ {I_VPMULHW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25536, 244},
+    /* 6136 */ {I_VPMULHW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25544, 244},
+    /* 6137 */ {I_VPMULHW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25552, 245},
+    /* 6138 */ {I_VPMULHW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25560, 245},
+    /* 6139 */ {I_VPMULLD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25568, 240},
+    /* 6140 */ {I_VPMULLD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25576, 240},
+    /* 6141 */ {I_VPMULLD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25584, 240},
+    /* 6142 */ {I_VPMULLD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25592, 240},
+    /* 6143 */ {I_VPMULLD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25600, 241},
+    /* 6144 */ {I_VPMULLD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25608, 241},
+    /* 6145 */ {I_VPMULLQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25616, 242},
+    /* 6146 */ {I_VPMULLQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25624, 242},
+    /* 6147 */ {I_VPMULLQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25632, 242},
+    /* 6148 */ {I_VPMULLQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25640, 242},
+    /* 6149 */ {I_VPMULLQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25648, 243},
+    /* 6150 */ {I_VPMULLQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25656, 243},
+    /* 6151 */ {I_VPMULLW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25664, 244},
+    /* 6152 */ {I_VPMULLW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25672, 244},
+    /* 6153 */ {I_VPMULLW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25680, 244},
+    /* 6154 */ {I_VPMULLW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25688, 244},
+    /* 6155 */ {I_VPMULLW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25696, 245},
+    /* 6156 */ {I_VPMULLW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+25704, 245},
+    /* 6157 */ {I_VPMULTISHIFTQB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25712, 250},
+    /* 6158 */ {I_VPMULTISHIFTQB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25720, 250},
+    /* 6159 */ {I_VPMULTISHIFTQB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25728, 250},
+    /* 6160 */ {I_VPMULTISHIFTQB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25736, 250},
+    /* 6161 */ {I_VPMULTISHIFTQB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25744, 251},
+    /* 6162 */ {I_VPMULTISHIFTQB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25752, 251},
+    /* 6163 */ {I_VPMULUDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25760, 240},
+    /* 6164 */ {I_VPMULUDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25768, 240},
+    /* 6165 */ {I_VPMULUDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25776, 240},
+    /* 6166 */ {I_VPMULUDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25784, 240},
+    /* 6167 */ {I_VPMULUDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25792, 241},
+    /* 6168 */ {I_VPMULUDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25800, 241},
+    /* 6169 */ {I_VPORD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25808, 240},
+    /* 6170 */ {I_VPORD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25816, 240},
+    /* 6171 */ {I_VPORD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25824, 240},
+    /* 6172 */ {I_VPORD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25832, 240},
+    /* 6173 */ {I_VPORD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25840, 241},
+    /* 6174 */ {I_VPORD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25848, 241},
+    /* 6175 */ {I_VPORQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25856, 240},
+    /* 6176 */ {I_VPORQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25864, 240},
+    /* 6177 */ {I_VPORQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25872, 240},
+    /* 6178 */ {I_VPORQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25880, 240},
+    /* 6179 */ {I_VPORQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25888, 241},
+    /* 6180 */ {I_VPORQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25896, 241},
+    /* 6181 */ {I_VPROLD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9775, 240},
+    /* 6182 */ {I_VPROLD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9784, 240},
+    /* 6183 */ {I_VPROLD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9793, 240},
+    /* 6184 */ {I_VPROLD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9802, 240},
+    /* 6185 */ {I_VPROLD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9811, 241},
+    /* 6186 */ {I_VPROLD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9820, 241},
+    /* 6187 */ {I_VPROLQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9829, 240},
+    /* 6188 */ {I_VPROLQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9838, 240},
+    /* 6189 */ {I_VPROLQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9847, 240},
+    /* 6190 */ {I_VPROLQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9856, 240},
+    /* 6191 */ {I_VPROLQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9865, 241},
+    /* 6192 */ {I_VPROLQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9874, 241},
+    /* 6193 */ {I_VPROLVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25904, 240},
+    /* 6194 */ {I_VPROLVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25912, 240},
+    /* 6195 */ {I_VPROLVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25920, 240},
+    /* 6196 */ {I_VPROLVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25928, 240},
+    /* 6197 */ {I_VPROLVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+25936, 241},
+    /* 6198 */ {I_VPROLVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+25944, 241},
+    /* 6199 */ {I_VPROLVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25952, 240},
+    /* 6200 */ {I_VPROLVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25960, 240},
+    /* 6201 */ {I_VPROLVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25968, 240},
+    /* 6202 */ {I_VPROLVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25976, 240},
+    /* 6203 */ {I_VPROLVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+25984, 241},
+    /* 6204 */ {I_VPROLVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+25992, 241},
+    /* 6205 */ {I_VPRORD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9883, 240},
+    /* 6206 */ {I_VPRORD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9892, 240},
+    /* 6207 */ {I_VPRORD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9901, 240},
+    /* 6208 */ {I_VPRORD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9910, 240},
+    /* 6209 */ {I_VPRORD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+9919, 241},
+    /* 6210 */ {I_VPRORD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9928, 241},
+    /* 6211 */ {I_VPRORQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9937, 240},
+    /* 6212 */ {I_VPRORQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9946, 240},
+    /* 6213 */ {I_VPRORQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9955, 240},
+    /* 6214 */ {I_VPRORQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9964, 240},
+    /* 6215 */ {I_VPRORQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+9973, 241},
+    /* 6216 */ {I_VPRORQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+9982, 241},
+    /* 6217 */ {I_VPRORVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26000, 240},
+    /* 6218 */ {I_VPRORVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26008, 240},
+    /* 6219 */ {I_VPRORVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26016, 240},
+    /* 6220 */ {I_VPRORVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26024, 240},
+    /* 6221 */ {I_VPRORVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26032, 241},
+    /* 6222 */ {I_VPRORVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26040, 241},
+    /* 6223 */ {I_VPRORVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26048, 240},
+    /* 6224 */ {I_VPRORVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26056, 240},
+    /* 6225 */ {I_VPRORVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26064, 240},
+    /* 6226 */ {I_VPRORVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26072, 240},
+    /* 6227 */ {I_VPRORVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26080, 241},
+    /* 6228 */ {I_VPRORVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26088, 241},
+    /* 6229 */ {I_VPSADBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+26096, 244},
+    /* 6230 */ {I_VPSADBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+26104, 244},
+    /* 6231 */ {I_VPSADBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+26112, 244},
+    /* 6232 */ {I_VPSADBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+26120, 244},
+    /* 6233 */ {I_VPSADBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, NO_DECORATOR, nasm_bytecodes+26128, 245},
+    /* 6234 */ {I_VPSADBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+26136, 245},
+    /* 6235 */ {I_VPSCATTERDD, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+9991, 240},
+    /* 6236 */ {I_VPSCATTERDD, 2, {YMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10000, 240},
+    /* 6237 */ {I_VPSCATTERDD, 2, {ZMEM|BITS32,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10009, 241},
+    /* 6238 */ {I_VPSCATTERDQ, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10018, 240},
+    /* 6239 */ {I_VPSCATTERDQ, 2, {XMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10027, 240},
+    /* 6240 */ {I_VPSCATTERDQ, 2, {YMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10036, 241},
+    /* 6241 */ {I_VPSCATTERQD, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10045, 240},
+    /* 6242 */ {I_VPSCATTERQD, 2, {YMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10054, 240},
+    /* 6243 */ {I_VPSCATTERQD, 2, {ZMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10063, 241},
+    /* 6244 */ {I_VPSCATTERQQ, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10072, 240},
+    /* 6245 */ {I_VPSCATTERQQ, 2, {YMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10081, 240},
+    /* 6246 */ {I_VPSCATTERQQ, 2, {ZMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+10090, 241},
+    /* 6247 */ {I_VPSHUFB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26144, 244},
+    /* 6248 */ {I_VPSHUFB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26152, 244},
+    /* 6249 */ {I_VPSHUFB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26160, 244},
+    /* 6250 */ {I_VPSHUFB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26168, 244},
+    /* 6251 */ {I_VPSHUFB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26176, 245},
+    /* 6252 */ {I_VPSHUFB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26184, 245},
+    /* 6253 */ {I_VPSHUFD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10099, 240},
+    /* 6254 */ {I_VPSHUFD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10108, 240},
+    /* 6255 */ {I_VPSHUFD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10117, 241},
+    /* 6256 */ {I_VPSHUFHW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10126, 244},
+    /* 6257 */ {I_VPSHUFHW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10135, 244},
+    /* 6258 */ {I_VPSHUFHW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10144, 245},
+    /* 6259 */ {I_VPSHUFLW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10153, 244},
+    /* 6260 */ {I_VPSHUFLW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10162, 244},
+    /* 6261 */ {I_VPSHUFLW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10171, 245},
+    /* 6262 */ {I_VPSLLD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26192, 240},
+    /* 6263 */ {I_VPSLLD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26200, 240},
+    /* 6264 */ {I_VPSLLD, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26208, 240},
+    /* 6265 */ {I_VPSLLD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26216, 240},
+    /* 6266 */ {I_VPSLLD, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26224, 241},
+    /* 6267 */ {I_VPSLLD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26232, 241},
+    /* 6268 */ {I_VPSLLD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10180, 240},
+    /* 6269 */ {I_VPSLLD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10189, 240},
+    /* 6270 */ {I_VPSLLD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10198, 240},
+    /* 6271 */ {I_VPSLLD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10207, 240},
+    /* 6272 */ {I_VPSLLD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10216, 241},
+    /* 6273 */ {I_VPSLLD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10225, 241},
+    /* 6274 */ {I_VPSLLDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10234, 244},
+    /* 6275 */ {I_VPSLLDQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10243, 244},
+    /* 6276 */ {I_VPSLLDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10252, 244},
+    /* 6277 */ {I_VPSLLDQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10261, 244},
+    /* 6278 */ {I_VPSLLDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10270, 245},
+    /* 6279 */ {I_VPSLLDQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10279, 245},
+    /* 6280 */ {I_VPSLLQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26240, 240},
+    /* 6281 */ {I_VPSLLQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26248, 240},
+    /* 6282 */ {I_VPSLLQ, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26256, 240},
+    /* 6283 */ {I_VPSLLQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26264, 240},
+    /* 6284 */ {I_VPSLLQ, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26272, 241},
+    /* 6285 */ {I_VPSLLQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26280, 241},
+    /* 6286 */ {I_VPSLLQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10288, 240},
+    /* 6287 */ {I_VPSLLQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10297, 240},
+    /* 6288 */ {I_VPSLLQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10306, 240},
+    /* 6289 */ {I_VPSLLQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10315, 240},
+    /* 6290 */ {I_VPSLLQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10324, 241},
+    /* 6291 */ {I_VPSLLQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10333, 241},
+    /* 6292 */ {I_VPSLLVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26288, 240},
+    /* 6293 */ {I_VPSLLVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26296, 240},
+    /* 6294 */ {I_VPSLLVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26304, 240},
+    /* 6295 */ {I_VPSLLVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26312, 240},
+    /* 6296 */ {I_VPSLLVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26320, 241},
+    /* 6297 */ {I_VPSLLVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26328, 241},
+    /* 6298 */ {I_VPSLLVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26336, 240},
+    /* 6299 */ {I_VPSLLVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26344, 240},
+    /* 6300 */ {I_VPSLLVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26352, 240},
+    /* 6301 */ {I_VPSLLVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26360, 240},
+    /* 6302 */ {I_VPSLLVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26368, 241},
+    /* 6303 */ {I_VPSLLVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26376, 241},
+    /* 6304 */ {I_VPSLLVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26384, 244},
+    /* 6305 */ {I_VPSLLVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26392, 244},
+    /* 6306 */ {I_VPSLLVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26400, 244},
+    /* 6307 */ {I_VPSLLVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26408, 244},
+    /* 6308 */ {I_VPSLLVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26416, 245},
+    /* 6309 */ {I_VPSLLVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26424, 245},
+    /* 6310 */ {I_VPSLLW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26432, 244},
+    /* 6311 */ {I_VPSLLW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26440, 244},
+    /* 6312 */ {I_VPSLLW, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26448, 244},
+    /* 6313 */ {I_VPSLLW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26456, 244},
+    /* 6314 */ {I_VPSLLW, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26464, 245},
+    /* 6315 */ {I_VPSLLW, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26472, 245},
+    /* 6316 */ {I_VPSLLW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10342, 244},
+    /* 6317 */ {I_VPSLLW, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10351, 244},
+    /* 6318 */ {I_VPSLLW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10360, 244},
+    /* 6319 */ {I_VPSLLW, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10369, 244},
+    /* 6320 */ {I_VPSLLW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10378, 245},
+    /* 6321 */ {I_VPSLLW, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10387, 245},
+    /* 6322 */ {I_VPSRAD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26480, 240},
+    /* 6323 */ {I_VPSRAD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26488, 240},
+    /* 6324 */ {I_VPSRAD, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26496, 240},
+    /* 6325 */ {I_VPSRAD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26504, 240},
+    /* 6326 */ {I_VPSRAD, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26512, 241},
+    /* 6327 */ {I_VPSRAD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26520, 241},
+    /* 6328 */ {I_VPSRAD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10396, 240},
+    /* 6329 */ {I_VPSRAD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10405, 240},
+    /* 6330 */ {I_VPSRAD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10414, 240},
+    /* 6331 */ {I_VPSRAD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10423, 240},
+    /* 6332 */ {I_VPSRAD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10432, 241},
+    /* 6333 */ {I_VPSRAD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10441, 241},
+    /* 6334 */ {I_VPSRAQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26528, 240},
+    /* 6335 */ {I_VPSRAQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26536, 240},
+    /* 6336 */ {I_VPSRAQ, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26544, 240},
+    /* 6337 */ {I_VPSRAQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26552, 240},
+    /* 6338 */ {I_VPSRAQ, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26560, 241},
+    /* 6339 */ {I_VPSRAQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26568, 241},
+    /* 6340 */ {I_VPSRAQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10450, 240},
+    /* 6341 */ {I_VPSRAQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10459, 240},
+    /* 6342 */ {I_VPSRAQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10468, 240},
+    /* 6343 */ {I_VPSRAQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10477, 240},
+    /* 6344 */ {I_VPSRAQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10486, 241},
+    /* 6345 */ {I_VPSRAQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10495, 241},
+    /* 6346 */ {I_VPSRAVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26576, 240},
+    /* 6347 */ {I_VPSRAVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26584, 240},
+    /* 6348 */ {I_VPSRAVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26592, 240},
+    /* 6349 */ {I_VPSRAVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26600, 240},
+    /* 6350 */ {I_VPSRAVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26608, 241},
+    /* 6351 */ {I_VPSRAVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26616, 241},
+    /* 6352 */ {I_VPSRAVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26624, 240},
+    /* 6353 */ {I_VPSRAVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26632, 240},
+    /* 6354 */ {I_VPSRAVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26640, 240},
+    /* 6355 */ {I_VPSRAVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26648, 240},
+    /* 6356 */ {I_VPSRAVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26656, 241},
+    /* 6357 */ {I_VPSRAVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26664, 241},
+    /* 6358 */ {I_VPSRAVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26672, 244},
+    /* 6359 */ {I_VPSRAVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26680, 244},
+    /* 6360 */ {I_VPSRAVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26688, 244},
+    /* 6361 */ {I_VPSRAVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26696, 244},
+    /* 6362 */ {I_VPSRAVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26704, 245},
+    /* 6363 */ {I_VPSRAVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26712, 245},
+    /* 6364 */ {I_VPSRAW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26720, 244},
+    /* 6365 */ {I_VPSRAW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26728, 244},
+    /* 6366 */ {I_VPSRAW, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26736, 244},
+    /* 6367 */ {I_VPSRAW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26744, 244},
+    /* 6368 */ {I_VPSRAW, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26752, 245},
+    /* 6369 */ {I_VPSRAW, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26760, 245},
+    /* 6370 */ {I_VPSRAW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10504, 244},
+    /* 6371 */ {I_VPSRAW, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10513, 244},
+    /* 6372 */ {I_VPSRAW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10522, 244},
+    /* 6373 */ {I_VPSRAW, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10531, 244},
+    /* 6374 */ {I_VPSRAW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10540, 245},
+    /* 6375 */ {I_VPSRAW, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10549, 245},
+    /* 6376 */ {I_VPSRLD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26768, 240},
+    /* 6377 */ {I_VPSRLD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26776, 240},
+    /* 6378 */ {I_VPSRLD, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26784, 240},
+    /* 6379 */ {I_VPSRLD, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26792, 240},
+    /* 6380 */ {I_VPSRLD, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26800, 241},
+    /* 6381 */ {I_VPSRLD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26808, 241},
+    /* 6382 */ {I_VPSRLD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10558, 240},
+    /* 6383 */ {I_VPSRLD, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10567, 240},
+    /* 6384 */ {I_VPSRLD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10576, 240},
+    /* 6385 */ {I_VPSRLD, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10585, 240},
+    /* 6386 */ {I_VPSRLD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10594, 241},
+    /* 6387 */ {I_VPSRLD, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10603, 241},
+    /* 6388 */ {I_VPSRLDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10612, 244},
+    /* 6389 */ {I_VPSRLDQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10621, 244},
+    /* 6390 */ {I_VPSRLDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10630, 244},
+    /* 6391 */ {I_VPSRLDQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10639, 244},
+    /* 6392 */ {I_VPSRLDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+10648, 245},
+    /* 6393 */ {I_VPSRLDQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, NO_DECORATOR, nasm_bytecodes+10657, 245},
+    /* 6394 */ {I_VPSRLQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26816, 240},
+    /* 6395 */ {I_VPSRLQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26824, 240},
+    /* 6396 */ {I_VPSRLQ, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26832, 240},
+    /* 6397 */ {I_VPSRLQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26840, 240},
+    /* 6398 */ {I_VPSRLQ, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26848, 241},
+    /* 6399 */ {I_VPSRLQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26856, 241},
+    /* 6400 */ {I_VPSRLQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10666, 240},
+    /* 6401 */ {I_VPSRLQ, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10675, 240},
+    /* 6402 */ {I_VPSRLQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10684, 240},
+    /* 6403 */ {I_VPSRLQ, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10693, 240},
+    /* 6404 */ {I_VPSRLQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10702, 241},
+    /* 6405 */ {I_VPSRLQ, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10711, 241},
+    /* 6406 */ {I_VPSRLVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26864, 240},
+    /* 6407 */ {I_VPSRLVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26872, 240},
+    /* 6408 */ {I_VPSRLVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26880, 240},
+    /* 6409 */ {I_VPSRLVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26888, 240},
+    /* 6410 */ {I_VPSRLVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+26896, 241},
+    /* 6411 */ {I_VPSRLVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+26904, 241},
+    /* 6412 */ {I_VPSRLVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26912, 240},
+    /* 6413 */ {I_VPSRLVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26920, 240},
+    /* 6414 */ {I_VPSRLVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26928, 240},
+    /* 6415 */ {I_VPSRLVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26936, 240},
+    /* 6416 */ {I_VPSRLVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+26944, 241},
+    /* 6417 */ {I_VPSRLVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+26952, 241},
+    /* 6418 */ {I_VPSRLVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26960, 244},
+    /* 6419 */ {I_VPSRLVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26968, 244},
+    /* 6420 */ {I_VPSRLVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26976, 244},
+    /* 6421 */ {I_VPSRLVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26984, 244},
+    /* 6422 */ {I_VPSRLVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+26992, 245},
+    /* 6423 */ {I_VPSRLVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27000, 245},
+    /* 6424 */ {I_VPSRLW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27008, 244},
+    /* 6425 */ {I_VPSRLW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27016, 244},
+    /* 6426 */ {I_VPSRLW, 3, {YMMREG,YMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27024, 244},
+    /* 6427 */ {I_VPSRLW, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27032, 244},
+    /* 6428 */ {I_VPSRLW, 3, {ZMMREG,ZMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27040, 245},
+    /* 6429 */ {I_VPSRLW, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27048, 245},
+    /* 6430 */ {I_VPSRLW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10720, 244},
+    /* 6431 */ {I_VPSRLW, 2, {XMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10729, 244},
+    /* 6432 */ {I_VPSRLW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10738, 244},
+    /* 6433 */ {I_VPSRLW, 2, {YMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10747, 244},
+    /* 6434 */ {I_VPSRLW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10756, 245},
+    /* 6435 */ {I_VPSRLW, 2, {ZMMREG,IMMEDIATE|BITS8,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+10765, 245},
+    /* 6436 */ {I_VPSUBB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27056, 244},
+    /* 6437 */ {I_VPSUBB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27064, 244},
+    /* 6438 */ {I_VPSUBB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27072, 244},
+    /* 6439 */ {I_VPSUBB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27080, 244},
+    /* 6440 */ {I_VPSUBB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27088, 245},
+    /* 6441 */ {I_VPSUBB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27096, 245},
+    /* 6442 */ {I_VPSUBD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27104, 240},
+    /* 6443 */ {I_VPSUBD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27112, 240},
+    /* 6444 */ {I_VPSUBD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27120, 240},
+    /* 6445 */ {I_VPSUBD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27128, 240},
+    /* 6446 */ {I_VPSUBD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27136, 241},
+    /* 6447 */ {I_VPSUBD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27144, 241},
+    /* 6448 */ {I_VPSUBQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27152, 240},
+    /* 6449 */ {I_VPSUBQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27160, 240},
+    /* 6450 */ {I_VPSUBQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27168, 240},
+    /* 6451 */ {I_VPSUBQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27176, 240},
+    /* 6452 */ {I_VPSUBQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27184, 241},
+    /* 6453 */ {I_VPSUBQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27192, 241},
+    /* 6454 */ {I_VPSUBSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27200, 244},
+    /* 6455 */ {I_VPSUBSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27208, 244},
+    /* 6456 */ {I_VPSUBSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27216, 244},
+    /* 6457 */ {I_VPSUBSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27224, 244},
+    /* 6458 */ {I_VPSUBSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27232, 245},
+    /* 6459 */ {I_VPSUBSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27240, 245},
+    /* 6460 */ {I_VPSUBSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27248, 244},
+    /* 6461 */ {I_VPSUBSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27256, 244},
+    /* 6462 */ {I_VPSUBSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27264, 244},
+    /* 6463 */ {I_VPSUBSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27272, 244},
+    /* 6464 */ {I_VPSUBSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27280, 245},
+    /* 6465 */ {I_VPSUBSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27288, 245},
+    /* 6466 */ {I_VPSUBUSB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27296, 244},
+    /* 6467 */ {I_VPSUBUSB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27304, 244},
+    /* 6468 */ {I_VPSUBUSB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27312, 244},
+    /* 6469 */ {I_VPSUBUSB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27320, 244},
+    /* 6470 */ {I_VPSUBUSB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27328, 245},
+    /* 6471 */ {I_VPSUBUSB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27336, 245},
+    /* 6472 */ {I_VPSUBUSW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27344, 244},
+    /* 6473 */ {I_VPSUBUSW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27352, 244},
+    /* 6474 */ {I_VPSUBUSW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27360, 244},
+    /* 6475 */ {I_VPSUBUSW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27368, 244},
+    /* 6476 */ {I_VPSUBUSW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27376, 245},
+    /* 6477 */ {I_VPSUBUSW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27384, 245},
+    /* 6478 */ {I_VPSUBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27392, 244},
+    /* 6479 */ {I_VPSUBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27400, 244},
+    /* 6480 */ {I_VPSUBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27408, 244},
+    /* 6481 */ {I_VPSUBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27416, 244},
+    /* 6482 */ {I_VPSUBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27424, 245},
+    /* 6483 */ {I_VPSUBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27432, 245},
+    /* 6484 */ {I_VPTERNLOGD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10774, 240},
+    /* 6485 */ {I_VPTERNLOGD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10783, 240},
+    /* 6486 */ {I_VPTERNLOGD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10792, 241},
+    /* 6487 */ {I_VPTERNLOGQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10801, 240},
+    /* 6488 */ {I_VPTERNLOGQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10810, 240},
+    /* 6489 */ {I_VPTERNLOGQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10819, 241},
+    /* 6490 */ {I_VPTESTMB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27440, 244},
+    /* 6491 */ {I_VPTESTMB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27448, 244},
+    /* 6492 */ {I_VPTESTMB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27456, 245},
+    /* 6493 */ {I_VPTESTMD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27464, 240},
+    /* 6494 */ {I_VPTESTMD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27472, 240},
+    /* 6495 */ {I_VPTESTMD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27480, 241},
+    /* 6496 */ {I_VPTESTMQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27488, 240},
+    /* 6497 */ {I_VPTESTMQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27496, 240},
+    /* 6498 */ {I_VPTESTMQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27504, 241},
+    /* 6499 */ {I_VPTESTMW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27512, 244},
+    /* 6500 */ {I_VPTESTMW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27520, 244},
+    /* 6501 */ {I_VPTESTMW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27528, 245},
+    /* 6502 */ {I_VPTESTNMB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27536, 244},
+    /* 6503 */ {I_VPTESTNMB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27544, 244},
+    /* 6504 */ {I_VPTESTNMB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27552, 245},
+    /* 6505 */ {I_VPTESTNMD, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27560, 240},
+    /* 6506 */ {I_VPTESTNMD, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27568, 240},
+    /* 6507 */ {I_VPTESTNMD, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B32,0,0}, nasm_bytecodes+27576, 241},
+    /* 6508 */ {I_VPTESTNMQ, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27584, 240},
+    /* 6509 */ {I_VPTESTNMQ, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27592, 240},
+    /* 6510 */ {I_VPTESTNMQ, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,B64,0,0}, nasm_bytecodes+27600, 241},
+    /* 6511 */ {I_VPTESTNMW, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27608, 244},
+    /* 6512 */ {I_VPTESTNMW, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27616, 244},
+    /* 6513 */ {I_VPTESTNMW, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+27624, 245},
+    /* 6514 */ {I_VPUNPCKHBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27632, 244},
+    /* 6515 */ {I_VPUNPCKHBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27640, 244},
+    /* 6516 */ {I_VPUNPCKHBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27648, 244},
+    /* 6517 */ {I_VPUNPCKHBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27656, 244},
+    /* 6518 */ {I_VPUNPCKHBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27664, 245},
+    /* 6519 */ {I_VPUNPCKHBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27672, 245},
+    /* 6520 */ {I_VPUNPCKHDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27680, 240},
+    /* 6521 */ {I_VPUNPCKHDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27688, 240},
+    /* 6522 */ {I_VPUNPCKHDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27696, 240},
+    /* 6523 */ {I_VPUNPCKHDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27704, 240},
+    /* 6524 */ {I_VPUNPCKHDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27712, 241},
+    /* 6525 */ {I_VPUNPCKHDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27720, 241},
+    /* 6526 */ {I_VPUNPCKHQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27728, 240},
+    /* 6527 */ {I_VPUNPCKHQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27736, 240},
+    /* 6528 */ {I_VPUNPCKHQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27744, 240},
+    /* 6529 */ {I_VPUNPCKHQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27752, 240},
+    /* 6530 */ {I_VPUNPCKHQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27760, 241},
+    /* 6531 */ {I_VPUNPCKHQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27768, 241},
+    /* 6532 */ {I_VPUNPCKHWD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27776, 244},
+    /* 6533 */ {I_VPUNPCKHWD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27784, 244},
+    /* 6534 */ {I_VPUNPCKHWD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27792, 244},
+    /* 6535 */ {I_VPUNPCKHWD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27800, 244},
+    /* 6536 */ {I_VPUNPCKHWD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27808, 245},
+    /* 6537 */ {I_VPUNPCKHWD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27816, 245},
+    /* 6538 */ {I_VPUNPCKLBW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27824, 244},
+    /* 6539 */ {I_VPUNPCKLBW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27832, 244},
+    /* 6540 */ {I_VPUNPCKLBW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27840, 244},
+    /* 6541 */ {I_VPUNPCKLBW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27848, 244},
+    /* 6542 */ {I_VPUNPCKLBW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27856, 245},
+    /* 6543 */ {I_VPUNPCKLBW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27864, 245},
+    /* 6544 */ {I_VPUNPCKLDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27872, 240},
+    /* 6545 */ {I_VPUNPCKLDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27880, 240},
+    /* 6546 */ {I_VPUNPCKLDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27888, 240},
+    /* 6547 */ {I_VPUNPCKLDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27896, 240},
+    /* 6548 */ {I_VPUNPCKLDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+27904, 241},
+    /* 6549 */ {I_VPUNPCKLDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+27912, 241},
+    /* 6550 */ {I_VPUNPCKLQDQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27920, 240},
+    /* 6551 */ {I_VPUNPCKLQDQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27928, 240},
+    /* 6552 */ {I_VPUNPCKLQDQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27936, 240},
+    /* 6553 */ {I_VPUNPCKLQDQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27944, 240},
+    /* 6554 */ {I_VPUNPCKLQDQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+27952, 241},
+    /* 6555 */ {I_VPUNPCKLQDQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+27960, 241},
+    /* 6556 */ {I_VPUNPCKLWD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27968, 244},
+    /* 6557 */ {I_VPUNPCKLWD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27976, 244},
+    /* 6558 */ {I_VPUNPCKLWD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27984, 244},
+    /* 6559 */ {I_VPUNPCKLWD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+27992, 244},
+    /* 6560 */ {I_VPUNPCKLWD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28000, 245},
+    /* 6561 */ {I_VPUNPCKLWD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28008, 245},
+    /* 6562 */ {I_VPXORD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28016, 240},
+    /* 6563 */ {I_VPXORD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28024, 240},
+    /* 6564 */ {I_VPXORD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28032, 240},
+    /* 6565 */ {I_VPXORD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28040, 240},
+    /* 6566 */ {I_VPXORD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28048, 241},
+    /* 6567 */ {I_VPXORD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28056, 241},
+    /* 6568 */ {I_VPXORQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28064, 240},
+    /* 6569 */ {I_VPXORQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28072, 240},
+    /* 6570 */ {I_VPXORQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28080, 240},
+    /* 6571 */ {I_VPXORQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28088, 240},
+    /* 6572 */ {I_VPXORQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28096, 241},
+    /* 6573 */ {I_VPXORQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28104, 241},
+    /* 6574 */ {I_VRANGEPD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10828, 242},
+    /* 6575 */ {I_VRANGEPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10837, 242},
+    /* 6576 */ {I_VRANGEPD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+10846, 242},
+    /* 6577 */ {I_VRANGEPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10855, 242},
+    /* 6578 */ {I_VRANGEPD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64|SAE,0,0}, nasm_bytecodes+10864, 243},
+    /* 6579 */ {I_VRANGEPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+10873, 243},
+    /* 6580 */ {I_VRANGEPS, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10882, 242},
+    /* 6581 */ {I_VRANGEPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10891, 242},
+    /* 6582 */ {I_VRANGEPS, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+10900, 242},
+    /* 6583 */ {I_VRANGEPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10909, 242},
+    /* 6584 */ {I_VRANGEPS, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32|SAE,0,0}, nasm_bytecodes+10918, 243},
+    /* 6585 */ {I_VRANGEPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+10927, 243},
+    /* 6586 */ {I_VRANGESD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+10936, 243},
+    /* 6587 */ {I_VRANGESD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+10945, 243},
+    /* 6588 */ {I_VRANGESS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+10954, 243},
+    /* 6589 */ {I_VRANGESS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+10963, 243},
+    /* 6590 */ {I_VRCP14PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28112, 240},
+    /* 6591 */ {I_VRCP14PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28120, 240},
+    /* 6592 */ {I_VRCP14PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28128, 241},
+    /* 6593 */ {I_VRCP14PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28136, 240},
+    /* 6594 */ {I_VRCP14PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28144, 240},
+    /* 6595 */ {I_VRCP14PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28152, 241},
+    /* 6596 */ {I_VRCP14SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28160, 241},
+    /* 6597 */ {I_VRCP14SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28168, 241},
+    /* 6598 */ {I_VRCP14SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28176, 241},
+    /* 6599 */ {I_VRCP14SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28184, 241},
+    /* 6600 */ {I_VRCP28PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+28192, 246},
+    /* 6601 */ {I_VRCP28PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+28200, 246},
+    /* 6602 */ {I_VRCP28SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28208, 246},
+    /* 6603 */ {I_VRCP28SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28216, 246},
+    /* 6604 */ {I_VRCP28SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28224, 246},
+    /* 6605 */ {I_VRCP28SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28232, 246},
+    /* 6606 */ {I_VREDUCEPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10972, 242},
+    /* 6607 */ {I_VREDUCEPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+10981, 242},
+    /* 6608 */ {I_VREDUCEPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+10990, 243},
+    /* 6609 */ {I_VREDUCEPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+10999, 242},
+    /* 6610 */ {I_VREDUCEPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11008, 242},
+    /* 6611 */ {I_VREDUCEPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+11017, 243},
+    /* 6612 */ {I_VREDUCESD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11026, 243},
+    /* 6613 */ {I_VREDUCESD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11035, 243},
+    /* 6614 */ {I_VREDUCESS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11044, 243},
+    /* 6615 */ {I_VREDUCESS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11053, 243},
+    /* 6616 */ {I_VRNDSCALEPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11062, 240},
+    /* 6617 */ {I_VRNDSCALEPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11071, 240},
+    /* 6618 */ {I_VRNDSCALEPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+11080, 241},
+    /* 6619 */ {I_VRNDSCALEPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11089, 240},
+    /* 6620 */ {I_VRNDSCALEPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11098, 240},
+    /* 6621 */ {I_VRNDSCALEPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+11107, 241},
+    /* 6622 */ {I_VRNDSCALESD, 4, {XMMREG,XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11116, 241},
+    /* 6623 */ {I_VRNDSCALESD, 3, {XMMREG,RM_XMM|BITS64,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11125, 241},
+    /* 6624 */ {I_VRNDSCALESS, 4, {XMMREG,XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+11134, 241},
+    /* 6625 */ {I_VRNDSCALESS, 3, {XMMREG,RM_XMM|BITS32,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+11143, 241},
+    /* 6626 */ {I_VRSQRT14PD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28240, 240},
+    /* 6627 */ {I_VRSQRT14PD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28248, 240},
+    /* 6628 */ {I_VRSQRT14PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28256, 241},
+    /* 6629 */ {I_VRSQRT14PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28264, 240},
+    /* 6630 */ {I_VRSQRT14PS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28272, 240},
+    /* 6631 */ {I_VRSQRT14PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28280, 241},
+    /* 6632 */ {I_VRSQRT14SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28288, 241},
+    /* 6633 */ {I_VRSQRT14SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28296, 241},
+    /* 6634 */ {I_VRSQRT14SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28304, 241},
+    /* 6635 */ {I_VRSQRT14SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+28312, 241},
+    /* 6636 */ {I_VRSQRT28PD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|SAE,0,0,0}, nasm_bytecodes+28320, 246},
+    /* 6637 */ {I_VRSQRT28PS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|SAE,0,0,0}, nasm_bytecodes+28328, 246},
+    /* 6638 */ {I_VRSQRT28SD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28336, 246},
+    /* 6639 */ {I_VRSQRT28SD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28344, 246},
+    /* 6640 */ {I_VRSQRT28SS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+28352, 246},
+    /* 6641 */ {I_VRSQRT28SS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+28360, 246},
+    /* 6642 */ {I_VSCALEFPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28368, 240},
+    /* 6643 */ {I_VSCALEFPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28376, 240},
+    /* 6644 */ {I_VSCALEFPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28384, 240},
+    /* 6645 */ {I_VSCALEFPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28392, 240},
+    /* 6646 */ {I_VSCALEFPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+28400, 241},
+    /* 6647 */ {I_VSCALEFPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+28408, 241},
+    /* 6648 */ {I_VSCALEFPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28416, 240},
+    /* 6649 */ {I_VSCALEFPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28424, 240},
+    /* 6650 */ {I_VSCALEFPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28432, 240},
+    /* 6651 */ {I_VSCALEFPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28440, 240},
+    /* 6652 */ {I_VSCALEFPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+28448, 241},
+    /* 6653 */ {I_VSCALEFPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+28456, 241},
+    /* 6654 */ {I_VSCALEFSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28464, 241},
+    /* 6655 */ {I_VSCALEFSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28472, 241},
+    /* 6656 */ {I_VSCALEFSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28480, 241},
+    /* 6657 */ {I_VSCALEFSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28488, 241},
+    /* 6658 */ {I_VSCATTERDPD, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11152, 240},
+    /* 6659 */ {I_VSCATTERDPD, 2, {XMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11161, 240},
+    /* 6660 */ {I_VSCATTERDPD, 2, {YMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11170, 241},
+    /* 6661 */ {I_VSCATTERDPS, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11179, 240},
+    /* 6662 */ {I_VSCATTERDPS, 2, {YMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11188, 240},
+    /* 6663 */ {I_VSCATTERDPS, 2, {ZMEM|BITS32,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11197, 241},
+    /* 6664 */ {I_VSCATTERPF0DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11206, 247},
+    /* 6665 */ {I_VSCATTERPF0DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11215, 247},
+    /* 6666 */ {I_VSCATTERPF0QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11224, 247},
+    /* 6667 */ {I_VSCATTERPF0QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11233, 247},
+    /* 6668 */ {I_VSCATTERPF1DPD, 1, {YMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11242, 247},
+    /* 6669 */ {I_VSCATTERPF1DPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11251, 247},
+    /* 6670 */ {I_VSCATTERPF1QPD, 1, {ZMEM|BITS64,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11260, 247},
+    /* 6671 */ {I_VSCATTERPF1QPS, 1, {ZMEM|BITS32,0,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11269, 247},
+    /* 6672 */ {I_VSCATTERQPD, 2, {XMEM|BITS64,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11278, 240},
+    /* 6673 */ {I_VSCATTERQPD, 2, {YMEM|BITS64,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11287, 240},
+    /* 6674 */ {I_VSCATTERQPD, 2, {ZMEM|BITS64,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11296, 241},
+    /* 6675 */ {I_VSCATTERQPS, 2, {XMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11305, 240},
+    /* 6676 */ {I_VSCATTERQPS, 2, {YMEM|BITS32,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11314, 240},
+    /* 6677 */ {I_VSCATTERQPS, 2, {ZMEM|BITS32,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+11323, 241},
+    /* 6678 */ {I_VSHUFF32X4, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11332, 240},
+    /* 6679 */ {I_VSHUFF32X4, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11341, 240},
+    /* 6680 */ {I_VSHUFF32X4, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11350, 241},
+    /* 6681 */ {I_VSHUFF32X4, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11359, 241},
+    /* 6682 */ {I_VSHUFF64X2, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11368, 240},
+    /* 6683 */ {I_VSHUFF64X2, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11377, 240},
+    /* 6684 */ {I_VSHUFF64X2, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11386, 241},
+    /* 6685 */ {I_VSHUFF64X2, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11395, 241},
+    /* 6686 */ {I_VSHUFI32X4, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11404, 240},
+    /* 6687 */ {I_VSHUFI32X4, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11413, 240},
+    /* 6688 */ {I_VSHUFI32X4, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11422, 241},
+    /* 6689 */ {I_VSHUFI32X4, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11431, 241},
+    /* 6690 */ {I_VSHUFI64X2, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11440, 240},
+    /* 6691 */ {I_VSHUFI64X2, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11449, 240},
+    /* 6692 */ {I_VSHUFI64X2, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11458, 241},
+    /* 6693 */ {I_VSHUFI64X2, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11467, 241},
+    /* 6694 */ {I_VSHUFPD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11476, 240},
+    /* 6695 */ {I_VSHUFPD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11485, 240},
+    /* 6696 */ {I_VSHUFPD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11494, 240},
+    /* 6697 */ {I_VSHUFPD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11503, 240},
+    /* 6698 */ {I_VSHUFPD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11512, 241},
+    /* 6699 */ {I_VSHUFPD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11521, 241},
+    /* 6700 */ {I_VSHUFPS, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11530, 240},
+    /* 6701 */ {I_VSHUFPS, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11539, 240},
+    /* 6702 */ {I_VSHUFPS, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11548, 240},
+    /* 6703 */ {I_VSHUFPS, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11557, 240},
+    /* 6704 */ {I_VSHUFPS, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11566, 241},
+    /* 6705 */ {I_VSHUFPS, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11575, 241},
+    /* 6706 */ {I_VSQRTPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28496, 240},
+    /* 6707 */ {I_VSQRTPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28504, 240},
+    /* 6708 */ {I_VSQRTPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+28512, 241},
+    /* 6709 */ {I_VSQRTPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28520, 240},
+    /* 6710 */ {I_VSQRTPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28528, 240},
+    /* 6711 */ {I_VSQRTPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+28536, 241},
+    /* 6712 */ {I_VSQRTSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28544, 241},
+    /* 6713 */ {I_VSQRTSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28552, 241},
+    /* 6714 */ {I_VSQRTSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28560, 241},
+    /* 6715 */ {I_VSQRTSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28568, 241},
+    /* 6716 */ {I_VSUBPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28576, 240},
+    /* 6717 */ {I_VSUBPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28584, 240},
+    /* 6718 */ {I_VSUBPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28592, 240},
+    /* 6719 */ {I_VSUBPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28600, 240},
+    /* 6720 */ {I_VSUBPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64|ER,0,0}, nasm_bytecodes+28608, 241},
+    /* 6721 */ {I_VSUBPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+28616, 241},
+    /* 6722 */ {I_VSUBPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28624, 240},
+    /* 6723 */ {I_VSUBPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28632, 240},
+    /* 6724 */ {I_VSUBPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28640, 240},
+    /* 6725 */ {I_VSUBPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28648, 240},
+    /* 6726 */ {I_VSUBPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+28656, 241},
+    /* 6727 */ {I_VSUBPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+28664, 241},
+    /* 6728 */ {I_VSUBSD, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28672, 241},
+    /* 6729 */ {I_VSUBSD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28680, 241},
+    /* 6730 */ {I_VSUBSS, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+28688, 241},
+    /* 6731 */ {I_VSUBSS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+28696, 241},
+    /* 6732 */ {I_VUCOMISD, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+28704, 241},
+    /* 6733 */ {I_VUCOMISS, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+28712, 241},
+    /* 6734 */ {I_VUNPCKHPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28720, 240},
+    /* 6735 */ {I_VUNPCKHPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28728, 240},
+    /* 6736 */ {I_VUNPCKHPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28736, 240},
+    /* 6737 */ {I_VUNPCKHPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28744, 240},
+    /* 6738 */ {I_VUNPCKHPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28752, 241},
+    /* 6739 */ {I_VUNPCKHPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28760, 241},
+    /* 6740 */ {I_VUNPCKHPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28768, 240},
+    /* 6741 */ {I_VUNPCKHPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28776, 240},
+    /* 6742 */ {I_VUNPCKHPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28784, 240},
+    /* 6743 */ {I_VUNPCKHPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28792, 240},
+    /* 6744 */ {I_VUNPCKHPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28800, 241},
+    /* 6745 */ {I_VUNPCKHPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28808, 241},
+    /* 6746 */ {I_VUNPCKLPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28816, 240},
+    /* 6747 */ {I_VUNPCKLPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28824, 240},
+    /* 6748 */ {I_VUNPCKLPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28832, 240},
+    /* 6749 */ {I_VUNPCKLPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28840, 240},
+    /* 6750 */ {I_VUNPCKLPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28848, 241},
+    /* 6751 */ {I_VUNPCKLPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28856, 241},
+    /* 6752 */ {I_VUNPCKLPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28864, 240},
+    /* 6753 */ {I_VUNPCKLPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28872, 240},
+    /* 6754 */ {I_VUNPCKLPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28880, 240},
+    /* 6755 */ {I_VUNPCKLPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28888, 240},
+    /* 6756 */ {I_VUNPCKLPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28896, 241},
+    /* 6757 */ {I_VUNPCKLPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28904, 241},
+    /* 6758 */ {I_VXORPD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28912, 242},
+    /* 6759 */ {I_VXORPD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28920, 242},
+    /* 6760 */ {I_VXORPD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28928, 242},
+    /* 6761 */ {I_VXORPD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28936, 242},
+    /* 6762 */ {I_VXORPD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+28944, 243},
+    /* 6763 */ {I_VXORPD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+28952, 243},
+    /* 6764 */ {I_VXORPS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28960, 242},
+    /* 6765 */ {I_VXORPS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28968, 242},
+    /* 6766 */ {I_VXORPS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28976, 242},
+    /* 6767 */ {I_VXORPS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+28984, 242},
+    /* 6768 */ {I_VXORPS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+28992, 243},
+    /* 6769 */ {I_VXORPS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29000, 243},
+    /* 6770 */ {I_RDPKRU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46072, 136},
+    /* 6771 */ {I_WRPKRU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46078, 136},
+    /* 6772 */ {I_RDPID, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42322, 254},
+    /* 6773 */ {I_RDPID, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42321, 136},
+    /* 6774 */ {I_RDPID, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42322, 255},
+    /* 6775 */ {I_CLFLUSHOPT, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45951, 135},
+    /* 6776 */ {I_CLWB, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45957, 135},
+    /* 6777 */ {I_PCOMMIT, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45963, 256},
+    /* 6778 */ {I_CLZERO, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45982, 257},
+    /* 6779 */ {I_PTWRITE, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34020, 135},
+    /* 6780 */ {I_PTWRITE, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+34019, 136},
+    /* 6781 */ {I_CLDEMOTE, 1, {MEMORY,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45987, 135},
+    /* 6782 */ {I_MOVDIRI, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42328, 260},
+    /* 6783 */ {I_MOVDIRI, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42335, 261},
+    /* 6784 */ {I_MOVDIR64B, 2, {REG_GPR|BITS16,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29008, 254},
+    /* 6785 */ {I_MOVDIR64B, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29016, 135},
+    /* 6786 */ {I_MOVDIR64B, 2, {REG_GPR|BITS64,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+11584, 136},
+    /* 6787 */ {I_PCONFIG, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45993, 135},
+    /* 6788 */ {I_TPAUSE, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45957, 135},
+    /* 6789 */ {I_UMONITOR, 1, {REG_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42342, 254},
+    /* 6790 */ {I_UMONITOR, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42349, 135},
+    /* 6791 */ {I_UMONITOR, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+29024, 136},
+    /* 6792 */ {I_UMWAIT, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45999, 135},
+    /* 6793 */ {I_WBNOINVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49182, 135},
+    /* 6794 */ {I_GF2P8AFFINEINVQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29032, 262},
+    /* 6795 */ {I_VGF2P8AFFINEINVQB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29040, 263},
+    /* 6796 */ {I_VGF2P8AFFINEINVQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29048, 263},
+    /* 6797 */ {I_VGF2P8AFFINEINVQB, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29056, 263},
+    /* 6798 */ {I_VGF2P8AFFINEINVQB, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29064, 263},
+    /* 6799 */ {I_VGF2P8AFFINEINVQB, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11593, 264},
+    /* 6800 */ {I_VGF2P8AFFINEINVQB, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11602, 264},
+    /* 6801 */ {I_VGF2P8AFFINEINVQB, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11611, 264},
+    /* 6802 */ {I_VGF2P8AFFINEINVQB, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11620, 264},
+    /* 6803 */ {I_VGF2P8AFFINEINVQB, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11629, 265},
+    /* 6804 */ {I_VGF2P8AFFINEINVQB, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11638, 265},
+    /* 6805 */ {I_GF2P8AFFINEQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29072, 262},
+    /* 6806 */ {I_VGF2P8AFFINEQB, 4, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29080, 263},
+    /* 6807 */ {I_VGF2P8AFFINEQB, 3, {XMM_L16,RM_XMM_L16|BITS128,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29088, 263},
+    /* 6808 */ {I_VGF2P8AFFINEQB, 4, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0}, NO_DECORATOR, nasm_bytecodes+29096, 263},
+    /* 6809 */ {I_VGF2P8AFFINEQB, 3, {YMM_L16,RM_YMM_L16|BITS256,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+29104, 263},
+    /* 6810 */ {I_VGF2P8AFFINEQB, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11647, 264},
+    /* 6811 */ {I_VGF2P8AFFINEQB, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11656, 264},
+    /* 6812 */ {I_VGF2P8AFFINEQB, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11665, 264},
+    /* 6813 */ {I_VGF2P8AFFINEQB, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11674, 264},
+    /* 6814 */ {I_VGF2P8AFFINEQB, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11683, 265},
+    /* 6815 */ {I_VGF2P8AFFINEQB, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11692, 265},
+    /* 6816 */ {I_GF2P8MULB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+42356, 262},
+    /* 6817 */ {I_VGF2P8MULB, 3, {XMM_L16,XMM_L16,RM_XMM_L16|BITS128,0,0}, NO_DECORATOR, nasm_bytecodes+42363, 263},
+    /* 6818 */ {I_VGF2P8MULB, 2, {XMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+42370, 263},
+    /* 6819 */ {I_VGF2P8MULB, 3, {YMM_L16,YMM_L16,RM_YMM_L16|BITS256,0,0}, NO_DECORATOR, nasm_bytecodes+42377, 263},
+    /* 6820 */ {I_VGF2P8MULB, 2, {YMM_L16,RM_YMM_L16|BITS256,0,0,0}, NO_DECORATOR, nasm_bytecodes+42384, 263},
+    /* 6821 */ {I_VGF2P8MULB, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29112, 264},
+    /* 6822 */ {I_VGF2P8MULB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29120, 264},
+    /* 6823 */ {I_VGF2P8MULB, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29128, 264},
+    /* 6824 */ {I_VGF2P8MULB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29136, 264},
+    /* 6825 */ {I_VGF2P8MULB, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29144, 265},
+    /* 6826 */ {I_VGF2P8MULB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29152, 265},
+    /* 6827 */ {I_VPCOMPRESSB, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29160, 266},
+    /* 6828 */ {I_VPCOMPRESSB, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29168, 266},
+    /* 6829 */ {I_VPCOMPRESSB, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29176, 267},
+    /* 6830 */ {I_VPCOMPRESSB, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29184, 266},
+    /* 6831 */ {I_VPCOMPRESSB, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29192, 266},
+    /* 6832 */ {I_VPCOMPRESSB, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29200, 267},
+    /* 6833 */ {I_VPCOMPRESSW, 2, {MEMORY|BITS128,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29208, 266},
+    /* 6834 */ {I_VPCOMPRESSW, 2, {MEMORY|BITS256,YMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29216, 266},
+    /* 6835 */ {I_VPCOMPRESSW, 2, {MEMORY|BITS512,ZMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29224, 267},
+    /* 6836 */ {I_VPCOMPRESSW, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29232, 266},
+    /* 6837 */ {I_VPCOMPRESSW, 2, {YMMREG,YMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29240, 266},
+    /* 6838 */ {I_VPCOMPRESSW, 2, {ZMMREG,ZMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29248, 267},
+    /* 6839 */ {I_VPEXPANDB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29256, 266},
+    /* 6840 */ {I_VPEXPANDB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29264, 266},
+    /* 6841 */ {I_VPEXPANDB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29272, 267},
+    /* 6842 */ {I_VPEXPANDW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29280, 266},
+    /* 6843 */ {I_VPEXPANDW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29288, 266},
+    /* 6844 */ {I_VPEXPANDW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29296, 267},
+    /* 6845 */ {I_VPSHLDW, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11701, 266},
+    /* 6846 */ {I_VPSHLDW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11710, 266},
+    /* 6847 */ {I_VPSHLDW, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11719, 266},
+    /* 6848 */ {I_VPSHLDW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11728, 266},
+    /* 6849 */ {I_VPSHLDW, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11737, 267},
+    /* 6850 */ {I_VPSHLDW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11746, 267},
+    /* 6851 */ {I_VPSHLDD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11755, 266},
+    /* 6852 */ {I_VPSHLDD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11764, 266},
+    /* 6853 */ {I_VPSHLDD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11773, 266},
+    /* 6854 */ {I_VPSHLDD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11782, 266},
+    /* 6855 */ {I_VPSHLDD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11791, 267},
+    /* 6856 */ {I_VPSHLDD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11800, 267},
+    /* 6857 */ {I_VPSHLDQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11809, 266},
+    /* 6858 */ {I_VPSHLDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11818, 266},
+    /* 6859 */ {I_VPSHLDQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11827, 266},
+    /* 6860 */ {I_VPSHLDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11836, 266},
+    /* 6861 */ {I_VPSHLDQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11845, 267},
+    /* 6862 */ {I_VPSHLDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11854, 267},
+    /* 6863 */ {I_VPSHLDVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29304, 266},
+    /* 6864 */ {I_VPSHLDVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29312, 266},
+    /* 6865 */ {I_VPSHLDVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29320, 266},
+    /* 6866 */ {I_VPSHLDVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29328, 266},
+    /* 6867 */ {I_VPSHLDVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29336, 267},
+    /* 6868 */ {I_VPSHLDVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29344, 267},
+    /* 6869 */ {I_VPSHLDVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29352, 266},
+    /* 6870 */ {I_VPSHLDVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29360, 266},
+    /* 6871 */ {I_VPSHLDVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29368, 266},
+    /* 6872 */ {I_VPSHLDVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29376, 266},
+    /* 6873 */ {I_VPSHLDVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29384, 267},
+    /* 6874 */ {I_VPSHLDVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29392, 267},
+    /* 6875 */ {I_VPSHLDVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29400, 266},
+    /* 6876 */ {I_VPSHLDVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29408, 266},
+    /* 6877 */ {I_VPSHLDVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29416, 266},
+    /* 6878 */ {I_VPSHLDVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29424, 266},
+    /* 6879 */ {I_VPSHLDVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29432, 267},
+    /* 6880 */ {I_VPSHLDVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29440, 267},
+    /* 6881 */ {I_VPSHRDW, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11863, 266},
+    /* 6882 */ {I_VPSHRDW, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11872, 266},
+    /* 6883 */ {I_VPSHRDW, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11881, 266},
+    /* 6884 */ {I_VPSHRDW, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11890, 266},
+    /* 6885 */ {I_VPSHRDW, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11899, 267},
+    /* 6886 */ {I_VPSHRDW, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+11908, 267},
+    /* 6887 */ {I_VPSHRDD, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11917, 266},
+    /* 6888 */ {I_VPSHRDD, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11926, 266},
+    /* 6889 */ {I_VPSHRDD, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11935, 266},
+    /* 6890 */ {I_VPSHRDD, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11944, 266},
+    /* 6891 */ {I_VPSHRDD, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+11953, 267},
+    /* 6892 */ {I_VPSHRDD, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+11962, 267},
+    /* 6893 */ {I_VPSHRDQ, 4, {XMMREG,XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11971, 266},
+    /* 6894 */ {I_VPSHRDQ, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11980, 266},
+    /* 6895 */ {I_VPSHRDQ, 4, {YMMREG,YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+11989, 266},
+    /* 6896 */ {I_VPSHRDQ, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+11998, 266},
+    /* 6897 */ {I_VPSHRDQ, 4, {ZMMREG,ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+12007, 267},
+    /* 6898 */ {I_VPSHRDQ, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+12016, 267},
+    /* 6899 */ {I_VPSHRDVW, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29448, 266},
+    /* 6900 */ {I_VPSHRDVW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29456, 266},
+    /* 6901 */ {I_VPSHRDVW, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29464, 266},
+    /* 6902 */ {I_VPSHRDVW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29472, 266},
+    /* 6903 */ {I_VPSHRDVW, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29480, 267},
+    /* 6904 */ {I_VPSHRDVW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29488, 267},
+    /* 6905 */ {I_VPSHRDVD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29496, 266},
+    /* 6906 */ {I_VPSHRDVD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29504, 266},
+    /* 6907 */ {I_VPSHRDVD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29512, 266},
+    /* 6908 */ {I_VPSHRDVD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29520, 266},
+    /* 6909 */ {I_VPSHRDVD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29528, 267},
+    /* 6910 */ {I_VPSHRDVD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29536, 267},
+    /* 6911 */ {I_VPSHRDVQ, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29544, 266},
+    /* 6912 */ {I_VPSHRDVQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29552, 266},
+    /* 6913 */ {I_VPSHRDVQ, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29560, 266},
+    /* 6914 */ {I_VPSHRDVQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29568, 266},
+    /* 6915 */ {I_VPSHRDVQ, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B64,0,0}, nasm_bytecodes+29576, 267},
+    /* 6916 */ {I_VPSHRDVQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+29584, 267},
+    /* 6917 */ {I_VPDPBUSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29592, 268},
+    /* 6918 */ {I_VPDPBUSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29600, 268},
+    /* 6919 */ {I_VPDPBUSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29608, 268},
+    /* 6920 */ {I_VPDPBUSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29616, 268},
+    /* 6921 */ {I_VPDPBUSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29624, 269},
+    /* 6922 */ {I_VPDPBUSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29632, 269},
+    /* 6923 */ {I_VPDPBUSDS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29640, 268},
+    /* 6924 */ {I_VPDPBUSDS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29648, 268},
+    /* 6925 */ {I_VPDPBUSDS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29656, 268},
+    /* 6926 */ {I_VPDPBUSDS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29664, 268},
+    /* 6927 */ {I_VPDPBUSDS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29672, 269},
+    /* 6928 */ {I_VPDPBUSDS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29680, 269},
+    /* 6929 */ {I_VPDPWSSD, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29688, 268},
+    /* 6930 */ {I_VPDPWSSD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29696, 268},
+    /* 6931 */ {I_VPDPWSSD, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29704, 268},
+    /* 6932 */ {I_VPDPWSSD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29712, 268},
+    /* 6933 */ {I_VPDPWSSD, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29720, 269},
+    /* 6934 */ {I_VPDPWSSD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29728, 269},
+    /* 6935 */ {I_VPDPWSSDS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29736, 268},
+    /* 6936 */ {I_VPDPWSSDS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29744, 268},
+    /* 6937 */ {I_VPDPWSSDS, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29752, 268},
+    /* 6938 */ {I_VPDPWSSDS, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29760, 268},
+    /* 6939 */ {I_VPDPWSSDS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+29768, 269},
+    /* 6940 */ {I_VPDPWSSDS, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+29776, 269},
+    /* 6941 */ {I_VPOPCNTB, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29784, 270},
+    /* 6942 */ {I_VPOPCNTB, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29792, 270},
+    /* 6943 */ {I_VPOPCNTB, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29800, 271},
+    /* 6944 */ {I_VPOPCNTW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29808, 270},
+    /* 6945 */ {I_VPOPCNTW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29816, 270},
+    /* 6946 */ {I_VPOPCNTW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29824, 271},
+    /* 6947 */ {I_VPOPCNTD, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29832, 272},
+    /* 6948 */ {I_VPOPCNTD, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29840, 272},
+    /* 6949 */ {I_VPOPCNTD, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29848, 273},
+    /* 6950 */ {I_VPOPCNTQ, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29856, 272},
+    /* 6951 */ {I_VPOPCNTQ, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29864, 272},
+    /* 6952 */ {I_VPOPCNTQ, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29872, 273},
+    /* 6953 */ {I_VPSHUFBITQMB, 3, {KREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29880, 270},
+    /* 6954 */ {I_VPSHUFBITQMB, 3, {KREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29888, 270},
+    /* 6955 */ {I_VPSHUFBITQMB, 3, {KREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+29896, 271},
+    /* 6956 */ {I_V4FMADDPS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29904, 274},
+    /* 6957 */ {I_V4FNMADDPS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29912, 274},
+    /* 6958 */ {I_V4FMADDSS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29920, 274},
+    /* 6959 */ {I_V4FNMADDSS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29928, 274},
+    /* 6960 */ {I_V4DPWSSDS, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29936, 275},
+    /* 6961 */ {I_V4DPWSSD, 3, {ZMM_L16,ZMM_L16|RS4,MEMORY,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+29944, 275},
+    /* 6962 */ {I_ENCLS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46005, 276},
+    /* 6963 */ {I_ENCLU, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46011, 276},
+    /* 6964 */ {I_ENCLV, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46017, 276},
+    /* 6965 */ {I_CLRSSBSY, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42350, 277},
+    /* 6966 */ {I_ENDBR32, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46023, 277},
+    /* 6967 */ {I_ENDBR64, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46029, 277},
+    /* 6968 */ {I_INCSSPD, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42391, 277},
+    /* 6969 */ {I_INCSSPQ, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42398, 278},
+    /* 6970 */ {I_RDSSPD, 1, {REG_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42405, 277},
+    /* 6971 */ {I_RDSSPQ, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42412, 278},
+    /* 6972 */ {I_RSTORSSP, 1, {MEMORY|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46035, 277},
+    /* 6973 */ {I_SAVEPREVSSP, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46041, 277},
+    /* 6974 */ {I_SETSSBSY, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46047, 277},
+    /* 6975 */ {I_WRUSSD, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+29952, 277},
+    /* 6976 */ {I_WRUSSQ, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+29960, 278},
+    /* 6977 */ {I_WRSSD, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+42419, 277},
+    /* 6978 */ {I_WRSSQ, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+42426, 278},
+    /* 6979 */ {I_ENQCMD, 2, {REG_GPR|BITS16,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29968, 279},
+    /* 6980 */ {I_ENQCMD, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29976, 280},
+    /* 6981 */ {I_ENQCMD, 2, {REG_GPR|BITS64,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29984, 281},
+    /* 6982 */ {I_ENQCMDS, 2, {REG_GPR|BITS16,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+29992, 282},
+    /* 6983 */ {I_ENQCMDS, 2, {REG_GPR|BITS32,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+30000, 283},
+    /* 6984 */ {I_ENQCMDS, 2, {REG_GPR|BITS64,MEMORY|BITS512,0,0,0}, NO_DECORATOR, nasm_bytecodes+30008, 284},
+    /* 6985 */ {I_PCONFIG, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+45993, 285},
+    /* 6986 */ {I_SERIALIZE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46053, 286},
+    /* 6987 */ {I_WBNOINVD, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+49182, 287},
+    /* 6988 */ {I_XRESLDTRK, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46059, 288},
+    /* 6989 */ {I_XSUSLDTRK, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46065, 288},
+    /* 6990 */ {I_VCVTNE2PS2BF16, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30016, 289},
+    /* 6991 */ {I_VCVTNE2PS2BF16, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30024, 289},
+    /* 6992 */ {I_VCVTNE2PS2BF16, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30032, 289},
+    /* 6993 */ {I_VCVTNE2PS2BF16, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30040, 289},
+    /* 6994 */ {I_VCVTNE2PS2BF16, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30048, 289},
+    /* 6995 */ {I_VCVTNE2PS2BF16, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30056, 289},
+    /* 6996 */ {I_VCVTNEPS2BF16, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30064, 289},
+    /* 6997 */ {I_VCVTNEPS2BF16, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30072, 289},
+    /* 6998 */ {I_VCVTNEPS2BF16, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30080, 289},
+    /* 6999 */ {I_VCVTNEPS2BF16, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30088, 289},
+    /* 7000 */ {I_VCVTNEPS2BF16, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30096, 289},
+    /* 7001 */ {I_VCVTNEPS2BF16, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30104, 289},
+    /* 7002 */ {I_VDPBF16PS, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30112, 289},
+    /* 7003 */ {I_VDPBF16PS, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30120, 289},
+    /* 7004 */ {I_VDPBF16PS, 3, {YMMREG,YMMREG,RM_YMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30128, 289},
+    /* 7005 */ {I_VDPBF16PS, 2, {YMMREG,RM_YMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30136, 289},
+    /* 7006 */ {I_VDPBF16PS, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+30144, 289},
+    /* 7007 */ {I_VDPBF16PS, 2, {ZMMREG,RM_ZMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30152, 289},
+    /* 7008 */ {I_VP2INTERSECTD, 3, {KREG|RS2,XMMREG,RM_XMM|BITS128,0,0}, {0,0,B32,0,0}, nasm_bytecodes+30160, 289},
+    /* 7009 */ {I_VP2INTERSECTD, 3, {KREG|RS2,YMMREG,RM_YMM|BITS128,0,0}, {0,0,B32,0,0}, nasm_bytecodes+30168, 289},
+    /* 7010 */ {I_VP2INTERSECTD, 3, {KREG|RS2,ZMMREG,RM_ZMM|BITS128,0,0}, {0,0,B32,0,0}, nasm_bytecodes+30176, 289},
+    /* 7011 */ {I_LDTILECFG, 1, {MEMORY|BITS512,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42433, 290},
+    /* 7012 */ {I_STTILECFG, 1, {MEMORY|BITS512,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42440, 290},
+    /* 7013 */ {I_TDPBF16PS, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42447, 291},
+    /* 7014 */ {I_TDPBSSD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42454, 292},
+    /* 7015 */ {I_TDPBSUD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42461, 292},
+    /* 7016 */ {I_TDPBUSD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42468, 292},
+    /* 7017 */ {I_TDPBUUD, 3, {TMMREG,TMMREG,TMMREG,0,0}, NO_DECORATOR, nasm_bytecodes+42475, 292},
+    /* 7018 */ {I_TILELOADD, 2, {TMMREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42482, 293},
+    /* 7019 */ {I_TILELOADDT1, 2, {TMMREG,MEMORY,0,0,0}, NO_DECORATOR, nasm_bytecodes+42489, 293},
+    /* 7020 */ {I_TILERELEASE, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42496, 294},
+    /* 7021 */ {I_TILESTORED, 2, {MEMORY,TMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+42503, 293},
+    /* 7022 */ {I_TILEZERO, 1, {TMMREG,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+30184, 294},
+    /* 7023 */ {I_VADDPH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30192, 295},
+    /* 7024 */ {I_VADDPH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30200, 295},
+    /* 7025 */ {I_VADDPH, 3, {YMMREG,YMMREG,RM_YMM|BITS16,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30208, 295},
+    /* 7026 */ {I_VADDPH, 2, {YMMREG,RM_YMM|BITS16,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30216, 295},
+    /* 7027 */ {I_VADDPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS16,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+30224, 296},
+    /* 7028 */ {I_VADDPH, 2, {ZMMREG,RM_ZMM|BITS16,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30232, 296},
+    /* 7029 */ {I_VADDSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+30240, 296},
+    /* 7030 */ {I_VADDSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+30248, 296},
+    /* 7031 */ {I_VCMPPH, 4, {KREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,B16,0,0}, nasm_bytecodes+12025, 295},
+    /* 7032 */ {I_VCMPPH, 3, {KREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12034, 295},
+    /* 7033 */ {I_VCMPPH, 4, {KREG,YMMREG,RM_YMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,B16,0,0}, nasm_bytecodes+12043, 295},
+    /* 7034 */ {I_VCMPPH, 3, {KREG,RM_YMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12052, 295},
+    /* 7035 */ {I_VCMPPH, 4, {KREG,ZMMREG,RM_ZMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,B16|SAE,0,0}, nasm_bytecodes+12061, 296},
+    /* 7036 */ {I_VCMPPH, 3, {KREG,RM_ZMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,B16|SAE,0,0,0}, nasm_bytecodes+12070, 296},
+    /* 7037 */ {I_VCMPSH, 4, {KREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK,0,SAE,0,0}, nasm_bytecodes+12079, 296},
+    /* 7038 */ {I_VCMPSH, 3, {KREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,SAE,0,0,0}, nasm_bytecodes+12088, 296},
+    /* 7039 */ {I_VCOMISH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30256, 296},
+    /* 7040 */ {I_VCVTDQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30264, 295},
+    /* 7041 */ {I_VCVTDQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30272, 295},
+    /* 7042 */ {I_VCVTDQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+30280, 296},
+    /* 7043 */ {I_VCVTPD2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30288, 295},
+    /* 7044 */ {I_VCVTPD2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30296, 295},
+    /* 7045 */ {I_VCVTPD2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+30304, 296},
+    /* 7046 */ {I_VCVTPH2DQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30312, 295},
+    /* 7047 */ {I_VCVTPH2DQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30320, 295},
+    /* 7048 */ {I_VCVTPH2DQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30328, 296},
+    /* 7049 */ {I_VCVTPH2PD, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30336, 295},
+    /* 7050 */ {I_VCVTPH2PD, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30344, 295},
+    /* 7051 */ {I_VCVTPH2PD, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30352, 296},
+    /* 7052 */ {I_VCVTPH2PS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+39108, 297},
+    /* 7053 */ {I_VCVTPH2PS, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, NO_DECORATOR, nasm_bytecodes+39101, 297},
+    /* 7054 */ {I_VCVTPH2PS, 2, {XMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17240, 240},
+    /* 7055 */ {I_VCVTPH2PS, 2, {YMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+17248, 240},
+    /* 7056 */ {I_VCVTPH2PS, 2, {ZMM_L16,RM_YMM_L16|BITS256,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+17256, 241},
+    /* 7057 */ {I_VCVTPH2PSX, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30360, 295},
+    /* 7058 */ {I_VCVTPH2PSX, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30368, 295},
+    /* 7059 */ {I_VCVTPH2PSX, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30376, 296},
+    /* 7060 */ {I_VCVTPH2QQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30384, 295},
+    /* 7061 */ {I_VCVTPH2QQ, 2, {YMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30392, 295},
+    /* 7062 */ {I_VCVTPH2QQ, 2, {ZMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30400, 296},
+    /* 7063 */ {I_VCVTPH2UDQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30408, 295},
+    /* 7064 */ {I_VCVTPH2UDQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30416, 295},
+    /* 7065 */ {I_VCVTPH2UDQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30424, 296},
+    /* 7066 */ {I_VCVTPH2UQQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30432, 295},
+    /* 7067 */ {I_VCVTPH2UQQ, 2, {YMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30440, 295},
+    /* 7068 */ {I_VCVTPH2UQQ, 2, {ZMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30448, 296},
+    /* 7069 */ {I_VCVTPH2UW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30456, 295},
+    /* 7070 */ {I_VCVTPH2UW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30464, 295},
+    /* 7071 */ {I_VCVTPH2UW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30472, 296},
+    /* 7072 */ {I_VCVTPH2W, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30480, 295},
+    /* 7073 */ {I_VCVTPH2W, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30488, 295},
+    /* 7074 */ {I_VCVTPH2W, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30496, 296},
+    /* 7075 */ {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS64,XMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14232, 298},
+    /* 7076 */ {I_VCVTPS2PH, 3, {RM_XMM_L16|BITS128,YMM_L16,IMMEDIATE|BITS8,0,0}, NO_DECORATOR, nasm_bytecodes+14224, 298},
+    /* 7077 */ {I_VCVTPS2PH, 3, {XMMREG,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8182, 240},
+    /* 7078 */ {I_VCVTPS2PH, 3, {MEMORY|BITS64,XMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8182, 240},
+    /* 7079 */ {I_VCVTPS2PH, 3, {XMMREG,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+8191, 240},
+    /* 7080 */ {I_VCVTPS2PH, 3, {MEMORY|BITS128,YMMREG,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+8191, 240},
+    /* 7081 */ {I_VCVTPS2PH, 3, {YMMREG,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    /* 7082 */ {I_VCVTPS2PH, 3, {MEMORY|BITS256,ZMMREG,IMMEDIATE|BITS8,0,0}, {MASK,SAE,0,0,0}, nasm_bytecodes+8200, 241},
+    /* 7083 */ {I_VCVTPS2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30504, 295},
+    /* 7084 */ {I_VCVTPS2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30512, 295},
+    /* 7085 */ {I_VCVTPS2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+30520, 296},
+    /* 7086 */ {I_VCVTQQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30528, 295},
+    /* 7087 */ {I_VCVTQQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B64,0,0,0}, nasm_bytecodes+30536, 295},
+    /* 7088 */ {I_VCVTQQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B64|ER,0,0,0}, nasm_bytecodes+30544, 295},
+    /* 7089 */ {I_VCVTSD2SH, 3, {XMMREG,XMMREG,RM_XMM|BITS64,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+30552, 296},
+    /* 7090 */ {I_VCVTSD2SH, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+30560, 296},
+    /* 7091 */ {I_VCVTSH2SD, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {0,0,SAE,0,0}, nasm_bytecodes+30568, 296},
+    /* 7092 */ {I_VCVTSH2SD, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30576, 296},
+    /* 7093 */ {I_VCVTSH2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30584, 296},
+    /* 7094 */ {I_VCVTSH2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30592, 296},
+    /* 7095 */ {I_VCVTSH2SS, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+30600, 296},
+    /* 7096 */ {I_VCVTSH2SS, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+30608, 296},
+    /* 7097 */ {I_VCVTSH2USI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30616, 296},
+    /* 7098 */ {I_VCVTSH2USI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30624, 296},
+    /* 7099 */ {I_VCVTSI2SH, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,0,ER,0,0}, nasm_bytecodes+30632, 296},
+    /* 7100 */ {I_VCVTSI2SH, 2, {XMMREG,RM_GPR|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30640, 296},
+    /* 7101 */ {I_VCVTSI2SH, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,0,ER,0,0}, nasm_bytecodes+30648, 296},
+    /* 7102 */ {I_VCVTSI2SH, 2, {XMMREG,RM_GPR|BITS64,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30656, 296},
+    /* 7103 */ {I_VCVTSS2SH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {0,0,ER,0,0}, nasm_bytecodes+30664, 296},
+    /* 7104 */ {I_VCVTSS2SH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {0,ER,0,0,0}, nasm_bytecodes+30672, 296},
+    /* 7105 */ {I_VCVTTPH2DQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30680, 295},
+    /* 7106 */ {I_VCVTTPH2DQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30688, 295},
+    /* 7107 */ {I_VCVTTPH2DQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30696, 296},
+    /* 7108 */ {I_VCVTTPH2QQ, 2, {XMM_L16,RM_XMM_L16|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30704, 295},
+    /* 7109 */ {I_VCVTTPH2QQ, 2, {YMM_L16,RM_XMM_L16|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30712, 295},
+    /* 7110 */ {I_VCVTTPH2QQ, 2, {ZMM_L16,RM_XMM_L16|BITS128,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30720, 296},
+    /* 7111 */ {I_VCVTTPH2UDQ, 2, {XMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30728, 295},
+    /* 7112 */ {I_VCVTTPH2UDQ, 2, {YMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30736, 295},
+    /* 7113 */ {I_VCVTTPH2UDQ, 2, {ZMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30744, 296},
+    /* 7114 */ {I_VCVTTPH2UQQ, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30752, 295},
+    /* 7115 */ {I_VCVTTPH2UQQ, 2, {YMMREG,RM_XMM|BITS64,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30760, 295},
+    /* 7116 */ {I_VCVTTPH2UQQ, 2, {ZMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30768, 296},
+    /* 7117 */ {I_VCVTTPH2UW, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30776, 295},
+    /* 7118 */ {I_VCVTTPH2UW, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30784, 295},
+    /* 7119 */ {I_VCVTTPH2UW, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30792, 296},
+    /* 7120 */ {I_VCVTTPH2W, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30800, 295},
+    /* 7121 */ {I_VCVTTPH2W, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30808, 295},
+    /* 7122 */ {I_VCVTTPH2W, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+30816, 296},
+    /* 7123 */ {I_VCVTTSH2SI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30824, 296},
+    /* 7124 */ {I_VCVTTSH2SI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30832, 296},
+    /* 7125 */ {I_VCVTTSH2USI, 2, {REG_GPR|BITS32,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30840, 296},
+    /* 7126 */ {I_VCVTTSH2USI, 2, {REG_GPR|BITS64,RM_XMM_L16|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+30848, 296},
+    /* 7127 */ {I_VCVTUDQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30856, 295},
+    /* 7128 */ {I_VCVTUDQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30864, 295},
+    /* 7129 */ {I_VCVTUDQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30872, 296},
+    /* 7130 */ {I_VCVTUQQ2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30880, 295},
+    /* 7131 */ {I_VCVTUQQ2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30888, 295},
+    /* 7132 */ {I_VCVTUQQ2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+30896, 296},
+    /* 7133 */ {I_VCVTUSI2SH, 3, {XMMREG,XMMREG,RM_GPR|BITS32,0,0}, {0,ER,ER,0,0}, nasm_bytecodes+30904, 296},
+    /* 7134 */ {I_VCVTUSI2SS, 3, {XMMREG,XMMREG,RM_GPR|BITS64,0,0}, {0,ER,ER,0,0}, nasm_bytecodes+30912, 296},
+    /* 7135 */ {I_VCVTUW2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30920, 295},
+    /* 7136 */ {I_VCVTUW2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30928, 295},
+    /* 7137 */ {I_VCVTUW2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30936, 296},
+    /* 7138 */ {I_VCVTW2PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30944, 295},
+    /* 7139 */ {I_VCVTW2PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30952, 295},
+    /* 7140 */ {I_VCVTW2PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+30960, 296},
+    /* 7141 */ {I_VDIVPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30968, 295},
+    /* 7142 */ {I_VDIVPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30976, 295},
+    /* 7143 */ {I_VDIVPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+30984, 295},
+    /* 7144 */ {I_VDIVPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+30992, 295},
+    /* 7145 */ {I_VDIVPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31000, 296},
+    /* 7146 */ {I_VDIVPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31008, 296},
+    /* 7147 */ {I_VDIVSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31016, 296},
+    /* 7148 */ {I_VDIVSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31024, 296},
+    /* 7149 */ {I_VFCMADDCPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31032, 295},
+    /* 7150 */ {I_VFCMADDCPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31040, 295},
+    /* 7151 */ {I_VFCMADDCPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31048, 295},
+    /* 7152 */ {I_VFCMADDCPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31056, 295},
+    /* 7153 */ {I_VFCMADDCPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31064, 295},
+    /* 7154 */ {I_VFCMADDCPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31072, 295},
+    /* 7155 */ {I_VFMADDCPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31080, 295},
+    /* 7156 */ {I_VFMADDCPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31088, 295},
+    /* 7157 */ {I_VFMADDCPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31096, 295},
+    /* 7158 */ {I_VFMADDCPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31104, 295},
+    /* 7159 */ {I_VFMADDCPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31112, 295},
+    /* 7160 */ {I_VFMADDCPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31120, 295},
+    /* 7161 */ {I_VFCMADDCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31128, 296},
+    /* 7162 */ {I_VFCMADDCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31136, 296},
+    /* 7163 */ {I_VFMADDCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31144, 296},
+    /* 7164 */ {I_VFMADDCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31152, 296},
+    /* 7165 */ {I_VFCMULCPCH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31160, 295},
+    /* 7166 */ {I_VFCMULCPCH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31168, 295},
+    /* 7167 */ {I_VFCMULCPCH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31176, 295},
+    /* 7168 */ {I_VFCMULCPCH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31184, 295},
+    /* 7169 */ {I_VFCMULCPCH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31192, 295},
+    /* 7170 */ {I_VFCMULCPCH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31200, 295},
+    /* 7171 */ {I_VFMULCPCH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31208, 295},
+    /* 7172 */ {I_VFMULCPCH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31216, 295},
+    /* 7173 */ {I_VFMULCPCH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B32,0,0}, nasm_bytecodes+31224, 295},
+    /* 7174 */ {I_VFMULCPCH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B32,0,0,0}, nasm_bytecodes+31232, 295},
+    /* 7175 */ {I_VFMULCPCH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B32|ER,0,0}, nasm_bytecodes+31240, 295},
+    /* 7176 */ {I_VFMULCPCH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B32|ER,0,0,0}, nasm_bytecodes+31248, 295},
+    /* 7177 */ {I_VFCMULCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31256, 296},
+    /* 7178 */ {I_VFCMULCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31264, 296},
+    /* 7179 */ {I_VFMULCSH, 3, {XMMREG,XMMREG,RM_XMM|BITS32,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31272, 296},
+    /* 7180 */ {I_VFMULCSH, 2, {XMMREG,RM_XMM|BITS32,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31280, 296},
+    /* 7181 */ {I_VFMADDSUB132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31288, 295},
+    /* 7182 */ {I_VFMADDSUB132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31296, 295},
+    /* 7183 */ {I_VFMADDSUB132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31304, 295},
+    /* 7184 */ {I_VFMADDSUB132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31312, 295},
+    /* 7185 */ {I_VFMADDSUB132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31320, 296},
+    /* 7186 */ {I_VFMADDSUB132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31328, 296},
+    /* 7187 */ {I_VFMADDSUB213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31336, 295},
+    /* 7188 */ {I_VFMADDSUB213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31344, 295},
+    /* 7189 */ {I_VFMADDSUB213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31352, 295},
+    /* 7190 */ {I_VFMADDSUB213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31360, 295},
+    /* 7191 */ {I_VFMADDSUB213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31368, 296},
+    /* 7192 */ {I_VFMADDSUB213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31376, 296},
+    /* 7193 */ {I_VFMADDSUB231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31384, 295},
+    /* 7194 */ {I_VFMADDSUB231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31392, 295},
+    /* 7195 */ {I_VFMADDSUB231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31400, 295},
+    /* 7196 */ {I_VFMADDSUB231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31408, 295},
+    /* 7197 */ {I_VFMADDSUB231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31416, 296},
+    /* 7198 */ {I_VFMADDSUB231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31424, 296},
+    /* 7199 */ {I_VFMSUBADD132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31432, 295},
+    /* 7200 */ {I_VFMSUBADD132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31440, 295},
+    /* 7201 */ {I_VFMSUBADD132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31448, 295},
+    /* 7202 */ {I_VFMSUBADD132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31456, 295},
+    /* 7203 */ {I_VFMSUBADD132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31464, 296},
+    /* 7204 */ {I_VFMSUBADD132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31472, 296},
+    /* 7205 */ {I_VFMSUBADD213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31480, 295},
+    /* 7206 */ {I_VFMSUBADD213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31488, 295},
+    /* 7207 */ {I_VFMSUBADD213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31496, 295},
+    /* 7208 */ {I_VFMSUBADD213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31504, 295},
+    /* 7209 */ {I_VFMSUBADD213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31512, 296},
+    /* 7210 */ {I_VFMSUBADD213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31520, 296},
+    /* 7211 */ {I_VFMSUBADD231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31528, 295},
+    /* 7212 */ {I_VFMSUBADD231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31536, 295},
+    /* 7213 */ {I_VFMSUBADD231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31544, 295},
+    /* 7214 */ {I_VFMSUBADD231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31552, 295},
+    /* 7215 */ {I_VFMSUBADD231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31560, 296},
+    /* 7216 */ {I_VFMSUBADD231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31568, 296},
+    /* 7217 */ {I_VPMADD132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31576, 295},
+    /* 7218 */ {I_VPMADD132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31584, 295},
+    /* 7219 */ {I_VPMADD132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31592, 295},
+    /* 7220 */ {I_VPMADD132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31600, 295},
+    /* 7221 */ {I_VPMADD132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31608, 296},
+    /* 7222 */ {I_VPMADD132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31616, 296},
+    /* 7223 */ {I_VPMADD213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31624, 295},
+    /* 7224 */ {I_VPMADD213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31632, 295},
+    /* 7225 */ {I_VPMADD213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31640, 295},
+    /* 7226 */ {I_VPMADD213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31648, 295},
+    /* 7227 */ {I_VPMADD213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31656, 296},
+    /* 7228 */ {I_VPMADD213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31664, 296},
+    /* 7229 */ {I_VPMADD231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31672, 295},
+    /* 7230 */ {I_VPMADD231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31680, 295},
+    /* 7231 */ {I_VPMADD231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31688, 295},
+    /* 7232 */ {I_VPMADD231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31696, 295},
+    /* 7233 */ {I_VPMADD231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31704, 296},
+    /* 7234 */ {I_VPMADD231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31712, 296},
+    /* 7235 */ {I_VFMADD132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31720, 295},
+    /* 7236 */ {I_VFMADD132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31728, 295},
+    /* 7237 */ {I_VFMADD132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31736, 295},
+    /* 7238 */ {I_VFMADD132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31744, 295},
+    /* 7239 */ {I_VFMADD132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31752, 296},
+    /* 7240 */ {I_VFMADD132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31760, 296},
+    /* 7241 */ {I_VFMADD213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31768, 295},
+    /* 7242 */ {I_VFMADD213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31776, 295},
+    /* 7243 */ {I_VFMADD213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31784, 295},
+    /* 7244 */ {I_VFMADD213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31792, 295},
+    /* 7245 */ {I_VFMADD213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31800, 296},
+    /* 7246 */ {I_VFMADD213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31808, 296},
+    /* 7247 */ {I_VFMADD231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31816, 295},
+    /* 7248 */ {I_VFMADD231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31824, 295},
+    /* 7249 */ {I_VFMADD231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31832, 295},
+    /* 7250 */ {I_VFMADD231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31840, 295},
+    /* 7251 */ {I_VFMADD231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31848, 296},
+    /* 7252 */ {I_VFMADD231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+31856, 296},
+    /* 7253 */ {I_VPMADD132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31864, 296},
+    /* 7254 */ {I_VPMADD132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31872, 296},
+    /* 7255 */ {I_VPMADD213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31880, 296},
+    /* 7256 */ {I_VPMADD213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31888, 296},
+    /* 7257 */ {I_VPMADD231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31896, 296},
+    /* 7258 */ {I_VPMADD231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31904, 296},
+    /* 7259 */ {I_VPNMADD132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31912, 296},
+    /* 7260 */ {I_VPNMADD132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31920, 296},
+    /* 7261 */ {I_VPNMADD213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31928, 296},
+    /* 7262 */ {I_VPNMADD213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31936, 296},
+    /* 7263 */ {I_VPNMADD231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+31944, 296},
+    /* 7264 */ {I_VPNMADD231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+31952, 296},
+    /* 7265 */ {I_VPMSUB132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31960, 295},
+    /* 7266 */ {I_VPMSUB132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31968, 295},
+    /* 7267 */ {I_VPMSUB132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+31976, 295},
+    /* 7268 */ {I_VPMSUB132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+31984, 295},
+    /* 7269 */ {I_VPMSUB132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+31992, 296},
+    /* 7270 */ {I_VPMSUB132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32000, 296},
+    /* 7271 */ {I_VPMSUB213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32008, 295},
+    /* 7272 */ {I_VPMSUB213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32016, 295},
+    /* 7273 */ {I_VPMSUB213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32024, 295},
+    /* 7274 */ {I_VPMSUB213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32032, 295},
+    /* 7275 */ {I_VPMSUB213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32040, 296},
+    /* 7276 */ {I_VPMSUB213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32048, 296},
+    /* 7277 */ {I_VPMSUB231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32056, 295},
+    /* 7278 */ {I_VPMSUB231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32064, 295},
+    /* 7279 */ {I_VPMSUB231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32072, 295},
+    /* 7280 */ {I_VPMSUB231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32080, 295},
+    /* 7281 */ {I_VPMSUB231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32088, 296},
+    /* 7282 */ {I_VPMSUB231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32096, 296},
+    /* 7283 */ {I_VFMSUB132PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32104, 295},
+    /* 7284 */ {I_VFMSUB132PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32112, 295},
+    /* 7285 */ {I_VFMSUB132PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32120, 295},
+    /* 7286 */ {I_VFMSUB132PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32128, 295},
+    /* 7287 */ {I_VFMSUB132PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32136, 296},
+    /* 7288 */ {I_VFMSUB132PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32144, 296},
+    /* 7289 */ {I_VFMSUB213PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32152, 295},
+    /* 7290 */ {I_VFMSUB213PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32160, 295},
+    /* 7291 */ {I_VFMSUB213PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32168, 295},
+    /* 7292 */ {I_VFMSUB213PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32176, 295},
+    /* 7293 */ {I_VFMSUB213PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32184, 296},
+    /* 7294 */ {I_VFMSUB213PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32192, 296},
+    /* 7295 */ {I_VFMSUB231PH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32200, 295},
+    /* 7296 */ {I_VFMSUB231PH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32208, 295},
+    /* 7297 */ {I_VFMSUB231PH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32216, 295},
+    /* 7298 */ {I_VFMSUB231PH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32224, 295},
+    /* 7299 */ {I_VFMSUB231PH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32232, 296},
+    /* 7300 */ {I_VFMSUB231PH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32240, 296},
+    /* 7301 */ {I_VPMSUB132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32248, 296},
+    /* 7302 */ {I_VPMSUB132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32256, 296},
+    /* 7303 */ {I_VPMSUB213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32264, 296},
+    /* 7304 */ {I_VPMSUB213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32272, 296},
+    /* 7305 */ {I_VPMSUB231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32280, 296},
+    /* 7306 */ {I_VPMSUB231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32288, 296},
+    /* 7307 */ {I_VPNMSUB132SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32296, 296},
+    /* 7308 */ {I_VPNMSUB132SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32304, 296},
+    /* 7309 */ {I_VPNMSUB213SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32312, 296},
+    /* 7310 */ {I_VPNMSUB213SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32320, 296},
+    /* 7311 */ {I_VPNMSUB231SH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32328, 296},
+    /* 7312 */ {I_VPNMSUB231SH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32336, 296},
+    /* 7313 */ {I_VFPCLASSPH, 3, {KREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12097, 295},
+    /* 7314 */ {I_VFPCLASSPH, 3, {KREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12106, 295},
+    /* 7315 */ {I_VFPCLASSPH, 3, {KREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK,B16,0,0,0}, nasm_bytecodes+12115, 296},
+    /* 7316 */ {I_VFPCLASSSH, 3, {KREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+12124, 296},
+    /* 7317 */ {I_VGETEXPPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32344, 295},
+    /* 7318 */ {I_VGETEXPPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32352, 295},
+    /* 7319 */ {I_VGETEXPPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+32360, 296},
+    /* 7320 */ {I_VGETEXPSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32368, 296},
+    /* 7321 */ {I_VGETMANTPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12133, 295},
+    /* 7322 */ {I_VGETMANTPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12142, 295},
+    /* 7323 */ {I_VGETMANTPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12151, 296},
+    /* 7324 */ {I_VGETMANTSH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12160, 296},
+    /* 7325 */ {I_VGETMAXPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32376, 295},
+    /* 7326 */ {I_VGETMAXPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32384, 295},
+    /* 7327 */ {I_VGETMAXPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+32392, 296},
+    /* 7328 */ {I_VGETMAXSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32400, 296},
+    /* 7329 */ {I_VGETMINPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32408, 295},
+    /* 7330 */ {I_VGETMINPH, 2, {YMMREG,RM_XMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32416, 295},
+    /* 7331 */ {I_VGETMINPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+32424, 296},
+    /* 7332 */ {I_VGETMINSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32432, 296},
+    /* 7333 */ {I_VMOVSH, 2, {XMMREG,MEMORY|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32440, 296},
+    /* 7334 */ {I_VMOVSH, 2, {MEMORY|BITS16,XMMREG,0,0,0}, {MASK,0,0,0,0}, nasm_bytecodes+32448, 296},
+    /* 7335 */ {I_VMOVSH, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32456, 296},
+    /* 7336 */ {I_VMOVSH, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32464, 296},
+    /* 7337 */ {I_VMOVSH, 3, {XMMREG,XMMREG,XMMREG,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32472, 296},
+    /* 7338 */ {I_VMOVSH, 2, {XMMREG,XMMREG,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32480, 296},
+    /* 7339 */ {I_VMOVW, 2, {XMMREG,RM_GPR|BITS16,0,0,0}, {MASK|Z,0,0,0,0}, nasm_bytecodes+32488, 296},
+    /* 7340 */ {I_VMOVW, 2, {RM_GPR|BITS16,XMMREG,0,0,0}, NO_DECORATOR, nasm_bytecodes+32496, 296},
+    /* 7341 */ {I_VMULPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32504, 295},
+    /* 7342 */ {I_VMULPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32512, 295},
+    /* 7343 */ {I_VMULPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32520, 295},
+    /* 7344 */ {I_VMULPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32528, 295},
+    /* 7345 */ {I_VMULPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32536, 296},
+    /* 7346 */ {I_VMULPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32544, 296},
+    /* 7347 */ {I_VMULSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32552, 296},
+    /* 7348 */ {I_VMULSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32560, 296},
+    /* 7349 */ {I_VRCPPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32568, 295},
+    /* 7350 */ {I_VRCPPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32576, 295},
+    /* 7351 */ {I_VRCPPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32584, 295},
+    /* 7352 */ {I_VRCPPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32592, 295},
+    /* 7353 */ {I_VRCPPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32600, 296},
+    /* 7354 */ {I_VRCPPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32608, 296},
+    /* 7355 */ {I_VRCPSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+32616, 296},
+    /* 7356 */ {I_VRCPSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+32624, 296},
+    /* 7357 */ {I_VREDUCEPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12169, 295},
+    /* 7358 */ {I_VREDUCEPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12178, 295},
+    /* 7359 */ {I_VREDUCEPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12187, 296},
+    /* 7360 */ {I_VREDUCESH, 4, {XMMREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+12196, 296},
+    /* 7361 */ {I_VREDUCESH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12205, 296},
+    /* 7362 */ {I_VENDSCALEPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12214, 295},
+    /* 7363 */ {I_VENDSCALEPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12223, 295},
+    /* 7364 */ {I_VENDSCALEPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12232, 296},
+    /* 7365 */ {I_VENDSCALESH, 4, {XMMREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+12241, 296},
+    /* 7366 */ {I_VENDSCALESH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12250, 296},
+    /* 7367 */ {I_VRSQRTPH, 3, {XMMREG,RM_XMM|BITS128,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12259, 295},
+    /* 7368 */ {I_VRSQRTPH, 3, {YMMREG,RM_YMM|BITS256,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+12268, 295},
+    /* 7369 */ {I_VRSQRTPH, 3, {ZMMREG,RM_ZMM|BITS512,IMMEDIATE|BITS8,0,0}, {MASK|Z,B16|SAE,0,0,0}, nasm_bytecodes+12277, 296},
+    /* 7370 */ {I_VRSQRTSH, 4, {XMMREG,XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0}, {MASK|Z,0,SAE,0,0}, nasm_bytecodes+12286, 296},
+    /* 7371 */ {I_VRSQRTSH, 3, {XMMREG,RM_XMM|BITS16,IMMEDIATE|BITS8,0,0}, {MASK|Z,SAE,0,0,0}, nasm_bytecodes+12295, 296},
+    /* 7372 */ {I_VSCALEFPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32632, 295},
+    /* 7373 */ {I_VSCALEFPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32640, 295},
+    /* 7374 */ {I_VSCALEFPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32648, 295},
+    /* 7375 */ {I_VSCALEFPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32656, 295},
+    /* 7376 */ {I_VSCALEFPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32664, 296},
+    /* 7377 */ {I_VSCALEFPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32672, 296},
+    /* 7378 */ {I_VSCALEFSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32680, 296},
+    /* 7379 */ {I_VSCALEFSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32688, 296},
+    /* 7380 */ {I_VSQRTPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32696, 295},
+    /* 7381 */ {I_VSQRTPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32704, 295},
+    /* 7382 */ {I_VSQRTPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32712, 296},
+    /* 7383 */ {I_VSQRTSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32720, 296},
+    /* 7384 */ {I_VSQRTSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32728, 296},
+    /* 7385 */ {I_VSUBPH, 3, {XMMREG,XMMREG,RM_XMM|BITS128,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32736, 295},
+    /* 7386 */ {I_VSUBPH, 2, {XMMREG,RM_XMM|BITS128,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32744, 295},
+    /* 7387 */ {I_VSUBPH, 3, {YMMREG,YMMREG,RM_YMM|BITS256,0,0}, {MASK|Z,0,B16,0,0}, nasm_bytecodes+32752, 295},
+    /* 7388 */ {I_VSUBPH, 2, {YMMREG,RM_YMM|BITS256,0,0,0}, {MASK|Z,B16,0,0,0}, nasm_bytecodes+32760, 295},
+    /* 7389 */ {I_VSUBPH, 3, {ZMMREG,ZMMREG,RM_ZMM|BITS512,0,0}, {MASK|Z,0,B16|ER,0,0}, nasm_bytecodes+32768, 296},
+    /* 7390 */ {I_VSUBPH, 2, {ZMMREG,RM_ZMM|BITS512,0,0,0}, {MASK|Z,B16|ER,0,0,0}, nasm_bytecodes+32776, 296},
+    /* 7391 */ {I_VSUBSH, 3, {XMMREG,XMMREG,RM_XMM|BITS16,0,0}, {MASK|Z,0,ER,0,0}, nasm_bytecodes+32784, 296},
+    /* 7392 */ {I_VSUBSH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {MASK|Z,ER,0,0,0}, nasm_bytecodes+32792, 296},
+    /* 7393 */ {I_VUCOMISH, 2, {XMMREG,RM_XMM|BITS16,0,0,0}, {0,SAE,0,0,0}, nasm_bytecodes+32800, 296},
+    /* 7394 */ {I_AADD, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32808, 299},
+    /* 7395 */ {I_AADD, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+32816, 300},
+    /* 7396 */ {I_AAND, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32824, 299},
+    /* 7397 */ {I_AAND, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+32832, 300},
+    /* 7398 */ {I_AXOR, 2, {MEMORY|BITS32,REG_GPR|BITS32,0,0,0}, NO_DECORATOR, nasm_bytecodes+32840, 299},
+    /* 7399 */ {I_AXOR, 2, {MEMORY|BITS64,REG_GPR|BITS64,0,0,0}, NO_DECORATOR, nasm_bytecodes+32848, 300},
+    /* 7400 */ {I_CLUI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46071, 301},
+    /* 7401 */ {I_SENDUIPI, 1, {REG_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+42510, 301},
+    /* 7402 */ {I_STUI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46077, 301},
+    /* 7403 */ {I_TESTUI, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46083, 301},
+    /* 7404 */ {I_UIRET, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46089, 301},
+    /* 7405 */ {I_CMPAXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42517, 302},
+    /* 7406 */ {I_CMPCXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42531, 302},
+    /* 7407 */ {I_CMPGXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42552, 302},
+    /* 7408 */ {I_CMPLXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42566, 302},
+    /* 7409 */ {I_CMPNAXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42538, 302},
+    /* 7410 */ {I_CMPNCXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42524, 302},
+    /* 7411 */ {I_CMPNGXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42573, 302},
+    /* 7412 */ {I_CMPNLXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42559, 302},
+    /* 7413 */ {I_CMPNOXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42587, 302},
+    /* 7414 */ {I_CMPNSXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42601, 302},
+    /* 7415 */ {I_CMPNZXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42580, 302},
+    /* 7416 */ {I_CMPOXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42608, 302},
+    /* 7417 */ {I_CMPPEXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42615, 302},
+    /* 7418 */ {I_CMPPOXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42594, 302},
+    /* 7419 */ {I_CMPSXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42622, 302},
+    /* 7420 */ {I_CMPZXADD, 3, {MEMORY|BITS32,REG_GPR|BITS32,REG_GPR|BITS32,0,0}, NO_DECORATOR, nasm_bytecodes+42545, 302},
+    /* 7421 */ {I_CMPAXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42629, 303},
+    /* 7422 */ {I_CMPCXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42643, 303},
+    /* 7423 */ {I_CMPGXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42664, 303},
+    /* 7424 */ {I_CMPLXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42678, 303},
+    /* 7425 */ {I_CMPNAXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42650, 303},
+    /* 7426 */ {I_CMPNCXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42636, 303},
+    /* 7427 */ {I_CMPNGXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42685, 303},
+    /* 7428 */ {I_CMPNLXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42671, 303},
+    /* 7429 */ {I_CMPNOXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42699, 303},
+    /* 7430 */ {I_CMPNSXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42713, 303},
+    /* 7431 */ {I_CMPNZXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42692, 303},
+    /* 7432 */ {I_CMPOXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42720, 303},
+    /* 7433 */ {I_CMPPEXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42727, 303},
+    /* 7434 */ {I_CMPPOXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42706, 303},
+    /* 7435 */ {I_CMPSXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42734, 303},
+    /* 7436 */ {I_CMPZXADD, 3, {MEMORY|BITS64,REG_GPR|BITS64,REG_GPR|BITS64,0,0}, NO_DECORATOR, nasm_bytecodes+42657, 303},
+    /* 7437 */ {I_WRMSRNS, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46095, 304},
+    /* 7438 */ {I_RDMSRLIST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46101, 305},
+    /* 7439 */ {I_WRMSRLIST, 0, {0,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46107, 305},
+    /* 7440 */ {I_HRESET, 2, {IMMEDIATE,REG_EAX,0,0,0}, NO_DECORATOR, nasm_bytecodes+32856, 306},
+    /* 7441 */ {I_HINT_NOP0, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46113, 307},
+    /* 7442 */ {I_HINT_NOP0, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46119, 307},
+    /* 7443 */ {I_HINT_NOP0, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46125, 308},
+    /* 7444 */ {I_HINT_NOP1, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46131, 307},
+    /* 7445 */ {I_HINT_NOP1, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46137, 307},
+    /* 7446 */ {I_HINT_NOP1, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46143, 308},
+    /* 7447 */ {I_HINT_NOP2, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46149, 307},
+    /* 7448 */ {I_HINT_NOP2, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46155, 307},
+    /* 7449 */ {I_HINT_NOP2, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46161, 308},
+    /* 7450 */ {I_HINT_NOP3, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46167, 307},
+    /* 7451 */ {I_HINT_NOP3, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46173, 307},
+    /* 7452 */ {I_HINT_NOP3, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46179, 308},
+    /* 7453 */ {I_HINT_NOP4, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46185, 307},
+    /* 7454 */ {I_HINT_NOP4, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46191, 307},
+    /* 7455 */ {I_HINT_NOP4, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46197, 308},
+    /* 7456 */ {I_HINT_NOP5, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46203, 307},
+    /* 7457 */ {I_HINT_NOP5, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46209, 307},
+    /* 7458 */ {I_HINT_NOP5, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46215, 308},
+    /* 7459 */ {I_HINT_NOP6, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46221, 307},
+    /* 7460 */ {I_HINT_NOP6, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46227, 307},
+    /* 7461 */ {I_HINT_NOP6, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46233, 308},
+    /* 7462 */ {I_HINT_NOP7, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46239, 307},
+    /* 7463 */ {I_HINT_NOP7, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46245, 307},
+    /* 7464 */ {I_HINT_NOP7, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46251, 308},
+    /* 7465 */ {I_HINT_NOP8, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46257, 307},
+    /* 7466 */ {I_HINT_NOP8, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46263, 307},
+    /* 7467 */ {I_HINT_NOP8, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46269, 308},
+    /* 7468 */ {I_HINT_NOP9, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46275, 307},
+    /* 7469 */ {I_HINT_NOP9, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46281, 307},
+    /* 7470 */ {I_HINT_NOP9, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46287, 308},
+    /* 7471 */ {I_HINT_NOP10, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46293, 307},
+    /* 7472 */ {I_HINT_NOP10, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46299, 307},
+    /* 7473 */ {I_HINT_NOP10, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46305, 308},
+    /* 7474 */ {I_HINT_NOP11, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46311, 307},
+    /* 7475 */ {I_HINT_NOP11, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46317, 307},
+    /* 7476 */ {I_HINT_NOP11, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46323, 308},
+    /* 7477 */ {I_HINT_NOP12, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46329, 307},
+    /* 7478 */ {I_HINT_NOP12, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46335, 307},
+    /* 7479 */ {I_HINT_NOP12, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46341, 308},
+    /* 7480 */ {I_HINT_NOP13, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46347, 307},
+    /* 7481 */ {I_HINT_NOP13, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46353, 307},
+    /* 7482 */ {I_HINT_NOP13, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46359, 308},
+    /* 7483 */ {I_HINT_NOP14, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46365, 307},
+    /* 7484 */ {I_HINT_NOP14, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46371, 307},
+    /* 7485 */ {I_HINT_NOP14, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46377, 308},
+    /* 7486 */ {I_HINT_NOP15, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46383, 307},
+    /* 7487 */ {I_HINT_NOP15, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46389, 307},
+    /* 7488 */ {I_HINT_NOP15, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46395, 308},
+    /* 7489 */ {I_HINT_NOP16, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46401, 307},
+    /* 7490 */ {I_HINT_NOP16, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46407, 307},
+    /* 7491 */ {I_HINT_NOP16, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46413, 308},
+    /* 7492 */ {I_HINT_NOP17, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46419, 307},
+    /* 7493 */ {I_HINT_NOP17, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46425, 307},
+    /* 7494 */ {I_HINT_NOP17, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46431, 308},
+    /* 7495 */ {I_HINT_NOP18, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46437, 307},
+    /* 7496 */ {I_HINT_NOP18, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46443, 307},
+    /* 7497 */ {I_HINT_NOP18, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46449, 308},
+    /* 7498 */ {I_HINT_NOP19, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46455, 307},
+    /* 7499 */ {I_HINT_NOP19, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46461, 307},
+    /* 7500 */ {I_HINT_NOP19, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46467, 308},
+    /* 7501 */ {I_HINT_NOP20, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46473, 307},
+    /* 7502 */ {I_HINT_NOP20, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46479, 307},
+    /* 7503 */ {I_HINT_NOP20, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46485, 308},
+    /* 7504 */ {I_HINT_NOP21, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46491, 307},
+    /* 7505 */ {I_HINT_NOP21, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46497, 307},
+    /* 7506 */ {I_HINT_NOP21, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46503, 308},
+    /* 7507 */ {I_HINT_NOP22, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46509, 307},
+    /* 7508 */ {I_HINT_NOP22, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46515, 307},
+    /* 7509 */ {I_HINT_NOP22, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46521, 308},
+    /* 7510 */ {I_HINT_NOP23, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46527, 307},
+    /* 7511 */ {I_HINT_NOP23, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46533, 307},
+    /* 7512 */ {I_HINT_NOP23, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46539, 308},
+    /* 7513 */ {I_HINT_NOP24, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46545, 307},
+    /* 7514 */ {I_HINT_NOP24, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46551, 307},
+    /* 7515 */ {I_HINT_NOP24, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46557, 308},
+    /* 7516 */ {I_HINT_NOP25, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46563, 307},
+    /* 7517 */ {I_HINT_NOP25, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46569, 307},
+    /* 7518 */ {I_HINT_NOP25, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46575, 308},
+    /* 7519 */ {I_HINT_NOP26, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46581, 307},
+    /* 7520 */ {I_HINT_NOP26, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46587, 307},
+    /* 7521 */ {I_HINT_NOP26, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46593, 308},
+    /* 7522 */ {I_HINT_NOP27, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46599, 307},
+    /* 7523 */ {I_HINT_NOP27, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46605, 307},
+    /* 7524 */ {I_HINT_NOP27, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46611, 308},
+    /* 7525 */ {I_HINT_NOP28, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46617, 307},
+    /* 7526 */ {I_HINT_NOP28, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46623, 307},
+    /* 7527 */ {I_HINT_NOP28, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46629, 308},
+    /* 7528 */ {I_HINT_NOP29, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46635, 307},
+    /* 7529 */ {I_HINT_NOP29, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46641, 307},
+    /* 7530 */ {I_HINT_NOP29, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46647, 308},
+    /* 7531 */ {I_HINT_NOP30, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46653, 307},
+    /* 7532 */ {I_HINT_NOP30, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46659, 307},
+    /* 7533 */ {I_HINT_NOP30, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46665, 308},
+    /* 7534 */ {I_HINT_NOP31, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46671, 307},
+    /* 7535 */ {I_HINT_NOP31, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46677, 307},
+    /* 7536 */ {I_HINT_NOP31, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46683, 308},
+    /* 7537 */ {I_HINT_NOP32, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46689, 307},
+    /* 7538 */ {I_HINT_NOP32, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46695, 307},
+    /* 7539 */ {I_HINT_NOP32, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46701, 308},
+    /* 7540 */ {I_HINT_NOP33, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46707, 307},
+    /* 7541 */ {I_HINT_NOP33, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46713, 307},
+    /* 7542 */ {I_HINT_NOP33, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46719, 308},
+    /* 7543 */ {I_HINT_NOP34, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46725, 307},
+    /* 7544 */ {I_HINT_NOP34, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46731, 307},
+    /* 7545 */ {I_HINT_NOP34, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46737, 308},
+    /* 7546 */ {I_HINT_NOP35, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46743, 307},
+    /* 7547 */ {I_HINT_NOP35, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46749, 307},
+    /* 7548 */ {I_HINT_NOP35, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46755, 308},
+    /* 7549 */ {I_HINT_NOP36, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46761, 307},
+    /* 7550 */ {I_HINT_NOP36, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46767, 307},
+    /* 7551 */ {I_HINT_NOP36, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46773, 308},
+    /* 7552 */ {I_HINT_NOP37, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46779, 307},
+    /* 7553 */ {I_HINT_NOP37, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46785, 307},
+    /* 7554 */ {I_HINT_NOP37, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46791, 308},
+    /* 7555 */ {I_HINT_NOP38, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46797, 307},
+    /* 7556 */ {I_HINT_NOP38, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46803, 307},
+    /* 7557 */ {I_HINT_NOP38, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46809, 308},
+    /* 7558 */ {I_HINT_NOP39, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46815, 307},
+    /* 7559 */ {I_HINT_NOP39, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46821, 307},
+    /* 7560 */ {I_HINT_NOP39, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46827, 308},
+    /* 7561 */ {I_HINT_NOP40, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46833, 307},
+    /* 7562 */ {I_HINT_NOP40, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46839, 307},
+    /* 7563 */ {I_HINT_NOP40, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46845, 308},
+    /* 7564 */ {I_HINT_NOP41, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46851, 307},
+    /* 7565 */ {I_HINT_NOP41, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46857, 307},
+    /* 7566 */ {I_HINT_NOP41, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46863, 308},
+    /* 7567 */ {I_HINT_NOP42, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46869, 307},
+    /* 7568 */ {I_HINT_NOP42, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46875, 307},
+    /* 7569 */ {I_HINT_NOP42, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46881, 308},
+    /* 7570 */ {I_HINT_NOP43, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46887, 307},
+    /* 7571 */ {I_HINT_NOP43, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46893, 307},
+    /* 7572 */ {I_HINT_NOP43, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46899, 308},
+    /* 7573 */ {I_HINT_NOP44, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46905, 307},
+    /* 7574 */ {I_HINT_NOP44, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46911, 307},
+    /* 7575 */ {I_HINT_NOP44, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46917, 308},
+    /* 7576 */ {I_HINT_NOP45, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46923, 307},
+    /* 7577 */ {I_HINT_NOP45, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46929, 307},
+    /* 7578 */ {I_HINT_NOP45, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46935, 308},
+    /* 7579 */ {I_HINT_NOP46, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46941, 307},
+    /* 7580 */ {I_HINT_NOP46, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46947, 307},
+    /* 7581 */ {I_HINT_NOP46, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46953, 308},
+    /* 7582 */ {I_HINT_NOP47, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46959, 307},
+    /* 7583 */ {I_HINT_NOP47, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46965, 307},
+    /* 7584 */ {I_HINT_NOP47, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46971, 308},
+    /* 7585 */ {I_HINT_NOP48, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46977, 307},
+    /* 7586 */ {I_HINT_NOP48, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46983, 307},
+    /* 7587 */ {I_HINT_NOP48, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46989, 308},
+    /* 7588 */ {I_HINT_NOP49, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+46995, 307},
+    /* 7589 */ {I_HINT_NOP49, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47001, 307},
+    /* 7590 */ {I_HINT_NOP49, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47007, 308},
+    /* 7591 */ {I_HINT_NOP50, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47013, 307},
+    /* 7592 */ {I_HINT_NOP50, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47019, 307},
+    /* 7593 */ {I_HINT_NOP50, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47025, 308},
+    /* 7594 */ {I_HINT_NOP51, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47031, 307},
+    /* 7595 */ {I_HINT_NOP51, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47037, 307},
+    /* 7596 */ {I_HINT_NOP51, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47043, 308},
+    /* 7597 */ {I_HINT_NOP52, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47049, 307},
+    /* 7598 */ {I_HINT_NOP52, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47055, 307},
+    /* 7599 */ {I_HINT_NOP52, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47061, 308},
+    /* 7600 */ {I_HINT_NOP53, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47067, 307},
+    /* 7601 */ {I_HINT_NOP53, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47073, 307},
+    /* 7602 */ {I_HINT_NOP53, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47079, 308},
+    /* 7603 */ {I_HINT_NOP54, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47085, 307},
+    /* 7604 */ {I_HINT_NOP54, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47091, 307},
+    /* 7605 */ {I_HINT_NOP54, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47097, 308},
+    /* 7606 */ {I_HINT_NOP55, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47103, 307},
+    /* 7607 */ {I_HINT_NOP55, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47109, 307},
+    /* 7608 */ {I_HINT_NOP55, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47115, 308},
+    /* 7609 */ {I_HINT_NOP56, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43437, 307},
+    /* 7610 */ {I_HINT_NOP56, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43443, 307},
+    /* 7611 */ {I_HINT_NOP56, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+43449, 308},
+    /* 7612 */ {I_HINT_NOP57, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47121, 307},
+    /* 7613 */ {I_HINT_NOP57, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47127, 307},
+    /* 7614 */ {I_HINT_NOP57, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47133, 308},
+    /* 7615 */ {I_HINT_NOP58, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47139, 307},
+    /* 7616 */ {I_HINT_NOP58, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47145, 307},
+    /* 7617 */ {I_HINT_NOP58, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47151, 308},
+    /* 7618 */ {I_HINT_NOP59, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47157, 307},
+    /* 7619 */ {I_HINT_NOP59, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47163, 307},
+    /* 7620 */ {I_HINT_NOP59, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47169, 308},
+    /* 7621 */ {I_HINT_NOP60, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47175, 307},
+    /* 7622 */ {I_HINT_NOP60, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47181, 307},
+    /* 7623 */ {I_HINT_NOP60, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47187, 308},
+    /* 7624 */ {I_HINT_NOP61, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47193, 307},
+    /* 7625 */ {I_HINT_NOP61, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47199, 307},
+    /* 7626 */ {I_HINT_NOP61, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47205, 308},
+    /* 7627 */ {I_HINT_NOP62, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47211, 307},
+    /* 7628 */ {I_HINT_NOP62, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47217, 307},
+    /* 7629 */ {I_HINT_NOP62, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47223, 308},
+    /* 7630 */ {I_HINT_NOP63, 1, {RM_GPR|BITS16,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47229, 307},
+    /* 7631 */ {I_HINT_NOP63, 1, {RM_GPR|BITS32,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47235, 307},
+    /* 7632 */ {I_HINT_NOP63, 1, {RM_GPR|BITS64,0,0,0,0}, NO_DECORATOR, nasm_bytecodes+47241, 308},
+};
+
+static const struct itemplate * const itable_00[] = {
+    instrux + 43,
+    instrux + 44,
+};
+
+static const struct itemplate * const itable_01[] = {
+    instrux + 45,
+    instrux + 46,
+    instrux + 47,
+    instrux + 48,
+    instrux + 49,
+    instrux + 50,
+};
+
+static const struct itemplate * const itable_02[] = {
+    instrux + 51,
+    instrux + 52,
+};
+
+static const struct itemplate * const itable_03[] = {
+    instrux + 53,
+    instrux + 54,
+    instrux + 55,
+    instrux + 56,
+    instrux + 57,
+    instrux + 58,
+};
+
+static const struct itemplate * const itable_04[] = {
+    instrux + 62,
+};
+
+static const struct itemplate * const itable_05[] = {
+    instrux + 63,
+    instrux + 64,
+    instrux + 65,
+};
+
+static const struct itemplate * const itable_06[] = {
+    instrux + 845,
+};
+
+static const struct itemplate * const itable_07[] = {
+    instrux + 794,
+};
+
+static const struct itemplate * const itable_08[] = {
+    instrux + 697,
+    instrux + 698,
+};
+
+static const struct itemplate * const itable_09[] = {
+    instrux + 699,
+    instrux + 700,
+    instrux + 701,
+    instrux + 702,
+    instrux + 703,
+    instrux + 704,
+};
+
+static const struct itemplate * const itable_0A[] = {
+    instrux + 705,
+    instrux + 706,
+};
+
+static const struct itemplate * const itable_0B[] = {
+    instrux + 707,
+    instrux + 708,
+    instrux + 709,
+    instrux + 710,
+    instrux + 711,
+    instrux + 712,
+};
+
+static const struct itemplate * const itable_0C[] = {
+    instrux + 716,
+};
+
+static const struct itemplate * const itable_0D[] = {
+    instrux + 717,
+    instrux + 718,
+    instrux + 719,
+};
+
+static const struct itemplate * const itable_0E[] = {
+    instrux + 846,
+};
+
+static const struct itemplate * const itable_0F00[] = {
+    instrux + 525,
+    instrux + 526,
+    instrux + 555,
+    instrux + 556,
+    instrux + 557,
+    instrux + 598,
+    instrux + 599,
+    instrux + 600,
+    instrux + 1045,
+    instrux + 1046,
+    instrux + 1047,
+    instrux + 1048,
+    instrux + 1049,
+    instrux + 1064,
+    instrux + 1065,
+    instrux + 1066,
+    instrux + 1067,
+    instrux + 1068,
+    instrux + 1137,
+    instrux + 1138,
+    instrux + 1139,
+    instrux + 1140,
+    instrux + 1141,
+    instrux + 1142,
+};
+
+static const struct itemplate * const itable_0F01[] = {
+    instrux + 491,
+    instrux + 492,
+    instrux + 493,
+    instrux + 494,
+    instrux + 495,
+    instrux + 550,
+    instrux + 554,
+    instrux + 558,
+    instrux + 559,
+    instrux + 560,
+    instrux + 602,
+    instrux + 603,
+    instrux + 683,
+    instrux + 684,
+    instrux + 893,
+    instrux + 995,
+    instrux + 1044,
+    instrux + 1050,
+    instrux + 1052,
+    instrux + 1053,
+    instrux + 1054,
+    instrux + 1055,
+    instrux + 1056,
+    instrux + 1101,
+    instrux + 1495,
+    instrux + 1496,
+    instrux + 1728,
+    instrux + 1729,
+    instrux + 1730,
+    instrux + 1732,
+    instrux + 1733,
+    instrux + 1734,
+    instrux + 1735,
+    instrux + 1740,
+    instrux + 1741,
+    instrux + 1742,
+    instrux + 1745,
+    instrux + 1751,
+    instrux + 1752,
+    instrux + 1753,
+    instrux + 1754,
+    instrux + 3380,
+    instrux + 3381,
+    instrux + 3989,
+    instrux + 3990,
+    instrux + 6770,
+    instrux + 6771,
+    instrux + 6778,
+    instrux + 6787,
+    instrux + 6962,
+    instrux + 6963,
+    instrux + 6964,
+    instrux + 6972,
+    instrux + 6973,
+    instrux + 6974,
+    instrux + 6985,
+    instrux + 6986,
+    instrux + 6988,
+    instrux + 6989,
+    instrux + 7400,
+    instrux + 7402,
+    instrux + 7403,
+    instrux + 7404,
+    instrux + 7437,
+    instrux + 7438,
+    instrux + 7439,
+};
+
+static const struct itemplate * const itable_0F02[] = {
+    instrux + 528,
+    instrux + 529,
+    instrux + 530,
+    instrux + 531,
+    instrux + 532,
+    instrux + 533,
+    instrux + 534,
+    instrux + 535,
+    instrux + 536,
+    instrux + 537,
+};
+
+static const struct itemplate * const itable_0F03[] = {
+    instrux + 585,
+    instrux + 586,
+    instrux + 587,
+    instrux + 588,
+    instrux + 589,
+    instrux + 590,
+    instrux + 591,
+    instrux + 592,
+    instrux + 593,
+    instrux + 594,
+};
+
+static const struct itemplate * const itable_0F05[] = {
+    instrux + 1102,
+};
+
+static const struct itemplate * const itable_0F06[] = {
+    instrux + 181,
+};
+
+static const struct itemplate * const itable_0F07[] = {
+    instrux + 1105,
+};
+
+static const struct itemplate * const itable_0F08[] = {
+    instrux + 488,
+};
+
+static const struct itemplate * const itable_0F09[] = {
+    instrux + 1144,
+    instrux + 6793,
+    instrux + 6987,
+};
+
+static const struct itemplate * const itable_0F0B[] = {
+    instrux + 1136,
+};
+
+static const struct itemplate * const itable_0F0D[] = {
+    instrux + 807,
+    instrux + 808,
+    instrux + 4040,
+};
+
+static const struct itemplate * const itable_0F0E[] = {
+    instrux + 314,
+};
+
+static const struct itemplate * const itable_0F0F[] = {
+    instrux + 751,
+    instrux + 759,
+    instrux + 760,
+    instrux + 761,
+    instrux + 762,
+    instrux + 763,
+    instrux + 764,
+    instrux + 765,
+    instrux + 766,
+    instrux + 767,
+    instrux + 768,
+    instrux + 769,
+    instrux + 770,
+    instrux + 771,
+    instrux + 772,
+    instrux + 773,
+    instrux + 774,
+    instrux + 775,
+    instrux + 780,
+    instrux + 1532,
+    instrux + 1533,
+    instrux + 1534,
+    instrux + 1535,
+    instrux + 1536,
+    instrux + 1869,
+    instrux + 1870,
+};
+
+static const struct itemplate * const itable_0F10[] = {
+    instrux + 1470,
+    instrux + 1472,
+    instrux + 1702,
+    instrux + 1704,
+};
+
+static const struct itemplate * const itable_0F11[] = {
+    instrux + 1471,
+    instrux + 1473,
+    instrux + 1703,
+    instrux + 1705,
+};
+
+static const struct itemplate * const itable_0F12[] = {
+    instrux + 1464,
+    instrux + 1466,
+    instrux + 1699,
+    instrux + 1725,
+    instrux + 1727,
+};
+
+static const struct itemplate * const itable_0F13[] = {
+    instrux + 1465,
+    instrux + 1698,
+};
+
+static const struct itemplate * const itable_0F14[] = {
+    instrux + 1489,
+    instrux + 1716,
+};
+
+static const struct itemplate * const itable_0F15[] = {
+    instrux + 1488,
+    instrux + 1715,
+};
+
+static const struct itemplate * const itable_0F16[] = {
+    instrux + 1461,
+    instrux + 1463,
+    instrux + 1697,
+    instrux + 1726,
+};
+
+static const struct itemplate * const itable_0F17[] = {
+    instrux + 1462,
+    instrux + 1696,
+};
+
+static const struct itemplate * const itable_0F18[] = {
+    instrux + 1509,
+    instrux + 1510,
+    instrux + 1511,
+    instrux + 1512,
+    instrux + 1513,
+    instrux + 1514,
+    instrux + 7441,
+    instrux + 7442,
+    instrux + 7443,
+    instrux + 7444,
+    instrux + 7445,
+    instrux + 7446,
+    instrux + 7447,
+    instrux + 7448,
+    instrux + 7449,
+    instrux + 7450,
+    instrux + 7451,
+    instrux + 7452,
+    instrux + 7453,
+    instrux + 7454,
+    instrux + 7455,
+    instrux + 7456,
+    instrux + 7457,
+    instrux + 7458,
+    instrux + 7459,
+    instrux + 7460,
+    instrux + 7461,
+    instrux + 7462,
+    instrux + 7463,
+    instrux + 7464,
+};
+
+static const struct itemplate * const itable_0F19[] = {
+    instrux + 7465,
+    instrux + 7466,
+    instrux + 7467,
+    instrux + 7468,
+    instrux + 7469,
+    instrux + 7470,
+    instrux + 7471,
+    instrux + 7472,
+    instrux + 7473,
+    instrux + 7474,
+    instrux + 7475,
+    instrux + 7476,
+    instrux + 7477,
+    instrux + 7478,
+    instrux + 7479,
+    instrux + 7480,
+    instrux + 7481,
+    instrux + 7482,
+    instrux + 7483,
+    instrux + 7484,
+    instrux + 7485,
+    instrux + 7486,
+    instrux + 7487,
+    instrux + 7488,
+};
+
+static const struct itemplate * const itable_0F1A[] = {
+    instrux + 4042,
+    instrux + 4043,
+    instrux + 4044,
+    instrux + 4045,
+    instrux + 4046,
+    instrux + 4047,
+    instrux + 4051,
+    instrux + 4052,
+    instrux + 4055,
+    instrux + 4056,
+    instrux + 4057,
+    instrux + 7489,
+    instrux + 7490,
+    instrux + 7491,
+    instrux + 7492,
+    instrux + 7493,
+    instrux + 7494,
+    instrux + 7495,
+    instrux + 7496,
+    instrux + 7497,
+    instrux + 7498,
+    instrux + 7499,
+    instrux + 7500,
+    instrux + 7501,
+    instrux + 7502,
+    instrux + 7503,
+    instrux + 7504,
+    instrux + 7505,
+    instrux + 7506,
+    instrux + 7507,
+    instrux + 7508,
+    instrux + 7509,
+    instrux + 7510,
+    instrux + 7511,
+    instrux + 7512,
+};
+
+static const struct itemplate * const itable_0F1B[] = {
+    instrux + 4041,
+    instrux + 4048,
+    instrux + 4049,
+    instrux + 4050,
+    instrux + 4053,
+    instrux + 4054,
+    instrux + 4058,
+    instrux + 4059,
+    instrux + 4060,
+    instrux + 4061,
+    instrux + 4062,
+    instrux + 7513,
+    instrux + 7514,
+    instrux + 7515,
+    instrux + 7516,
+    instrux + 7517,
+    instrux + 7518,
+    instrux + 7519,
+    instrux + 7520,
+    instrux + 7521,
+    instrux + 7522,
+    instrux + 7523,
+    instrux + 7524,
+    instrux + 7525,
+    instrux + 7526,
+    instrux + 7527,
+    instrux + 7528,
+    instrux + 7529,
+    instrux + 7530,
+    instrux + 7531,
+    instrux + 7532,
+    instrux + 7533,
+    instrux + 7534,
+    instrux + 7535,
+    instrux + 7536,
+};
+
+static const struct itemplate * const itable_0F1C[] = {
+    instrux + 6781,
+    instrux + 7537,
+    instrux + 7538,
+    instrux + 7539,
+    instrux + 7540,
+    instrux + 7541,
+    instrux + 7542,
+    instrux + 7543,
+    instrux + 7544,
+    instrux + 7545,
+    instrux + 7546,
+    instrux + 7547,
+    instrux + 7548,
+    instrux + 7549,
+    instrux + 7550,
+    instrux + 7551,
+    instrux + 7552,
+    instrux + 7553,
+    instrux + 7554,
+    instrux + 7555,
+    instrux + 7556,
+    instrux + 7557,
+    instrux + 7558,
+    instrux + 7559,
+    instrux + 7560,
+};
+
+static const struct itemplate * const itable_0F1D[] = {
+    instrux + 7561,
+    instrux + 7562,
+    instrux + 7563,
+    instrux + 7564,
+    instrux + 7565,
+    instrux + 7566,
+    instrux + 7567,
+    instrux + 7568,
+    instrux + 7569,
+    instrux + 7570,
+    instrux + 7571,
+    instrux + 7572,
+    instrux + 7573,
+    instrux + 7574,
+    instrux + 7575,
+    instrux + 7576,
+    instrux + 7577,
+    instrux + 7578,
+    instrux + 7579,
+    instrux + 7580,
+    instrux + 7581,
+    instrux + 7582,
+    instrux + 7583,
+    instrux + 7584,
+};
+
+static const struct itemplate * const itable_0F1E[] = {
+    instrux + 6966,
+    instrux + 6967,
+    instrux + 6970,
+    instrux + 6971,
+    instrux + 7585,
+    instrux + 7586,
+    instrux + 7587,
+    instrux + 7588,
+    instrux + 7589,
+    instrux + 7590,
+    instrux + 7591,
+    instrux + 7592,
+    instrux + 7593,
+    instrux + 7594,
+    instrux + 7595,
+    instrux + 7596,
+    instrux + 7597,
+    instrux + 7598,
+    instrux + 7599,
+    instrux + 7600,
+    instrux + 7601,
+    instrux + 7602,
+    instrux + 7603,
+    instrux + 7604,
+    instrux + 7605,
+    instrux + 7606,
+    instrux + 7607,
+    instrux + 7608,
+};
+
+static const struct itemplate * const itable_0F1F[] = {
+    instrux + 690,
+    instrux + 691,
+    instrux + 692,
+    instrux + 7609,
+    instrux + 7610,
+    instrux + 7611,
+    instrux + 7612,
+    instrux + 7613,
+    instrux + 7614,
+    instrux + 7615,
+    instrux + 7616,
+    instrux + 7617,
+    instrux + 7618,
+    instrux + 7619,
+    instrux + 7620,
+    instrux + 7621,
+    instrux + 7622,
+    instrux + 7623,
+    instrux + 7624,
+    instrux + 7625,
+    instrux + 7626,
+    instrux + 7627,
+    instrux + 7628,
+    instrux + 7629,
+    instrux + 7630,
+    instrux + 7631,
+    instrux + 7632,
+};
+
+static const struct itemplate * const itable_0F20[] = {
+    instrux + 620,
+    instrux + 621,
+};
+
+static const struct itemplate * const itable_0F21[] = {
+    instrux + 624,
+    instrux + 625,
+};
+
+static const struct itemplate * const itable_0F22[] = {
+    instrux + 622,
+    instrux + 623,
+};
+
+static const struct itemplate * const itable_0F23[] = {
+    instrux + 626,
+    instrux + 627,
+};
+
+static const struct itemplate * const itable_0F28[] = {
+    instrux + 1459,
+    instrux + 1694,
+};
+
+static const struct itemplate * const itable_0F29[] = {
+    instrux + 1460,
+    instrux + 1695,
+};
+
+static const struct itemplate * const itable_0F2A[] = {
+    instrux + 1441,
+    instrux + 1443,
+    instrux + 1444,
+    instrux + 1670,
+    instrux + 1678,
+    instrux + 1679,
+};
+
+static const struct itemplate * const itable_0F2B[] = {
+    instrux + 1469,
+    instrux + 1542,
+    instrux + 1791,
+    instrux + 1792,
+};
+
+static const struct itemplate * const itable_0F2C[] = {
+    instrux + 1449,
+    instrux + 1450,
+    instrux + 1451,
+    instrux + 1681,
+    instrux + 1684,
+    instrux + 1685,
+    instrux + 1686,
+    instrux + 1687,
+};
+
+static const struct itemplate * const itable_0F2D[] = {
+    instrux + 1442,
+    instrux + 1445,
+    instrux + 1446,
+    instrux + 1447,
+    instrux + 1448,
+    instrux + 1668,
+    instrux + 1673,
+    instrux + 1674,
+    instrux + 1675,
+    instrux + 1676,
+};
+
+static const struct itemplate * const itable_0F2E[] = {
+    instrux + 1487,
+    instrux + 1714,
+};
+
+static const struct itemplate * const itable_0F2F[] = {
+    instrux + 1440,
+    instrux + 1664,
+};
+
+static const struct itemplate * const itable_0F30[] = {
+    instrux + 1146,
+};
+
+static const struct itemplate * const itable_0F31[] = {
+    instrux + 892,
+};
+
+static const struct itemplate * const itable_0F32[] = {
+    instrux + 890,
+};
+
+static const struct itemplate * const itable_0F33[] = {
+    instrux + 891,
+};
+
+static const struct itemplate * const itable_0F34[] = {
+    instrux + 1103,
+};
+
+static const struct itemplate * const itable_0F35[] = {
+    instrux + 1104,
+};
+
+static const struct itemplate * const itable_0F36[] = {
+    instrux + 889,
+};
+
+static const struct itemplate * const itable_0F37[] = {
+    instrux + 1145,
+    instrux + 1868,
+};
+
+static const struct itemplate * const itable_0F3800[] = {
+    instrux + 1779,
+    instrux + 1780,
+};
+
+static const struct itemplate * const itable_0F3801[] = {
+    instrux + 1763,
+    instrux + 1764,
+};
+
+static const struct itemplate * const itable_0F3802[] = {
+    instrux + 1765,
+    instrux + 1766,
+};
+
+static const struct itemplate * const itable_0F3803[] = {
+    instrux + 1767,
+    instrux + 1768,
+};
+
+static const struct itemplate * const itable_0F3804[] = {
+    instrux + 1775,
+    instrux + 1776,
+};
+
+static const struct itemplate * const itable_0F3805[] = {
+    instrux + 1769,
+    instrux + 1770,
+};
+
+static const struct itemplate * const itable_0F3806[] = {
+    instrux + 1771,
+    instrux + 1772,
+};
+
+static const struct itemplate * const itable_0F3807[] = {
+    instrux + 1773,
+    instrux + 1774,
+};
+
+static const struct itemplate * const itable_0F3808[] = {
+    instrux + 1781,
+    instrux + 1782,
+};
+
+static const struct itemplate * const itable_0F3809[] = {
+    instrux + 1783,
+    instrux + 1784,
+};
+
+static const struct itemplate * const itable_0F380A[] = {
+    instrux + 1785,
+    instrux + 1786,
+};
+
+static const struct itemplate * const itable_0F380B[] = {
+    instrux + 1777,
+    instrux + 1778,
+};
+
+static const struct itemplate * const itable_0F3810[] = {
+    instrux + 1810,
+    instrux + 1811,
+};
+
+static const struct itemplate * const itable_0F3814[] = {
+    instrux + 1800,
+    instrux + 1801,
+};
+
+static const struct itemplate * const itable_0F3815[] = {
+    instrux + 1798,
+    instrux + 1799,
+};
+
+static const struct itemplate * const itable_0F3817[] = {
+    instrux + 1850,
+};
+
+static const struct itemplate * const itable_0F381C[] = {
+    instrux + 1755,
+    instrux + 1756,
+};
+
+static const struct itemplate * const itable_0F381D[] = {
+    instrux + 1757,
+    instrux + 1758,
+};
+
+static const struct itemplate * const itable_0F381E[] = {
+    instrux + 1759,
+    instrux + 1760,
+};
+
+static const struct itemplate * const itable_0F3820[] = {
+    instrux + 1836,
+};
+
+static const struct itemplate * const itable_0F3821[] = {
+    instrux + 1837,
+};
+
+static const struct itemplate * const itable_0F3822[] = {
+    instrux + 1838,
+};
+
+static const struct itemplate * const itable_0F3823[] = {
+    instrux + 1839,
+};
+
+static const struct itemplate * const itable_0F3824[] = {
+    instrux + 1840,
+};
+
+static const struct itemplate * const itable_0F3825[] = {
+    instrux + 1841,
+};
+
+static const struct itemplate * const itable_0F3828[] = {
+    instrux + 1848,
+};
+
+static const struct itemplate * const itable_0F3829[] = {
+    instrux + 1813,
+};
+
+static const struct itemplate * const itable_0F382A[] = {
+    instrux + 1807,
+};
+
+static const struct itemplate * const itable_0F382B[] = {
+    instrux + 1809,
+};
+
+static const struct itemplate * const itable_0F3830[] = {
+    instrux + 1842,
+};
+
+static const struct itemplate * const itable_0F3831[] = {
+    instrux + 1843,
+};
+
+static const struct itemplate * const itable_0F3832[] = {
+    instrux + 1844,
+};
+
+static const struct itemplate * const itable_0F3833[] = {
+    instrux + 1845,
+};
+
+static const struct itemplate * const itable_0F3834[] = {
+    instrux + 1846,
+};
+
+static const struct itemplate * const itable_0F3835[] = {
+    instrux + 1847,
+};
+
+static const struct itemplate * const itable_0F3837[] = {
+    instrux + 1864,
+};
+
+static const struct itemplate * const itable_0F3838[] = {
+    instrux + 1832,
+};
+
+static const struct itemplate * const itable_0F3839[] = {
+    instrux + 1833,
+};
+
+static const struct itemplate * const itable_0F383A[] = {
+    instrux + 1835,
+};
+
+static const struct itemplate * const itable_0F383B[] = {
+    instrux + 1834,
+};
+
+static const struct itemplate * const itable_0F383C[] = {
+    instrux + 1828,
+};
+
+static const struct itemplate * const itable_0F383D[] = {
+    instrux + 1829,
+};
+
+static const struct itemplate * const itable_0F383E[] = {
+    instrux + 1831,
+};
+
+static const struct itemplate * const itable_0F383F[] = {
+    instrux + 1830,
+};
+
+static const struct itemplate * const itable_0F3840[] = {
+    instrux + 1849,
+};
+
+static const struct itemplate * const itable_0F3841[] = {
+    instrux + 1822,
+};
+
+static const struct itemplate * const itable_0F3880[] = {
+    instrux + 1747,
+    instrux + 1748,
+};
+
+static const struct itemplate * const itable_0F3881[] = {
+    instrux + 1749,
+    instrux + 1750,
+};
+
+static const struct itemplate * const itable_0F3882[] = {
+    instrux + 489,
+    instrux + 490,
+};
+
+static const struct itemplate * const itable_0F38C8[] = {
+    instrux + 4065,
+};
+
+static const struct itemplate * const itable_0F38C9[] = {
+    instrux + 4063,
+};
+
+static const struct itemplate * const itable_0F38CA[] = {
+    instrux + 4064,
+};
+
+static const struct itemplate * const itable_0F38CB[] = {
+    instrux + 4069,
+    instrux + 4070,
+};
+
+static const struct itemplate * const itable_0F38CC[] = {
+    instrux + 4067,
+};
+
+static const struct itemplate * const itable_0F38CD[] = {
+    instrux + 4068,
+};
+
+static const struct itemplate * const itable_0F38CF[] = {
+    instrux + 6816,
+};
+
+static const struct itemplate * const itable_0F38DB[] = {
+    instrux + 1881,
+};
+
+static const struct itemplate * const itable_0F38DC[] = {
+    instrux + 1877,
+};
+
+static const struct itemplate * const itable_0F38DD[] = {
+    instrux + 1878,
+};
+
+static const struct itemplate * const itable_0F38DE[] = {
+    instrux + 1879,
+};
+
+static const struct itemplate * const itable_0F38DF[] = {
+    instrux + 1880,
+};
+
+static const struct itemplate * const itable_0F38F0[] = {
+    instrux + 1855,
+    instrux + 1858,
+    instrux + 1871,
+    instrux + 1872,
+    instrux + 1873,
+};
+
+static const struct itemplate * const itable_0F38F1[] = {
+    instrux + 1856,
+    instrux + 1857,
+    instrux + 1859,
+    instrux + 1874,
+    instrux + 1875,
+    instrux + 1876,
+};
+
+static const struct itemplate * const itable_0F38F5[] = {
+    instrux + 6975,
+    instrux + 6976,
+};
+
+static const struct itemplate * const itable_0F38F6[] = {
+    instrux + 3373,
+    instrux + 3374,
+    instrux + 3375,
+    instrux + 3376,
+    instrux + 6977,
+    instrux + 6978,
+};
+
+static const struct itemplate * const itable_0F38F8[] = {
+    instrux + 6784,
+    instrux + 6785,
+    instrux + 6786,
+    instrux + 6979,
+    instrux + 6980,
+    instrux + 6981,
+    instrux + 6982,
+    instrux + 6983,
+    instrux + 6984,
+};
+
+static const struct itemplate * const itable_0F38F9[] = {
+    instrux + 6782,
+    instrux + 6783,
+};
+
+static const struct itemplate * const itable_0F38FC[] = {
+    instrux + 7394,
+    instrux + 7395,
+    instrux + 7396,
+    instrux + 7397,
+    instrux + 7398,
+    instrux + 7399,
+};
+
+static const struct itemplate * const itable_0F39[] = {
+    instrux + 245,
+};
+
+static const struct itemplate * const itable_0F3A08[] = {
+    instrux + 1852,
+};
+
+static const struct itemplate * const itable_0F3A09[] = {
+    instrux + 1851,
+};
+
+static const struct itemplate * const itable_0F3A0A[] = {
+    instrux + 1854,
+};
+
+static const struct itemplate * const itable_0F3A0B[] = {
+    instrux + 1853,
+};
+
+static const struct itemplate * const itable_0F3A0C[] = {
+    instrux + 1797,
+};
+
+static const struct itemplate * const itable_0F3A0D[] = {
+    instrux + 1796,
+};
+
+static const struct itemplate * const itable_0F3A0E[] = {
+    instrux + 1812,
+};
+
+static const struct itemplate * const itable_0F3A0F[] = {
+    instrux + 1761,
+    instrux + 1762,
+};
+
+static const struct itemplate * const itable_0F3A14[] = {
+    instrux + 1814,
+    instrux + 1815,
+    instrux + 1816,
+};
+
+static const struct itemplate * const itable_0F3A15[] = {
+    instrux + 1819,
+    instrux + 1820,
+    instrux + 1821,
+};
+
+static const struct itemplate * const itable_0F3A16[] = {
+    instrux + 1817,
+    instrux + 1818,
+};
+
+static const struct itemplate * const itable_0F3A17[] = {
+    instrux + 1804,
+    instrux + 1805,
+};
+
+static const struct itemplate * const itable_0F3A20[] = {
+    instrux + 1823,
+    instrux + 1824,
+    instrux + 1825,
+};
+
+static const struct itemplate * const itable_0F3A21[] = {
+    instrux + 1806,
+};
+
+static const struct itemplate * const itable_0F3A22[] = {
+    instrux + 1826,
+    instrux + 1827,
+};
+
+static const struct itemplate * const itable_0F3A40[] = {
+    instrux + 1803,
+};
+
+static const struct itemplate * const itable_0F3A41[] = {
+    instrux + 1802,
+};
+
+static const struct itemplate * const itable_0F3A42[] = {
+    instrux + 1808,
+};
+
+static const struct itemplate * const itable_0F3A44[] = {
+    instrux + 3111,
+    instrux + 3112,
+    instrux + 3113,
+    instrux + 3114,
+    instrux + 3115,
+};
+
+static const struct itemplate * const itable_0F3A60[] = {
+    instrux + 1861,
+};
+
+static const struct itemplate * const itable_0F3A61[] = {
+    instrux + 1860,
+};
+
+static const struct itemplate * const itable_0F3A62[] = {
+    instrux + 1863,
+};
+
+static const struct itemplate * const itable_0F3A63[] = {
+    instrux + 1862,
+};
+
+static const struct itemplate * const itable_0F3ACC[] = {
+    instrux + 4066,
+};
+
+static const struct itemplate * const itable_0F3ACE[] = {
+    instrux + 6805,
+};
+
+static const struct itemplate * const itable_0F3ACF[] = {
+    instrux + 6794,
+};
+
+static const struct itemplate * const itable_0F3ADF[] = {
+    instrux + 1882,
+};
+
+static const struct itemplate * const itable_0F3AF0[] = {
+    instrux + 7440,
+};
+
+static const struct itemplate * const itable_0F3C[] = {
+    instrux + 229,
+};
+
+static const struct itemplate * const itable_0F3D[] = {
+    instrux + 228,
+};
+
+static const struct itemplate * const itable_0F40[] = {
+    instrux + 1221,
+    instrux + 1237,
+    instrux + 1253,
+    instrux + 1269,
+    instrux + 1285,
+    instrux + 1301,
+};
+
+static const struct itemplate * const itable_0F41[] = {
+    instrux + 1218,
+    instrux + 1234,
+    instrux + 1250,
+    instrux + 1266,
+    instrux + 1282,
+    instrux + 1298,
+};
+
+static const struct itemplate * const itable_0F42[] = {
+    instrux + 1211,
+    instrux + 1227,
+    instrux + 1243,
+    instrux + 1259,
+    instrux + 1275,
+    instrux + 1291,
+};
+
+static const struct itemplate * const itable_0F43[] = {
+    instrux + 1215,
+    instrux + 1231,
+    instrux + 1247,
+    instrux + 1263,
+    instrux + 1279,
+    instrux + 1295,
+};
+
+static const struct itemplate * const itable_0F44[] = {
+    instrux + 1225,
+    instrux + 1241,
+    instrux + 1257,
+    instrux + 1273,
+    instrux + 1289,
+    instrux + 1305,
+};
+
+static const struct itemplate * const itable_0F45[] = {
+    instrux + 1220,
+    instrux + 1236,
+    instrux + 1252,
+    instrux + 1268,
+    instrux + 1284,
+    instrux + 1300,
+};
+
+static const struct itemplate * const itable_0F46[] = {
+    instrux + 1214,
+    instrux + 1230,
+    instrux + 1246,
+    instrux + 1262,
+    instrux + 1278,
+    instrux + 1294,
+};
+
+static const struct itemplate * const itable_0F47[] = {
+    instrux + 1210,
+    instrux + 1226,
+    instrux + 1242,
+    instrux + 1258,
+    instrux + 1274,
+    instrux + 1290,
+};
+
+static const struct itemplate * const itable_0F48[] = {
+    instrux + 1224,
+    instrux + 1240,
+    instrux + 1256,
+    instrux + 1272,
+    instrux + 1288,
+    instrux + 1304,
+};
+
+static const struct itemplate * const itable_0F49[] = {
+    instrux + 1219,
+    instrux + 1235,
+    instrux + 1251,
+    instrux + 1267,
+    instrux + 1283,
+    instrux + 1299,
+};
+
+static const struct itemplate * const itable_0F4A[] = {
+    instrux + 1222,
+    instrux + 1238,
+    instrux + 1254,
+    instrux + 1270,
+    instrux + 1286,
+    instrux + 1302,
+};
+
+static const struct itemplate * const itable_0F4B[] = {
+    instrux + 1223,
+    instrux + 1239,
+    instrux + 1255,
+    instrux + 1271,
+    instrux + 1287,
+    instrux + 1303,
+};
+
+static const struct itemplate * const itable_0F4C[] = {
+    instrux + 1213,
+    instrux + 1229,
+    instrux + 1245,
+    instrux + 1261,
+    instrux + 1277,
+    instrux + 1293,
+};
+
+static const struct itemplate * const itable_0F4D[] = {
+    instrux + 1217,
+    instrux + 1233,
+    instrux + 1249,
+    instrux + 1265,
+    instrux + 1281,
+    instrux + 1297,
+};
+
+static const struct itemplate * const itable_0F4E[] = {
+    instrux + 1216,
+    instrux + 1232,
+    instrux + 1248,
+    instrux + 1264,
+    instrux + 1280,
+    instrux + 1296,
+};
+
+static const struct itemplate * const itable_0F4F[] = {
+    instrux + 1212,
+    instrux + 1228,
+    instrux + 1244,
+    instrux + 1260,
+    instrux + 1276,
+    instrux + 1292,
+};
+
+static const struct itemplate * const itable_0F50[] = {
+    instrux + 750,
+    instrux + 1467,
+    instrux + 1468,
+    instrux + 1700,
+    instrux + 1701,
+};
+
+static const struct itemplate * const itable_0F51[] = {
+    instrux + 742,
+    instrux + 1482,
+    instrux + 1483,
+    instrux + 1710,
+    instrux + 1711,
+};
+
+static const struct itemplate * const itable_0F52[] = {
+    instrux + 778,
+    instrux + 1479,
+    instrux + 1480,
+};
+
+static const struct itemplate * const itable_0F53[] = {
+    instrux + 1477,
+    instrux + 1478,
+};
+
+static const struct itemplate * const itable_0F54[] = {
+    instrux + 758,
+    instrux + 1421,
+    instrux + 1645,
+};
+
+static const struct itemplate * const itable_0F55[] = {
+    instrux + 828,
+    instrux + 1420,
+    instrux + 1644,
+};
+
+static const struct itemplate * const itable_0F56[] = {
+    instrux + 1476,
+    instrux + 1708,
+};
+
+static const struct itemplate * const itable_0F57[] = {
+    instrux + 1490,
+    instrux + 1717,
+};
+
+static const struct itemplate * const itable_0F58[] = {
+    instrux + 787,
+    instrux + 1418,
+    instrux + 1419,
+    instrux + 1642,
+    instrux + 1643,
+};
+
+static const struct itemplate * const itable_0F59[] = {
+    instrux + 781,
+    instrux + 1474,
+    instrux + 1475,
+    instrux + 1706,
+    instrux + 1707,
+};
+
+static const struct itemplate * const itable_0F5A[] = {
+    instrux + 786,
+    instrux + 1669,
+    instrux + 1672,
+    instrux + 1677,
+    instrux + 1680,
+};
+
+static const struct itemplate * const itable_0F5B[] = {
+    instrux + 785,
+    instrux + 1666,
+    instrux + 1671,
+    instrux + 1683,
+};
+
+static const struct itemplate * const itable_0F5C[] = {
+    instrux + 784,
+    instrux + 1485,
+    instrux + 1486,
+    instrux + 1712,
+    instrux + 1713,
+};
+
+static const struct itemplate * const itable_0F5D[] = {
+    instrux + 779,
+    instrux + 1457,
+    instrux + 1458,
+    instrux + 1692,
+    instrux + 1693,
+};
+
+static const struct itemplate * const itable_0F5E[] = {
+    instrux + 776,
+    instrux + 1452,
+    instrux + 1453,
+    instrux + 1688,
+    instrux + 1689,
+};
+
+static const struct itemplate * const itable_0F5F[] = {
+    instrux + 1455,
+    instrux + 1456,
+    instrux + 1690,
+    instrux + 1691,
+};
+
+static const struct itemplate * const itable_0F60[] = {
+    instrux + 836,
+    instrux + 1637,
+};
+
+static const struct itemplate * const itable_0F61[] = {
+    instrux + 838,
+    instrux + 1638,
+};
+
+static const struct itemplate * const itable_0F62[] = {
+    instrux + 837,
+    instrux + 1639,
+};
+
+static const struct itemplate * const itable_0F63[] = {
+    instrux + 737,
+    instrux + 1561,
+};
+
+static const struct itemplate * const itable_0F64[] = {
+    instrux + 755,
+    instrux + 1580,
+};
+
+static const struct itemplate * const itable_0F65[] = {
+    instrux + 757,
+    instrux + 1581,
+};
+
+static const struct itemplate * const itable_0F66[] = {
+    instrux + 756,
+    instrux + 1582,
+};
+
+static const struct itemplate * const itable_0F67[] = {
+    instrux + 738,
+    instrux + 1563,
+};
+
+static const struct itemplate * const itable_0F68[] = {
+    instrux + 833,
+    instrux + 1633,
+};
+
+static const struct itemplate * const itable_0F69[] = {
+    instrux + 835,
+    instrux + 1634,
+};
+
+static const struct itemplate * const itable_0F6A[] = {
+    instrux + 834,
+    instrux + 1635,
+};
+
+static const struct itemplate * const itable_0F6B[] = {
+    instrux + 736,
+    instrux + 1562,
+};
+
+static const struct itemplate * const itable_0F6C[] = {
+    instrux + 1640,
+};
+
+static const struct itemplate * const itable_0F6D[] = {
+    instrux + 1636,
+};
+
+static const struct itemplate * const itable_0F6E[] = {
+    instrux + 656,
+    instrux + 660,
+    instrux + 1546,
+    instrux + 1547,
+    instrux + 1558,
+};
+
+static const struct itemplate * const itable_0F6F[] = {
+    instrux + 658,
+    instrux + 1549,
+    instrux + 1551,
+};
+
+static const struct itemplate * const itable_0F70[] = {
+    instrux + 1531,
+    instrux + 1600,
+    instrux + 1601,
+    instrux + 1602,
+    instrux + 1603,
+    instrux + 1604,
+    instrux + 1605,
+};
+
+static const struct itemplate * const itable_0F71[] = {
+    instrux + 814,
+    instrux + 818,
+    instrux + 824,
+    instrux + 1608,
+    instrux + 1614,
+    instrux + 1619,
+};
+
+static const struct itemplate * const itable_0F72[] = {
+    instrux + 810,
+    instrux + 816,
+    instrux + 820,
+    instrux + 1610,
+    instrux + 1616,
+    instrux + 1621,
+};
+
+static const struct itemplate * const itable_0F73[] = {
+    instrux + 812,
+    instrux + 822,
+    instrux + 1606,
+    instrux + 1612,
+    instrux + 1617,
+    instrux + 1623,
+};
+
+static const struct itemplate * const itable_0F74[] = {
+    instrux + 752,
+    instrux + 1577,
+};
+
+static const struct itemplate * const itable_0F75[] = {
+    instrux + 754,
+    instrux + 1578,
+};
+
+static const struct itemplate * const itable_0F76[] = {
+    instrux + 753,
+    instrux + 1579,
+};
+
+static const struct itemplate * const itable_0F77[] = {
+    instrux + 246,
+};
+
+static const struct itemplate * const itable_0F78[] = {
+    instrux + 1099,
+    instrux + 1738,
+    instrux + 1739,
+    instrux + 1787,
+    instrux + 1789,
+};
+
+static const struct itemplate * const itable_0F79[] = {
+    instrux + 942,
+    instrux + 1743,
+    instrux + 1744,
+    instrux + 1788,
+    instrux + 1790,
+};
+
+static const struct itemplate * const itable_0F7B[] = {
+    instrux + 943,
+};
+
+static const struct itemplate * const itable_0F7C[] = {
+    instrux + 1100,
+    instrux + 1720,
+    instrux + 1721,
+};
+
+static const struct itemplate * const itable_0F7D[] = {
+    instrux + 945,
+    instrux + 1722,
+    instrux + 1723,
+};
+
+static const struct itemplate * const itable_0F7E[] = {
+    instrux + 657,
+    instrux + 661,
+    instrux + 1545,
+    instrux + 1548,
+    instrux + 1554,
+    instrux + 1557,
+    instrux + 1559,
+};
+
+static const struct itemplate * const itable_0F7F[] = {
+    instrux + 659,
+    instrux + 1550,
+    instrux + 1552,
+};
+
+static const struct itemplate * const itable_0F80[] = {
+    instrux + 1317,
+    instrux + 1333,
+    instrux + 1349,
+    instrux + 1365,
+};
+
+static const struct itemplate * const itable_0F81[] = {
+    instrux + 1314,
+    instrux + 1330,
+    instrux + 1346,
+    instrux + 1362,
+};
+
+static const struct itemplate * const itable_0F82[] = {
+    instrux + 1307,
+    instrux + 1323,
+    instrux + 1339,
+    instrux + 1355,
+};
+
+static const struct itemplate * const itable_0F83[] = {
+    instrux + 1311,
+    instrux + 1327,
+    instrux + 1343,
+    instrux + 1359,
+};
+
+static const struct itemplate * const itable_0F84[] = {
+    instrux + 1321,
+    instrux + 1337,
+    instrux + 1353,
+    instrux + 1369,
+};
+
+static const struct itemplate * const itable_0F85[] = {
+    instrux + 1316,
+    instrux + 1332,
+    instrux + 1348,
+    instrux + 1364,
+};
+
+static const struct itemplate * const itable_0F86[] = {
+    instrux + 1310,
+    instrux + 1326,
+    instrux + 1342,
+    instrux + 1358,
+};
+
+static const struct itemplate * const itable_0F87[] = {
+    instrux + 1306,
+    instrux + 1322,
+    instrux + 1338,
+    instrux + 1354,
+};
+
+static const struct itemplate * const itable_0F88[] = {
+    instrux + 1320,
+    instrux + 1336,
+    instrux + 1352,
+    instrux + 1368,
+};
+
+static const struct itemplate * const itable_0F89[] = {
+    instrux + 1315,
+    instrux + 1331,
+    instrux + 1347,
+    instrux + 1363,
+};
+
+static const struct itemplate * const itable_0F8A[] = {
+    instrux + 1318,
+    instrux + 1334,
+    instrux + 1350,
+    instrux + 1366,
+};
+
+static const struct itemplate * const itable_0F8B[] = {
+    instrux + 1319,
+    instrux + 1335,
+    instrux + 1351,
+    instrux + 1367,
+};
+
+static const struct itemplate * const itable_0F8C[] = {
+    instrux + 1309,
+    instrux + 1325,
+    instrux + 1341,
+    instrux + 1357,
+};
+
+static const struct itemplate * const itable_0F8D[] = {
+    instrux + 1313,
+    instrux + 1329,
+    instrux + 1345,
+    instrux + 1361,
+};
+
+static const struct itemplate * const itable_0F8E[] = {
+    instrux + 1312,
+    instrux + 1328,
+    instrux + 1344,
+    instrux + 1360,
+};
+
+static const struct itemplate * const itable_0F8F[] = {
+    instrux + 1308,
+    instrux + 1324,
+    instrux + 1340,
+    instrux + 1356,
+};
+
+static const struct itemplate * const itable_0F90[] = {
+    instrux + 1397,
+    instrux + 1413,
+};
+
+static const struct itemplate * const itable_0F91[] = {
+    instrux + 1394,
+    instrux + 1410,
+};
+
+static const struct itemplate * const itable_0F92[] = {
+    instrux + 1387,
+    instrux + 1403,
+};
+
+static const struct itemplate * const itable_0F93[] = {
+    instrux + 1391,
+    instrux + 1407,
+};
+
+static const struct itemplate * const itable_0F94[] = {
+    instrux + 1401,
+    instrux + 1417,
+};
+
+static const struct itemplate * const itable_0F95[] = {
+    instrux + 1396,
+    instrux + 1412,
+};
+
+static const struct itemplate * const itable_0F96[] = {
+    instrux + 1390,
+    instrux + 1406,
+};
+
+static const struct itemplate * const itable_0F97[] = {
+    instrux + 1386,
+    instrux + 1402,
+};
+
+static const struct itemplate * const itable_0F98[] = {
+    instrux + 1400,
+    instrux + 1416,
+};
+
+static const struct itemplate * const itable_0F99[] = {
+    instrux + 1395,
+    instrux + 1411,
+};
+
+static const struct itemplate * const itable_0F9A[] = {
+    instrux + 1398,
+    instrux + 1414,
+};
+
+static const struct itemplate * const itable_0F9B[] = {
+    instrux + 1399,
+    instrux + 1415,
+};
+
+static const struct itemplate * const itable_0F9C[] = {
+    instrux + 1389,
+    instrux + 1405,
+};
+
+static const struct itemplate * const itable_0F9D[] = {
+    instrux + 1393,
+    instrux + 1409,
+};
+
+static const struct itemplate * const itable_0F9E[] = {
+    instrux + 1392,
+    instrux + 1408,
+};
+
+static const struct itemplate * const itable_0F9F[] = {
+    instrux + 1388,
+    instrux + 1404,
+};
+
+static const struct itemplate * const itable_0FA0[] = {
+    instrux + 849,
+};
+
+static const struct itemplate * const itable_0FA1[] = {
+    instrux + 797,
+};
+
+static const struct itemplate * const itable_0FA2[] = {
+    instrux + 227,
+};
+
+static const struct itemplate * const itable_0FA3[] = {
+    instrux + 121,
+    instrux + 122,
+    instrux + 123,
+    instrux + 124,
+    instrux + 125,
+    instrux + 126,
+};
+
+static const struct itemplate * const itable_0FA4[] = {
+    instrux + 1008,
+    instrux + 1009,
+    instrux + 1010,
+    instrux + 1011,
+    instrux + 1012,
+    instrux + 1013,
+};
+
+static const struct itemplate * const itable_0FA5[] = {
+    instrux + 1014,
+    instrux + 1015,
+    instrux + 1016,
+    instrux + 1017,
+    instrux + 1018,
+    instrux + 1019,
+};
+
+static const struct itemplate * const itable_0FA6C0[] = {
+    instrux + 3388,
+};
+
+static const struct itemplate * const itable_0FA6C8[] = {
+    instrux + 3389,
+};
+
+static const struct itemplate * const itable_0FA6D0[] = {
+    instrux + 3390,
+};
+
+static const struct itemplate * const itable_0FA7C0[] = {
+    instrux + 3382,
+};
+
+static const struct itemplate * const itable_0FA7C8[] = {
+    instrux + 3383,
+};
+
+static const struct itemplate * const itable_0FA7D0[] = {
+    instrux + 3384,
+};
+
+static const struct itemplate * const itable_0FA7D8[] = {
+    instrux + 3385,
+};
+
+static const struct itemplate * const itable_0FA7E0[] = {
+    instrux + 3386,
+};
+
+static const struct itemplate * const itable_0FA7E8[] = {
+    instrux + 3387,
+};
+
+static const struct itemplate * const itable_0FA8[] = {
+    instrux + 850,
+};
+
+static const struct itemplate * const itable_0FA9[] = {
+    instrux + 798,
+};
+
+static const struct itemplate * const itable_0FAA[] = {
+    instrux + 944,
+};
+
+static const struct itemplate * const itable_0FAB[] = {
+    instrux + 148,
+    instrux + 149,
+    instrux + 150,
+    instrux + 151,
+    instrux + 152,
+    instrux + 153,
+};
+
+static const struct itemplate * const itable_0FAC[] = {
+    instrux + 1032,
+    instrux + 1033,
+    instrux + 1034,
+    instrux + 1035,
+    instrux + 1036,
+    instrux + 1037,
+};
+
+static const struct itemplate * const itable_0FAD[] = {
+    instrux + 1038,
+    instrux + 1039,
+    instrux + 1040,
+    instrux + 1041,
+    instrux + 1042,
+    instrux + 1043,
+};
+
+static const struct itemplate * const itable_0FAE[] = {
+    instrux + 546,
+    instrux + 601,
+    instrux + 994,
+    instrux + 1454,
+    instrux + 1484,
+    instrux + 1491,
+    instrux + 1492,
+    instrux + 1493,
+    instrux + 1494,
+    instrux + 1497,
+    instrux + 1498,
+    instrux + 1501,
+    instrux + 1502,
+    instrux + 1505,
+    instrux + 1506,
+    instrux + 1515,
+    instrux + 1538,
+    instrux + 1543,
+    instrux + 1544,
+    instrux + 3358,
+    instrux + 3359,
+    instrux + 3360,
+    instrux + 3361,
+    instrux + 3365,
+    instrux + 3366,
+    instrux + 3367,
+    instrux + 3368,
+    instrux + 6775,
+    instrux + 6776,
+    instrux + 6777,
+    instrux + 6779,
+    instrux + 6780,
+    instrux + 6788,
+    instrux + 6789,
+    instrux + 6790,
+    instrux + 6791,
+    instrux + 6792,
+    instrux + 6965,
+    instrux + 6968,
+    instrux + 6969,
+};
+
+static const struct itemplate * const itable_0FAF[] = {
+    instrux + 445,
+    instrux + 446,
+    instrux + 447,
+    instrux + 448,
+    instrux + 449,
+    instrux + 450,
+};
+
+static const struct itemplate * const itable_0FB0[] = {
+    instrux + 217,
+    instrux + 218,
+};
+
+static const struct itemplate * const itable_0FB1[] = {
+    instrux + 219,
+    instrux + 220,
+    instrux + 221,
+    instrux + 222,
+    instrux + 223,
+    instrux + 224,
+};
+
+static const struct itemplate * const itable_0FB2[] = {
+    instrux + 595,
+    instrux + 596,
+    instrux + 597,
+};
+
+static const struct itemplate * const itable_0FB3[] = {
+    instrux + 139,
+    instrux + 140,
+    instrux + 141,
+    instrux + 142,
+    instrux + 143,
+    instrux + 144,
+};
+
+static const struct itemplate * const itable_0FB4[] = {
+    instrux + 547,
+    instrux + 548,
+    instrux + 549,
+};
+
+static const struct itemplate * const itable_0FB5[] = {
+    instrux + 551,
+    instrux + 552,
+    instrux + 553,
+};
+
+static const struct itemplate * const itable_0FB6[] = {
+    instrux + 673,
+    instrux + 674,
+    instrux + 675,
+    instrux + 677,
+};
+
+static const struct itemplate * const itable_0FB7[] = {
+    instrux + 676,
+    instrux + 678,
+};
+
+static const struct itemplate * const itable_0FB8[] = {
+    instrux + 522,
+    instrux + 523,
+    instrux + 524,
+    instrux + 1865,
+    instrux + 1866,
+    instrux + 1867,
+};
+
+static const struct itemplate * const itable_0FB9[] = {
+    instrux + 1133,
+    instrux + 1134,
+    instrux + 1135,
+};
+
+static const struct itemplate * const itable_0FBA[] = {
+    instrux + 127,
+    instrux + 128,
+    instrux + 129,
+    instrux + 136,
+    instrux + 137,
+    instrux + 138,
+    instrux + 145,
+    instrux + 146,
+    instrux + 147,
+    instrux + 154,
+    instrux + 155,
+    instrux + 156,
+};
+
+static const struct itemplate * const itable_0FBB[] = {
+    instrux + 130,
+    instrux + 131,
+    instrux + 132,
+    instrux + 133,
+    instrux + 134,
+    instrux + 135,
+};
+
+static const struct itemplate * const itable_0FBC[] = {
+    instrux + 107,
+    instrux + 108,
+    instrux + 109,
+    instrux + 110,
+    instrux + 111,
+    instrux + 112,
+    instrux + 4033,
+    instrux + 4034,
+    instrux + 4035,
+};
+
+static const struct itemplate * const itable_0FBD[] = {
+    instrux + 113,
+    instrux + 114,
+    instrux + 115,
+    instrux + 116,
+    instrux + 117,
+    instrux + 118,
+    instrux + 1793,
+    instrux + 1794,
+    instrux + 1795,
+};
+
+static const struct itemplate * const itable_0FBE[] = {
+    instrux + 666,
+    instrux + 667,
+    instrux + 668,
+    instrux + 670,
+};
+
+static const struct itemplate * const itable_0FBF[] = {
+    instrux + 669,
+    instrux + 671,
+};
+
+static const struct itemplate * const itable_0FC0[] = {
+    instrux + 1147,
+    instrux + 1148,
+};
+
+static const struct itemplate * const itable_0FC1[] = {
+    instrux + 1149,
+    instrux + 1150,
+    instrux + 1151,
+    instrux + 1152,
+    instrux + 1153,
+    instrux + 1154,
+};
+
+static const struct itemplate * const itable_0FC2[] = {
+    instrux + 1422,
+    instrux + 1423,
+    instrux + 1424,
+    instrux + 1425,
+    instrux + 1426,
+    instrux + 1427,
+    instrux + 1428,
+    instrux + 1429,
+    instrux + 1430,
+    instrux + 1431,
+    instrux + 1432,
+    instrux + 1433,
+    instrux + 1434,
+    instrux + 1435,
+    instrux + 1436,
+    instrux + 1437,
+    instrux + 1438,
+    instrux + 1439,
+    instrux + 1646,
+    instrux + 1647,
+    instrux + 1648,
+    instrux + 1649,
+    instrux + 1650,
+    instrux + 1651,
+    instrux + 1652,
+    instrux + 1653,
+    instrux + 1654,
+    instrux + 1655,
+    instrux + 1656,
+    instrux + 1657,
+    instrux + 1658,
+    instrux + 1659,
+    instrux + 1660,
+    instrux + 1661,
+    instrux + 1662,
+    instrux + 1663,
+};
+
+static const struct itemplate * const itable_0FC3[] = {
+    instrux + 1540,
+    instrux + 1541,
+};
+
+static const struct itemplate * const itable_0FC4[] = {
+    instrux + 1521,
+    instrux + 1522,
+    instrux + 1523,
+    instrux + 1584,
+    instrux + 1585,
+    instrux + 1586,
+};
+
+static const struct itemplate * const itable_0FC5[] = {
+    instrux + 1520,
+    instrux + 1583,
+};
+
+static const struct itemplate * const itable_0FC6[] = {
+    instrux + 1481,
+    instrux + 1709,
+};
+
+static const struct itemplate * const itable_0FC7[] = {
+    instrux + 225,
+    instrux + 226,
+    instrux + 1499,
+    instrux + 1500,
+    instrux + 1503,
+    instrux + 1504,
+    instrux + 1507,
+    instrux + 1508,
+    instrux + 1731,
+    instrux + 1736,
+    instrux + 1737,
+    instrux + 1746,
+    instrux + 3362,
+    instrux + 3363,
+    instrux + 3364,
+    instrux + 3377,
+    instrux + 3378,
+    instrux + 3379,
+    instrux + 6772,
+    instrux + 6773,
+    instrux + 6774,
+    instrux + 7401,
+};
+
+static const struct itemplate * const itable_0FC8[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FC9[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FCA[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FCB[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FCC[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FCD[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FCE[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FCF[] = {
+    instrux + 119,
+    instrux + 120,
+};
+
+static const struct itemplate * const itable_0FD0[] = {
+    instrux + 1718,
+    instrux + 1719,
+};
+
+static const struct itemplate * const itable_0FD1[] = {
+    instrux + 823,
+    instrux + 1618,
+};
+
+static const struct itemplate * const itable_0FD2[] = {
+    instrux + 819,
+    instrux + 1620,
+};
+
+static const struct itemplate * const itable_0FD3[] = {
+    instrux + 821,
+    instrux + 1622,
+};
+
+static const struct itemplate * const itable_0FD4[] = {
+    instrux + 1567,
+    instrux + 1568,
+};
+
+static const struct itemplate * const itable_0FD5[] = {
+    instrux + 783,
+    instrux + 1595,
+};
+
+static const struct itemplate * const itable_0FD6[] = {
+    instrux + 1553,
+    instrux + 1555,
+    instrux + 1556,
+    instrux + 1560,
+};
+
+static const struct itemplate * const itable_0FD7[] = {
+    instrux + 1528,
+    instrux + 1592,
+};
+
+static const struct itemplate * const itable_0FD8[] = {
+    instrux + 830,
+    instrux + 1631,
+};
+
+static const struct itemplate * const itable_0FD9[] = {
+    instrux + 831,
+    instrux + 1632,
+};
+
+static const struct itemplate * const itable_0FDA[] = {
+    instrux + 1527,
+    instrux + 1591,
+};
+
+static const struct itemplate * const itable_0FDB[] = {
+    instrux + 747,
+    instrux + 1573,
+};
+
+static const struct itemplate * const itable_0FDC[] = {
+    instrux + 744,
+    instrux + 1571,
+};
+
+static const struct itemplate * const itable_0FDD[] = {
+    instrux + 745,
+    instrux + 1572,
+};
+
+static const struct itemplate * const itable_0FDE[] = {
+    instrux + 1525,
+    instrux + 1589,
+};
+
+static const struct itemplate * const itable_0FDF[] = {
+    instrux + 748,
+    instrux + 1574,
+};
+
+static const struct itemplate * const itable_0FE0[] = {
+    instrux + 1518,
+    instrux + 1575,
+};
+
+static const struct itemplate * const itable_0FE1[] = {
+    instrux + 817,
+    instrux + 1613,
+};
+
+static const struct itemplate * const itable_0FE2[] = {
+    instrux + 815,
+    instrux + 1615,
+};
+
+static const struct itemplate * const itable_0FE3[] = {
+    instrux + 1519,
+    instrux + 1576,
+};
+
+static const struct itemplate * const itable_0FE4[] = {
+    instrux + 1529,
+    instrux + 1593,
+};
+
+static const struct itemplate * const itable_0FE5[] = {
+    instrux + 782,
+    instrux + 1594,
+};
+
+static const struct itemplate * const itable_0FE6[] = {
+    instrux + 1665,
+    instrux + 1667,
+    instrux + 1682,
+};
+
+static const struct itemplate * const itable_0FE7[] = {
+    instrux + 1517,
+    instrux + 1539,
+};
+
+static const struct itemplate * const itable_0FE8[] = {
+    instrux + 827,
+    instrux + 1629,
+};
+
+static const struct itemplate * const itable_0FE9[] = {
+    instrux + 829,
+    instrux + 1630,
+};
+
+static const struct itemplate * const itable_0FEA[] = {
+    instrux + 1526,
+    instrux + 1590,
+};
+
+static const struct itemplate * const itable_0FEB[] = {
+    instrux + 806,
+    instrux + 1598,
+};
+
+static const struct itemplate * const itable_0FEC[] = {
+    instrux + 741,
+    instrux + 1569,
+};
+
+static const struct itemplate * const itable_0FED[] = {
+    instrux + 743,
+    instrux + 1570,
+};
+
+static const struct itemplate * const itable_0FEE[] = {
+    instrux + 1524,
+    instrux + 1588,
+};
+
+static const struct itemplate * const itable_0FEF[] = {
+    instrux + 864,
+    instrux + 1641,
+};
+
+static const struct itemplate * const itable_0FF0[] = {
+    instrux + 1724,
+};
+
+static const struct itemplate * const itable_0FF1[] = {
+    instrux + 813,
+    instrux + 1607,
+};
+
+static const struct itemplate * const itable_0FF2[] = {
+    instrux + 809,
+    instrux + 1609,
+};
+
+static const struct itemplate * const itable_0FF3[] = {
+    instrux + 811,
+    instrux + 1611,
+};
+
+static const struct itemplate * const itable_0FF4[] = {
+    instrux + 1596,
+    instrux + 1597,
+};
+
+static const struct itemplate * const itable_0FF5[] = {
+    instrux + 777,
+    instrux + 1587,
+};
+
+static const struct itemplate * const itable_0FF6[] = {
+    instrux + 1530,
+    instrux + 1599,
+};
+
+static const struct itemplate * const itable_0FF7[] = {
+    instrux + 1516,
+    instrux + 1537,
+};
+
+static const struct itemplate * const itable_0FF8[] = {
+    instrux + 825,
+    instrux + 1624,
+};
+
+static const struct itemplate * const itable_0FF9[] = {
+    instrux + 832,
+    instrux + 1625,
+};
+
+static const struct itemplate * const itable_0FFA[] = {
+    instrux + 826,
+    instrux + 1626,
+};
+
+static const struct itemplate * const itable_0FFB[] = {
+    instrux + 1627,
+    instrux + 1628,
+};
+
+static const struct itemplate * const itable_0FFC[] = {
+    instrux + 739,
+    instrux + 1564,
+};
+
+static const struct itemplate * const itable_0FFD[] = {
+    instrux + 746,
+    instrux + 1565,
+};
+
+static const struct itemplate * const itable_0FFE[] = {
+    instrux + 740,
+    instrux + 1566,
+};
+
+static const struct itemplate * const itable_0FFF[] = {
+    instrux + 1129,
+    instrux + 1130,
+    instrux + 1131,
+    instrux + 1132,
+};
+
+static const struct itemplate * const itable_10[] = {
+    instrux + 14,
+    instrux + 15,
+};
+
+static const struct itemplate * const itable_11[] = {
+    instrux + 16,
+    instrux + 17,
+    instrux + 18,
+    instrux + 19,
+    instrux + 20,
+    instrux + 21,
+};
+
+static const struct itemplate * const itable_12[] = {
+    instrux + 22,
+    instrux + 23,
+};
+
+static const struct itemplate * const itable_13[] = {
+    instrux + 24,
+    instrux + 25,
+    instrux + 26,
+    instrux + 27,
+    instrux + 28,
+    instrux + 29,
+};
+
+static const struct itemplate * const itable_14[] = {
+    instrux + 33,
+};
+
+static const struct itemplate * const itable_15[] = {
+    instrux + 34,
+    instrux + 35,
+    instrux + 36,
+};
+
+static const struct itemplate * const itable_16[] = {
+    instrux + 847,
+};
+
+static const struct itemplate * const itable_17[] = {
+    instrux + 795,
+};
+
+static const struct itemplate * const itable_18[] = {
+    instrux + 960,
+    instrux + 961,
+};
+
+static const struct itemplate * const itable_19[] = {
+    instrux + 962,
+    instrux + 963,
+    instrux + 964,
+    instrux + 965,
+    instrux + 966,
+    instrux + 967,
+};
+
+static const struct itemplate * const itable_1A[] = {
+    instrux + 968,
+    instrux + 969,
+};
+
+static const struct itemplate * const itable_1B[] = {
+    instrux + 970,
+    instrux + 971,
+    instrux + 972,
+    instrux + 973,
+    instrux + 974,
+    instrux + 975,
+};
+
+static const struct itemplate * const itable_1C[] = {
+    instrux + 979,
+};
+
+static const struct itemplate * const itable_1D[] = {
+    instrux + 980,
+    instrux + 981,
+    instrux + 982,
+};
+
+static const struct itemplate * const itable_1E[] = {
+    instrux + 848,
+};
+
+static const struct itemplate * const itable_1F[] = {
+    instrux + 796,
+};
+
+static const struct itemplate * const itable_20[] = {
+    instrux + 73,
+    instrux + 74,
+};
+
+static const struct itemplate * const itable_21[] = {
+    instrux + 75,
+    instrux + 76,
+    instrux + 77,
+    instrux + 78,
+    instrux + 79,
+    instrux + 80,
+};
+
+static const struct itemplate * const itable_22[] = {
+    instrux + 81,
+    instrux + 82,
+};
+
+static const struct itemplate * const itable_23[] = {
+    instrux + 83,
+    instrux + 84,
+    instrux + 85,
+    instrux + 86,
+    instrux + 87,
+    instrux + 88,
+};
+
+static const struct itemplate * const itable_24[] = {
+    instrux + 92,
+};
+
+static const struct itemplate * const itable_25[] = {
+    instrux + 93,
+    instrux + 94,
+    instrux + 95,
+};
+
+static const struct itemplate * const itable_27[] = {
+    instrux + 233,
+};
+
+static const struct itemplate * const itable_28[] = {
+    instrux + 1069,
+    instrux + 1070,
+};
+
+static const struct itemplate * const itable_29[] = {
+    instrux + 1071,
+    instrux + 1072,
+    instrux + 1073,
+    instrux + 1074,
+    instrux + 1075,
+    instrux + 1076,
+};
+
+static const struct itemplate * const itable_2A[] = {
+    instrux + 1077,
+    instrux + 1078,
+};
+
+static const struct itemplate * const itable_2B[] = {
+    instrux + 1079,
+    instrux + 1080,
+    instrux + 1081,
+    instrux + 1082,
+    instrux + 1083,
+    instrux + 1084,
+};
+
+static const struct itemplate * const itable_2C[] = {
+    instrux + 1088,
+};
+
+static const struct itemplate * const itable_2D[] = {
+    instrux + 1089,
+    instrux + 1090,
+    instrux + 1091,
+};
+
+static const struct itemplate * const itable_2F[] = {
+    instrux + 234,
+};
+
+static const struct itemplate * const itable_30[] = {
+    instrux + 1180,
+    instrux + 1181,
+};
+
+static const struct itemplate * const itable_31[] = {
+    instrux + 1182,
+    instrux + 1183,
+    instrux + 1184,
+    instrux + 1185,
+    instrux + 1186,
+    instrux + 1187,
+};
+
+static const struct itemplate * const itable_32[] = {
+    instrux + 1188,
+    instrux + 1189,
+};
+
+static const struct itemplate * const itable_33[] = {
+    instrux + 1190,
+    instrux + 1191,
+    instrux + 1192,
+    instrux + 1193,
+    instrux + 1194,
+    instrux + 1195,
+};
+
+static const struct itemplate * const itable_34[] = {
+    instrux + 1199,
+};
+
+static const struct itemplate * const itable_35[] = {
+    instrux + 1200,
+    instrux + 1201,
+    instrux + 1202,
+};
+
+static const struct itemplate * const itable_37[] = {
+    instrux + 8,
+};
+
+static const struct itemplate * const itable_38[] = {
+    instrux + 183,
+    instrux + 184,
+};
+
+static const struct itemplate * const itable_39[] = {
+    instrux + 185,
+    instrux + 186,
+    instrux + 187,
+    instrux + 188,
+    instrux + 189,
+    instrux + 190,
+};
+
+static const struct itemplate * const itable_3A[] = {
+    instrux + 191,
+    instrux + 192,
+};
+
+static const struct itemplate * const itable_3B[] = {
+    instrux + 193,
+    instrux + 194,
+    instrux + 195,
+    instrux + 196,
+    instrux + 197,
+    instrux + 198,
+};
+
+static const struct itemplate * const itable_3C[] = {
+    instrux + 202,
+};
+
+static const struct itemplate * const itable_3D[] = {
+    instrux + 203,
+    instrux + 204,
+    instrux + 205,
+};
+
+static const struct itemplate * const itable_3F[] = {
+    instrux + 13,
+};
+
+static const struct itemplate * const itable_40[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_41[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_42[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_43[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_44[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_45[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_46[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_47[] = {
+    instrux + 475,
+    instrux + 476,
+};
+
+static const struct itemplate * const itable_48[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_49[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_4A[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_4B[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_4C[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_4D[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_4E[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_4F[] = {
+    instrux + 235,
+    instrux + 236,
+};
+
+static const struct itemplate * const itable_50[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_51[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_52[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_53[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_54[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_55[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_56[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_57[] = {
+    instrux + 839,
+    instrux + 840,
+    instrux + 841,
+};
+
+static const struct itemplate * const itable_58[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_59[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_5A[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_5B[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_5C[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_5D[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_5E[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_5F[] = {
+    instrux + 788,
+    instrux + 789,
+    instrux + 790,
+};
+
+static const struct itemplate * const itable_60[] = {
+    instrux + 857,
+    instrux + 858,
+    instrux + 859,
+};
+
+static const struct itemplate * const itable_61[] = {
+    instrux + 799,
+    instrux + 800,
+    instrux + 801,
+};
+
+static const struct itemplate * const itable_62[] = {
+    instrux + 105,
+    instrux + 106,
+};
+
+static const struct itemplate * const itable_63[] = {
+    instrux + 103,
+    instrux + 104,
+    instrux + 672,
+};
+
+static const struct itemplate * const itable_68[] = {
+    instrux + 852,
+    instrux + 853,
+    instrux + 854,
+    instrux + 855,
+    instrux + 856,
+};
+
+static const struct itemplate * const itable_69[] = {
+    instrux + 452,
+    instrux + 454,
+    instrux + 456,
+    instrux + 458,
+    instrux + 460,
+    instrux + 462,
+    instrux + 464,
+    instrux + 466,
+    instrux + 468,
+};
+
+static const struct itemplate * const itable_6A[] = {
+    instrux + 851,
+};
+
+static const struct itemplate * const itable_6B[] = {
+    instrux + 451,
+    instrux + 453,
+    instrux + 455,
+    instrux + 457,
+    instrux + 459,
+    instrux + 461,
+    instrux + 463,
+    instrux + 465,
+    instrux + 467,
+};
+
+static const struct itemplate * const itable_6C[] = {
+    instrux + 481,
+};
+
+static const struct itemplate * const itable_6D[] = {
+    instrux + 482,
+    instrux + 483,
+};
+
+static const struct itemplate * const itable_6E[] = {
+    instrux + 733,
+};
+
+static const struct itemplate * const itable_6F[] = {
+    instrux + 734,
+    instrux + 735,
+};
+
+static const struct itemplate * const itable_70[] = {
+    instrux + 1381,
+};
+
+static const struct itemplate * const itable_71[] = {
+    instrux + 1378,
+};
+
+static const struct itemplate * const itable_72[] = {
+    instrux + 1371,
+};
+
+static const struct itemplate * const itable_73[] = {
+    instrux + 1375,
+};
+
+static const struct itemplate * const itable_74[] = {
+    instrux + 1385,
+};
+
+static const struct itemplate * const itable_75[] = {
+    instrux + 1380,
+};
+
+static const struct itemplate * const itable_76[] = {
+    instrux + 1374,
+};
+
+static const struct itemplate * const itable_77[] = {
+    instrux + 1370,
+};
+
+static const struct itemplate * const itable_78[] = {
+    instrux + 1384,
+};
+
+static const struct itemplate * const itable_79[] = {
+    instrux + 1379,
+};
+
+static const struct itemplate * const itable_7A[] = {
+    instrux + 1382,
+};
+
+static const struct itemplate * const itable_7B[] = {
+    instrux + 1383,
+};
+
+static const struct itemplate * const itable_7C[] = {
+    instrux + 1373,
+};
+
+static const struct itemplate * const itable_7D[] = {
+    instrux + 1377,
+};
+
+static const struct itemplate * const itable_7E[] = {
+    instrux + 1376,
+};
+
+static const struct itemplate * const itable_7F[] = {
+    instrux + 1372,
+};
+
+static const struct itemplate * const itable_80[] = {
+    instrux + 37,
+    instrux + 66,
+    instrux + 70,
+    instrux + 96,
+    instrux + 100,
+    instrux + 206,
+    instrux + 210,
+    instrux + 720,
+    instrux + 724,
+    instrux + 983,
+    instrux + 987,
+    instrux + 1092,
+    instrux + 1096,
+    instrux + 1203,
+    instrux + 1207,
+};
+
+static const struct itemplate * const itable_81[] = {
+    instrux + 38,
+    instrux + 39,
+    instrux + 40,
+    instrux + 41,
+    instrux + 42,
+    instrux + 67,
+    instrux + 68,
+    instrux + 69,
+    instrux + 71,
+    instrux + 72,
+    instrux + 97,
+    instrux + 98,
+    instrux + 99,
+    instrux + 101,
+    instrux + 102,
+    instrux + 207,
+    instrux + 208,
+    instrux + 209,
+    instrux + 211,
+    instrux + 212,
+    instrux + 721,
+    instrux + 722,
+    instrux + 723,
+    instrux + 725,
+    instrux + 726,
+    instrux + 984,
+    instrux + 985,
+    instrux + 986,
+    instrux + 988,
+    instrux + 989,
+    instrux + 1093,
+    instrux + 1094,
+    instrux + 1095,
+    instrux + 1097,
+    instrux + 1098,
+    instrux + 1204,
+    instrux + 1205,
+    instrux + 1206,
+    instrux + 1208,
+    instrux + 1209,
+};
+
+static const struct itemplate * const itable_83[] = {
+    instrux + 30,
+    instrux + 31,
+    instrux + 32,
+    instrux + 59,
+    instrux + 60,
+    instrux + 61,
+    instrux + 89,
+    instrux + 90,
+    instrux + 91,
+    instrux + 199,
+    instrux + 200,
+    instrux + 201,
+    instrux + 713,
+    instrux + 714,
+    instrux + 715,
+    instrux + 976,
+    instrux + 977,
+    instrux + 978,
+    instrux + 1085,
+    instrux + 1086,
+    instrux + 1087,
+    instrux + 1196,
+    instrux + 1197,
+    instrux + 1198,
+};
+
+static const struct itemplate * const itable_84[] = {
+    instrux + 1106,
+    instrux + 1107,
+    instrux + 1114,
+};
+
+static const struct itemplate * const itable_85[] = {
+    instrux + 1108,
+    instrux + 1109,
+    instrux + 1110,
+    instrux + 1111,
+    instrux + 1112,
+    instrux + 1113,
+    instrux + 1115,
+    instrux + 1116,
+    instrux + 1117,
+};
+
+static const struct itemplate * const itable_86[] = {
+    instrux + 1162,
+    instrux + 1163,
+    instrux + 1170,
+    instrux + 1171,
+};
+
+static const struct itemplate * const itable_87[] = {
+    instrux + 1164,
+    instrux + 1165,
+    instrux + 1166,
+    instrux + 1167,
+    instrux + 1168,
+    instrux + 1169,
+    instrux + 1172,
+    instrux + 1173,
+    instrux + 1174,
+    instrux + 1175,
+    instrux + 1176,
+    instrux + 1177,
+};
+
+static const struct itemplate * const itable_88[] = {
+    instrux + 628,
+    instrux + 629,
+};
+
+static const struct itemplate * const itable_89[] = {
+    instrux + 630,
+    instrux + 631,
+    instrux + 632,
+    instrux + 633,
+    instrux + 634,
+    instrux + 635,
+};
+
+static const struct itemplate * const itable_8A[] = {
+    instrux + 636,
+    instrux + 637,
+};
+
+static const struct itemplate * const itable_8B[] = {
+    instrux + 638,
+    instrux + 639,
+    instrux + 640,
+    instrux + 641,
+    instrux + 642,
+    instrux + 643,
+};
+
+static const struct itemplate * const itable_8C[] = {
+    instrux + 604,
+    instrux + 605,
+    instrux + 606,
+    instrux + 607,
+};
+
+static const struct itemplate * const itable_8D[] = {
+    instrux + 540,
+    instrux + 541,
+    instrux + 542,
+};
+
+static const struct itemplate * const itable_8E[] = {
+    instrux + 608,
+    instrux + 609,
+    instrux + 610,
+    instrux + 611,
+};
+
+static const struct itemplate * const itable_8F[] = {
+    instrux + 791,
+    instrux + 792,
+    instrux + 793,
+};
+
+static const struct itemplate * const itable_90[] = {
+    instrux + 689,
+    instrux + 749,
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+    instrux + 1161,
+};
+
+static const struct itemplate * const itable_91[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_92[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_93[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_94[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_95[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_96[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_97[] = {
+    instrux + 1155,
+    instrux + 1156,
+    instrux + 1157,
+    instrux + 1158,
+    instrux + 1159,
+    instrux + 1160,
+};
+
+static const struct itemplate * const itable_98[] = {
+    instrux + 175,
+    instrux + 177,
+    instrux + 232,
+};
+
+static const struct itemplate * const itable_99[] = {
+    instrux + 176,
+    instrux + 230,
+    instrux + 231,
+};
+
+static const struct itemplate * const itable_9A[] = {
+    instrux + 161,
+    instrux + 162,
+    instrux + 163,
+    instrux + 164,
+    instrux + 165,
+};
+
+static const struct itemplate * const itable_9C[] = {
+    instrux + 860,
+    instrux + 861,
+    instrux + 862,
+    instrux + 863,
+};
+
+static const struct itemplate * const itable_9D[] = {
+    instrux + 802,
+    instrux + 803,
+    instrux + 804,
+    instrux + 805,
+};
+
+static const struct itemplate * const itable_9E[] = {
+    instrux + 946,
+};
+
+static const struct itemplate * const itable_9F[] = {
+    instrux + 527,
+};
+
+static const struct itemplate * const itable_A0[] = {
+    instrux + 612,
+};
+
+static const struct itemplate * const itable_A1[] = {
+    instrux + 613,
+    instrux + 614,
+    instrux + 615,
+};
+
+static const struct itemplate * const itable_A2[] = {
+    instrux + 616,
+};
+
+static const struct itemplate * const itable_A3[] = {
+    instrux + 617,
+    instrux + 618,
+    instrux + 619,
+};
+
+static const struct itemplate * const itable_A4[] = {
+    instrux + 662,
+};
+
+static const struct itemplate * const itable_A5[] = {
+    instrux + 663,
+    instrux + 664,
+    instrux + 665,
+};
+
+static const struct itemplate * const itable_A6[] = {
+    instrux + 213,
+};
+
+static const struct itemplate * const itable_A7[] = {
+    instrux + 214,
+    instrux + 215,
+    instrux + 216,
+};
+
+static const struct itemplate * const itable_A8[] = {
+    instrux + 1118,
+};
+
+static const struct itemplate * const itable_A9[] = {
+    instrux + 1119,
+    instrux + 1120,
+    instrux + 1121,
+};
+
+static const struct itemplate * const itable_AA[] = {
+    instrux + 1060,
+};
+
+static const struct itemplate * const itable_AB[] = {
+    instrux + 1061,
+    instrux + 1062,
+    instrux + 1063,
+};
+
+static const struct itemplate * const itable_AC[] = {
+    instrux + 561,
+};
+
+static const struct itemplate * const itable_AD[] = {
+    instrux + 562,
+    instrux + 563,
+    instrux + 564,
+};
+
+static const struct itemplate * const itable_AE[] = {
+    instrux + 990,
+};
+
+static const struct itemplate * const itable_AF[] = {
+    instrux + 991,
+    instrux + 992,
+    instrux + 993,
+};
+
+static const struct itemplate * const itable_B0[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B1[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B2[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B3[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B4[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B5[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B6[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B7[] = {
+    instrux + 644,
+};
+
+static const struct itemplate * const itable_B8[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_B9[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_BA[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_BB[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_BC[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_BD[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_BE[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_BF[] = {
+    instrux + 645,
+    instrux + 646,
+    instrux + 647,
+};
+
+static const struct itemplate * const itable_C0[] = {
+    instrux + 867,
+    instrux + 879,
+    instrux + 920,
+    instrux + 932,
+    instrux + 950,
+    instrux + 998,
+    instrux + 1022,
+};
+
+static const struct itemplate * const itable_C1[] = {
+    instrux + 870,
+    instrux + 873,
+    instrux + 876,
+    instrux + 882,
+    instrux + 885,
+    instrux + 888,
+    instrux + 923,
+    instrux + 926,
+    instrux + 929,
+    instrux + 935,
+    instrux + 938,
+    instrux + 941,
+    instrux + 953,
+    instrux + 956,
+    instrux + 959,
+    instrux + 1001,
+    instrux + 1004,
+    instrux + 1007,
+    instrux + 1025,
+    instrux + 1028,
+    instrux + 1031,
+};
+
+static const struct itemplate * const itable_C2[] = {
+    instrux + 895,
+    instrux + 899,
+    instrux + 901,
+    instrux + 905,
+    instrux + 907,
+    instrux + 911,
+    instrux + 913,
+    instrux + 917,
+};
+
+static const struct itemplate * const itable_C3[] = {
+    instrux + 894,
+    instrux + 898,
+    instrux + 900,
+    instrux + 904,
+    instrux + 906,
+    instrux + 910,
+    instrux + 912,
+    instrux + 916,
+};
+
+static const struct itemplate * const itable_C4[] = {
+    instrux + 544,
+    instrux + 545,
+};
+
+static const struct itemplate * const itable_C5[] = {
+    instrux + 538,
+    instrux + 539,
+};
+
+static const struct itemplate * const itable_C6[] = {
+    instrux + 648,
+    instrux + 653,
+    instrux + 3983,
+    instrux + 3984,
+};
+
+static const struct itemplate * const itable_C7[] = {
+    instrux + 649,
+    instrux + 650,
+    instrux + 651,
+    instrux + 652,
+    instrux + 654,
+    instrux + 655,
+    instrux + 3985,
+    instrux + 3986,
+    instrux + 3987,
+    instrux + 3988,
+};
+
+static const struct itemplate * const itable_C8[] = {
+    instrux + 247,
+};
+
+static const struct itemplate * const itable_C9[] = {
+    instrux + 543,
+};
+
+static const struct itemplate * const itable_CA[] = {
+    instrux + 897,
+    instrux + 903,
+    instrux + 909,
+    instrux + 915,
+};
+
+static const struct itemplate * const itable_CB[] = {
+    instrux + 896,
+    instrux + 902,
+    instrux + 908,
+    instrux + 914,
+};
+
+static const struct itemplate * const itable_CC[] = {
+    instrux + 486,
+};
+
+static const struct itemplate * const itable_CD[] = {
+    instrux + 484,
+};
+
+static const struct itemplate * const itable_CE[] = {
+    instrux + 487,
+};
+
+static const struct itemplate * const itable_CF[] = {
+    instrux + 496,
+    instrux + 497,
+    instrux + 498,
+    instrux + 499,
+};
+
+static const struct itemplate * const itable_D0[] = {
+    instrux + 865,
+    instrux + 877,
+    instrux + 918,
+    instrux + 930,
+    instrux + 948,
+    instrux + 996,
+    instrux + 1020,
+};
+
+static const struct itemplate * const itable_D1[] = {
+    instrux + 868,
+    instrux + 871,
+    instrux + 874,
+    instrux + 880,
+    instrux + 883,
+    instrux + 886,
+    instrux + 921,
+    instrux + 924,
+    instrux + 927,
+    instrux + 933,
+    instrux + 936,
+    instrux + 939,
+    instrux + 951,
+    instrux + 954,
+    instrux + 957,
+    instrux + 999,
+    instrux + 1002,
+    instrux + 1005,
+    instrux + 1023,
+    instrux + 1026,
+    instrux + 1029,
+};
+
+static const struct itemplate * const itable_D2[] = {
+    instrux + 866,
+    instrux + 878,
+    instrux + 919,
+    instrux + 931,
+    instrux + 949,
+    instrux + 997,
+    instrux + 1021,
+};
+
+static const struct itemplate * const itable_D3[] = {
+    instrux + 869,
+    instrux + 872,
+    instrux + 875,
+    instrux + 881,
+    instrux + 884,
+    instrux + 887,
+    instrux + 922,
+    instrux + 925,
+    instrux + 928,
+    instrux + 934,
+    instrux + 937,
+    instrux + 940,
+    instrux + 952,
+    instrux + 955,
+    instrux + 958,
+    instrux + 1000,
+    instrux + 1003,
+    instrux + 1006,
+    instrux + 1024,
+    instrux + 1027,
+    instrux + 1030,
+};
+
+static const struct itemplate * const itable_D4[] = {
+    instrux + 11,
+    instrux + 12,
+};
+
+static const struct itemplate * const itable_D5[] = {
+    instrux + 9,
+    instrux + 10,
+};
+
+static const struct itemplate * const itable_D6[] = {
+    instrux + 947,
+};
+
+static const struct itemplate * const itable_D7[] = {
+    instrux + 1178,
+    instrux + 1179,
+};
+
+static const struct itemplate * const itable_D8[] = {
+    instrux + 252,
+    instrux + 255,
+    instrux + 257,
+    instrux + 282,
+    instrux + 284,
+    instrux + 285,
+    instrux + 290,
+    instrux + 292,
+    instrux + 293,
+    instrux + 298,
+    instrux + 301,
+    instrux + 303,
+    instrux + 306,
+    instrux + 310,
+    instrux + 311,
+    instrux + 362,
+    instrux + 366,
+    instrux + 367,
+    instrux + 403,
+    instrux + 407,
+    instrux + 408,
+    instrux + 411,
+    instrux + 415,
+    instrux + 416,
+};
+
+static const struct itemplate * const itable_D9[] = {
+    instrux + 250,
+    instrux + 251,
+    instrux + 264,
+    instrux + 295,
+    instrux + 296,
+    instrux + 335,
+    instrux + 349,
+    instrux + 352,
+    instrux + 353,
+    instrux + 354,
+    instrux + 355,
+    instrux + 356,
+    instrux + 357,
+    instrux + 358,
+    instrux + 359,
+    instrux + 360,
+    instrux + 361,
+    instrux + 374,
+    instrux + 376,
+    instrux + 377,
+    instrux + 380,
+    instrux + 381,
+    instrux + 382,
+    instrux + 383,
+    instrux + 384,
+    instrux + 387,
+    instrux + 389,
+    instrux + 390,
+    instrux + 391,
+    instrux + 392,
+    instrux + 395,
+    instrux + 396,
+    instrux + 397,
+    instrux + 419,
+    instrux + 429,
+    instrux + 430,
+    instrux + 431,
+    instrux + 432,
+    instrux + 433,
+    instrux + 434,
+    instrux + 435,
+};
+
+static const struct itemplate * const itable_DA[] = {
+    instrux + 266,
+    instrux + 267,
+    instrux + 268,
+    instrux + 269,
+    instrux + 270,
+    instrux + 271,
+    instrux + 280,
+    instrux + 281,
+    instrux + 320,
+    instrux + 322,
+    instrux + 324,
+    instrux + 326,
+    instrux + 328,
+    instrux + 333,
+    instrux + 345,
+    instrux + 347,
+    instrux + 428,
+};
+
+static const struct itemplate * const itable_DB[] = {
+    instrux + 265,
+    instrux + 272,
+    instrux + 273,
+    instrux + 274,
+    instrux + 275,
+    instrux + 276,
+    instrux + 277,
+    instrux + 278,
+    instrux + 279,
+    instrux + 286,
+    instrux + 287,
+    instrux + 297,
+    instrux + 315,
+    instrux + 330,
+    instrux + 336,
+    instrux + 337,
+    instrux + 339,
+    instrux + 343,
+    instrux + 351,
+    instrux + 370,
+    instrux + 371,
+    instrux + 372,
+    instrux + 373,
+    instrux + 388,
+    instrux + 399,
+    instrux + 422,
+    instrux + 423,
+};
+
+static const struct itemplate * const itable_DC[] = {
+    instrux + 253,
+    instrux + 254,
+    instrux + 256,
+    instrux + 283,
+    instrux + 291,
+    instrux + 299,
+    instrux + 300,
+    instrux + 302,
+    instrux + 307,
+    instrux + 308,
+    instrux + 309,
+    instrux + 363,
+    instrux + 364,
+    instrux + 365,
+    instrux + 404,
+    instrux + 405,
+    instrux + 406,
+    instrux + 412,
+    instrux + 413,
+    instrux + 414,
+};
+
+static const struct itemplate * const itable_DD[] = {
+    instrux + 316,
+    instrux + 317,
+    instrux + 344,
+    instrux + 350,
+    instrux + 375,
+    instrux + 378,
+    instrux + 385,
+    instrux + 386,
+    instrux + 393,
+    instrux + 394,
+    instrux + 398,
+    instrux + 400,
+    instrux + 401,
+    instrux + 420,
+    instrux + 421,
+    instrux + 426,
+    instrux + 427,
+};
+
+static const struct itemplate * const itable_DE[] = {
+    instrux + 258,
+    instrux + 259,
+    instrux + 294,
+    instrux + 304,
+    instrux + 305,
+    instrux + 312,
+    instrux + 313,
+    instrux + 321,
+    instrux + 323,
+    instrux + 325,
+    instrux + 327,
+    instrux + 329,
+    instrux + 334,
+    instrux + 346,
+    instrux + 348,
+    instrux + 368,
+    instrux + 369,
+    instrux + 409,
+    instrux + 410,
+    instrux + 417,
+    instrux + 418,
+};
+
+static const struct itemplate * const itable_DF[] = {
+    instrux + 260,
+    instrux + 261,
+    instrux + 262,
+    instrux + 263,
+    instrux + 288,
+    instrux + 289,
+    instrux + 318,
+    instrux + 319,
+    instrux + 331,
+    instrux + 332,
+    instrux + 338,
+    instrux + 340,
+    instrux + 341,
+    instrux + 342,
+    instrux + 379,
+    instrux + 402,
+    instrux + 424,
+    instrux + 425,
+};
+
+static const struct itemplate * const itable_E0[] = {
+    instrux + 573,
+    instrux + 574,
+    instrux + 575,
+    instrux + 576,
+    instrux + 577,
+    instrux + 578,
+    instrux + 579,
+    instrux + 580,
+};
+
+static const struct itemplate * const itable_E1[] = {
+    instrux + 569,
+    instrux + 570,
+    instrux + 571,
+    instrux + 572,
+    instrux + 581,
+    instrux + 582,
+    instrux + 583,
+    instrux + 584,
+};
+
+static const struct itemplate * const itable_E2[] = {
+    instrux + 565,
+    instrux + 566,
+    instrux + 567,
+    instrux + 568,
+};
+
+static const struct itemplate * const itable_E3[] = {
+    instrux + 500,
+    instrux + 501,
+    instrux + 502,
+};
+
+static const struct itemplate * const itable_E4[] = {
+    instrux + 469,
+};
+
+static const struct itemplate * const itable_E5[] = {
+    instrux + 470,
+    instrux + 471,
+};
+
+static const struct itemplate * const itable_E6[] = {
+    instrux + 727,
+};
+
+static const struct itemplate * const itable_E7[] = {
+    instrux + 728,
+    instrux + 729,
+};
+
+static const struct itemplate * const itable_E8[] = {
+    instrux + 157,
+    instrux + 158,
+    instrux + 159,
+    instrux + 160,
+};
+
+static const struct itemplate * const itable_E9[] = {
+    instrux + 504,
+    instrux + 505,
+    instrux + 506,
+    instrux + 507,
+};
+
+static const struct itemplate * const itable_EA[] = {
+    instrux + 508,
+    instrux + 509,
+    instrux + 510,
+    instrux + 511,
+    instrux + 512,
+};
+
+static const struct itemplate * const itable_EB[] = {
+    instrux + 503,
+};
+
+static const struct itemplate * const itable_EC[] = {
+    instrux + 472,
+};
+
+static const struct itemplate * const itable_ED[] = {
+    instrux + 473,
+    instrux + 474,
+};
+
+static const struct itemplate * const itable_EE[] = {
+    instrux + 730,
+};
+
+static const struct itemplate * const itable_EF[] = {
+    instrux + 731,
+    instrux + 732,
+};
+
+static const struct itemplate * const itable_F1[] = {
+    instrux + 485,
+    instrux + 1051,
+};
+
+static const struct itemplate * const itable_F4[] = {
+    instrux + 436,
+};
+
+static const struct itemplate * const itable_F5[] = {
+    instrux + 182,
+};
+
+static const struct itemplate * const itable_F6[] = {
+    instrux + 241,
+    instrux + 437,
+    instrux + 441,
+    instrux + 679,
+    instrux + 685,
+    instrux + 693,
+    instrux + 1122,
+    instrux + 1126,
+};
+
+static const struct itemplate * const itable_F7[] = {
+    instrux + 242,
+    instrux + 243,
+    instrux + 244,
+    instrux + 438,
+    instrux + 439,
+    instrux + 440,
+    instrux + 442,
+    instrux + 443,
+    instrux + 444,
+    instrux + 680,
+    instrux + 681,
+    instrux + 682,
+    instrux + 686,
+    instrux + 687,
+    instrux + 688,
+    instrux + 694,
+    instrux + 695,
+    instrux + 696,
+    instrux + 1123,
+    instrux + 1124,
+    instrux + 1125,
+    instrux + 1127,
+    instrux + 1128,
+};
+
+static const struct itemplate * const itable_F8[] = {
+    instrux + 178,
+};
+
+static const struct itemplate * const itable_F9[] = {
+    instrux + 1057,
+};
+
+static const struct itemplate * const itable_FA[] = {
+    instrux + 180,
+};
+
+static const struct itemplate * const itable_FB[] = {
+    instrux + 1059,
+};
+
+static const struct itemplate * const itable_FC[] = {
+    instrux + 179,
+};
+
+static const struct itemplate * const itable_FD[] = {
+    instrux + 1058,
+};
+
+static const struct itemplate * const itable_FE[] = {
+    instrux + 237,
+    instrux + 477,
+};
+
+static const struct itemplate * const itable_FF[] = {
+    instrux + 166,
+    instrux + 167,
+    instrux + 168,
+    instrux + 169,
+    instrux + 170,
+    instrux + 171,
+    instrux + 172,
+    instrux + 173,
+    instrux + 174,
+    instrux + 238,
+    instrux + 239,
+    instrux + 240,
+    instrux + 478,
+    instrux + 479,
+    instrux + 480,
+    instrux + 513,
+    instrux + 514,
+    instrux + 515,
+    instrux + 516,
+    instrux + 517,
+    instrux + 518,
+    instrux + 519,
+    instrux + 520,
+    instrux + 521,
+    instrux + 842,
+    instrux + 843,
+    instrux + 844,
+};
+
+static const struct itemplate * const itable_evex01010[] = {
+    instrux + 5183,
+    instrux + 5184,
+    instrux + 5185,
+};
+
+static const struct itemplate * const itable_evex01011[] = {
+    instrux + 5186,
+    instrux + 5187,
+    instrux + 5188,
+    instrux + 5189,
+    instrux + 5190,
+    instrux + 5191,
+};
+
+static const struct itemplate * const itable_evex01012[] = {
+    instrux + 5124,
+    instrux + 5125,
+    instrux + 5137,
+    instrux + 5138,
+};
+
+static const struct itemplate * const itable_evex01013[] = {
+    instrux + 5139,
+};
+
+static const struct itemplate * const itable_evex01014[] = {
+    instrux + 6752,
+    instrux + 6753,
+    instrux + 6754,
+    instrux + 6755,
+    instrux + 6756,
+    instrux + 6757,
+};
+
+static const struct itemplate * const itable_evex01015[] = {
+    instrux + 6740,
+    instrux + 6741,
+    instrux + 6742,
+    instrux + 6743,
+    instrux + 6744,
+    instrux + 6745,
+};
+
+static const struct itemplate * const itable_evex01016[] = {
+    instrux + 5129,
+    instrux + 5130,
+    instrux + 5132,
+    instrux + 5133,
+};
+
+static const struct itemplate * const itable_evex01017[] = {
+    instrux + 5131,
+};
+
+static const struct itemplate * const itable_evex01028[] = {
+    instrux + 5074,
+    instrux + 5075,
+    instrux + 5076,
+};
+
+static const struct itemplate * const itable_evex01029[] = {
+    instrux + 5077,
+    instrux + 5078,
+    instrux + 5079,
+    instrux + 5080,
+    instrux + 5081,
+    instrux + 5082,
+};
+
+static const struct itemplate * const itable_evex0102B[] = {
+    instrux + 5149,
+    instrux + 5150,
+    instrux + 5151,
+};
+
+static const struct itemplate * const itable_evex0102E[] = {
+    instrux + 6733,
+};
+
+static const struct itemplate * const itable_evex0102F[] = {
+    instrux + 4626,
+};
+
+static const struct itemplate * const itable_evex01051[] = {
+    instrux + 6709,
+    instrux + 6710,
+    instrux + 6711,
+};
+
+static const struct itemplate * const itable_evex01054[] = {
+    instrux + 4210,
+    instrux + 4211,
+    instrux + 4212,
+    instrux + 4213,
+    instrux + 4214,
+    instrux + 4215,
+};
+
+static const struct itemplate * const itable_evex01055[] = {
+    instrux + 4198,
+    instrux + 4199,
+    instrux + 4200,
+    instrux + 4201,
+    instrux + 4202,
+    instrux + 4203,
+};
+
+static const struct itemplate * const itable_evex01056[] = {
+    instrux + 5214,
+    instrux + 5215,
+    instrux + 5216,
+    instrux + 5217,
+    instrux + 5218,
+    instrux + 5219,
+};
+
+static const struct itemplate * const itable_evex01057[] = {
+    instrux + 6764,
+    instrux + 6765,
+    instrux + 6766,
+    instrux + 6767,
+    instrux + 6768,
+    instrux + 6769,
+};
+
+static const struct itemplate * const itable_evex01058[] = {
+    instrux + 4170,
+    instrux + 4171,
+    instrux + 4172,
+    instrux + 4173,
+    instrux + 4174,
+    instrux + 4175,
+};
+
+static const struct itemplate * const itable_evex01059[] = {
+    instrux + 5198,
+    instrux + 5199,
+    instrux + 5200,
+    instrux + 5201,
+    instrux + 5202,
+    instrux + 5203,
+};
+
+static const struct itemplate * const itable_evex0105A[] = {
+    instrux + 4666,
+    instrux + 4667,
+    instrux + 4668,
+};
+
+static const struct itemplate * const itable_evex0105B[] = {
+    instrux + 4642,
+    instrux + 4643,
+    instrux + 4644,
+    instrux + 4687,
+    instrux + 4688,
+    instrux + 4689,
+};
+
+static const struct itemplate * const itable_evex0105C[] = {
+    instrux + 6722,
+    instrux + 6723,
+    instrux + 6724,
+    instrux + 6725,
+    instrux + 6726,
+    instrux + 6727,
+};
+
+static const struct itemplate * const itable_evex0105D[] = {
+    instrux + 5055,
+    instrux + 5056,
+    instrux + 5057,
+    instrux + 5058,
+    instrux + 5059,
+    instrux + 5060,
+};
+
+static const struct itemplate * const itable_evex0105E[] = {
+    instrux + 4764,
+    instrux + 4765,
+    instrux + 4766,
+    instrux + 4767,
+    instrux + 4768,
+    instrux + 4769,
+};
+
+static const struct itemplate * const itable_evex0105F[] = {
+    instrux + 5039,
+    instrux + 5040,
+    instrux + 5041,
+    instrux + 5042,
+    instrux + 5043,
+    instrux + 5044,
+};
+
+static const struct itemplate * const itable_evex01078[] = {
+    instrux + 4710,
+    instrux + 4711,
+    instrux + 4712,
+    instrux + 4722,
+    instrux + 4723,
+    instrux + 4724,
+};
+
+static const struct itemplate * const itable_evex01079[] = {
+    instrux + 4654,
+    instrux + 4655,
+    instrux + 4656,
+    instrux + 4678,
+    instrux + 4679,
+    instrux + 4680,
+};
+
+static const struct itemplate * const itable_evex010C2[] = {
+    instrux + 4252,
+    instrux + 4253,
+    instrux + 4254,
+    instrux + 4260,
+    instrux + 4261,
+    instrux + 4262,
+    instrux + 4268,
+    instrux + 4269,
+    instrux + 4270,
+    instrux + 4276,
+    instrux + 4277,
+    instrux + 4278,
+    instrux + 4284,
+    instrux + 4285,
+    instrux + 4286,
+    instrux + 4292,
+    instrux + 4293,
+    instrux + 4294,
+    instrux + 4300,
+    instrux + 4301,
+    instrux + 4302,
+    instrux + 4308,
+    instrux + 4309,
+    instrux + 4310,
+    instrux + 4316,
+    instrux + 4317,
+    instrux + 4318,
+    instrux + 4324,
+    instrux + 4325,
+    instrux + 4326,
+    instrux + 4332,
+    instrux + 4333,
+    instrux + 4334,
+    instrux + 4340,
+    instrux + 4341,
+    instrux + 4342,
+    instrux + 4348,
+    instrux + 4349,
+    instrux + 4350,
+    instrux + 4356,
+    instrux + 4357,
+    instrux + 4358,
+    instrux + 4364,
+    instrux + 4365,
+    instrux + 4366,
+    instrux + 4372,
+    instrux + 4373,
+    instrux + 4374,
+    instrux + 4380,
+    instrux + 4381,
+    instrux + 4382,
+    instrux + 4388,
+    instrux + 4389,
+    instrux + 4390,
+    instrux + 4396,
+    instrux + 4397,
+    instrux + 4398,
+    instrux + 4404,
+    instrux + 4405,
+    instrux + 4406,
+    instrux + 4412,
+    instrux + 4413,
+    instrux + 4414,
+    instrux + 4420,
+    instrux + 4421,
+    instrux + 4422,
+    instrux + 4428,
+    instrux + 4429,
+    instrux + 4430,
+    instrux + 4436,
+    instrux + 4437,
+    instrux + 4438,
+    instrux + 4444,
+    instrux + 4445,
+    instrux + 4446,
+    instrux + 4452,
+    instrux + 4453,
+    instrux + 4454,
+    instrux + 4460,
+    instrux + 4461,
+    instrux + 4462,
+    instrux + 4468,
+    instrux + 4469,
+    instrux + 4470,
+    instrux + 4476,
+    instrux + 4477,
+    instrux + 4478,
+    instrux + 4484,
+    instrux + 4485,
+    instrux + 4486,
+    instrux + 4492,
+    instrux + 4493,
+    instrux + 4494,
+    instrux + 4500,
+    instrux + 4501,
+    instrux + 4502,
+    instrux + 4508,
+    instrux + 4509,
+    instrux + 4510,
+    instrux + 4516,
+    instrux + 4517,
+    instrux + 4518,
+    instrux + 4524,
+    instrux + 4525,
+    instrux + 4526,
+    instrux + 4532,
+    instrux + 4533,
+    instrux + 4534,
+    instrux + 4540,
+    instrux + 4541,
+    instrux + 4542,
+    instrux + 4548,
+    instrux + 4549,
+    instrux + 4550,
+    instrux + 4556,
+    instrux + 4557,
+    instrux + 4558,
+    instrux + 4564,
+    instrux + 4565,
+    instrux + 4566,
+    instrux + 4572,
+    instrux + 4573,
+    instrux + 4574,
+    instrux + 4580,
+    instrux + 4581,
+    instrux + 4582,
+    instrux + 4588,
+    instrux + 4589,
+    instrux + 4590,
+    instrux + 4596,
+    instrux + 4597,
+    instrux + 4598,
+    instrux + 4604,
+    instrux + 4605,
+    instrux + 4606,
+    instrux + 4612,
+    instrux + 4613,
+    instrux + 4614,
+    instrux + 4620,
+    instrux + 4621,
+    instrux + 4622,
+};
+
+static const struct itemplate * const itable_evex010C6[] = {
+    instrux + 6700,
+    instrux + 6701,
+    instrux + 6702,
+    instrux + 6703,
+    instrux + 6704,
+    instrux + 6705,
+};
+
+static const struct itemplate * const itable_evex01110[] = {
+    instrux + 5174,
+    instrux + 5175,
+    instrux + 5176,
+};
+
+static const struct itemplate * const itable_evex01111[] = {
+    instrux + 5177,
+    instrux + 5178,
+    instrux + 5179,
+    instrux + 5180,
+    instrux + 5181,
+    instrux + 5182,
+};
+
+static const struct itemplate * const itable_evex01112[] = {
+    instrux + 5134,
+    instrux + 5135,
+};
+
+static const struct itemplate * const itable_evex01113[] = {
+    instrux + 5136,
+};
+
+static const struct itemplate * const itable_evex01114[] = {
+    instrux + 6746,
+    instrux + 6747,
+    instrux + 6748,
+    instrux + 6749,
+    instrux + 6750,
+    instrux + 6751,
+};
+
+static const struct itemplate * const itable_evex01115[] = {
+    instrux + 6734,
+    instrux + 6735,
+    instrux + 6736,
+    instrux + 6737,
+    instrux + 6738,
+    instrux + 6739,
+};
+
+static const struct itemplate * const itable_evex01116[] = {
+    instrux + 5126,
+    instrux + 5127,
+};
+
+static const struct itemplate * const itable_evex01117[] = {
+    instrux + 5128,
+};
+
+static const struct itemplate * const itable_evex01128[] = {
+    instrux + 5065,
+    instrux + 5066,
+    instrux + 5067,
+};
+
+static const struct itemplate * const itable_evex01129[] = {
+    instrux + 5068,
+    instrux + 5069,
+    instrux + 5070,
+    instrux + 5071,
+    instrux + 5072,
+    instrux + 5073,
+};
+
+static const struct itemplate * const itable_evex0112B[] = {
+    instrux + 5146,
+    instrux + 5147,
+    instrux + 5148,
+};
+
+static const struct itemplate * const itable_evex0112E[] = {
+    instrux + 6732,
+};
+
+static const struct itemplate * const itable_evex0112F[] = {
+    instrux + 4625,
+};
+
+static const struct itemplate * const itable_evex01151[] = {
+    instrux + 6706,
+    instrux + 6707,
+    instrux + 6708,
+};
+
+static const struct itemplate * const itable_evex01154[] = {
+    instrux + 4204,
+    instrux + 4205,
+    instrux + 4206,
+    instrux + 4207,
+    instrux + 4208,
+    instrux + 4209,
+};
+
+static const struct itemplate * const itable_evex01155[] = {
+    instrux + 4192,
+    instrux + 4193,
+    instrux + 4194,
+    instrux + 4195,
+    instrux + 4196,
+    instrux + 4197,
+};
+
+static const struct itemplate * const itable_evex01156[] = {
+    instrux + 5208,
+    instrux + 5209,
+    instrux + 5210,
+    instrux + 5211,
+    instrux + 5212,
+    instrux + 5213,
+};
+
+static const struct itemplate * const itable_evex01157[] = {
+    instrux + 6758,
+    instrux + 6759,
+    instrux + 6760,
+    instrux + 6761,
+    instrux + 6762,
+    instrux + 6763,
+};
+
+static const struct itemplate * const itable_evex01158[] = {
+    instrux + 4164,
+    instrux + 4165,
+    instrux + 4166,
+    instrux + 4167,
+    instrux + 4168,
+    instrux + 4169,
+};
+
+static const struct itemplate * const itable_evex01159[] = {
+    instrux + 5192,
+    instrux + 5193,
+    instrux + 5194,
+    instrux + 5195,
+    instrux + 5196,
+    instrux + 5197,
+};
+
+static const struct itemplate * const itable_evex0115A[] = {
+    instrux + 4648,
+    instrux + 4649,
+    instrux + 4650,
+};
+
+static const struct itemplate * const itable_evex0115B[] = {
+    instrux + 4663,
+    instrux + 4664,
+    instrux + 4665,
+};
+
+static const struct itemplate * const itable_evex0115C[] = {
+    instrux + 6716,
+    instrux + 6717,
+    instrux + 6718,
+    instrux + 6719,
+    instrux + 6720,
+    instrux + 6721,
+};
+
+static const struct itemplate * const itable_evex0115D[] = {
+    instrux + 5049,
+    instrux + 5050,
+    instrux + 5051,
+    instrux + 5052,
+    instrux + 5053,
+    instrux + 5054,
+};
+
+static const struct itemplate * const itable_evex0115E[] = {
+    instrux + 4758,
+    instrux + 4759,
+    instrux + 4760,
+    instrux + 4761,
+    instrux + 4762,
+    instrux + 4763,
+};
+
+static const struct itemplate * const itable_evex0115F[] = {
+    instrux + 5033,
+    instrux + 5034,
+    instrux + 5035,
+    instrux + 5036,
+    instrux + 5037,
+    instrux + 5038,
+};
+
+static const struct itemplate * const itable_evex01160[] = {
+    instrux + 6538,
+    instrux + 6539,
+    instrux + 6540,
+    instrux + 6541,
+    instrux + 6542,
+    instrux + 6543,
+};
+
+static const struct itemplate * const itable_evex01161[] = {
+    instrux + 6556,
+    instrux + 6557,
+    instrux + 6558,
+    instrux + 6559,
+    instrux + 6560,
+    instrux + 6561,
+};
+
+static const struct itemplate * const itable_evex01162[] = {
+    instrux + 6544,
+    instrux + 6545,
+    instrux + 6546,
+    instrux + 6547,
+    instrux + 6548,
+    instrux + 6549,
+};
+
+static const struct itemplate * const itable_evex01163[] = {
+    instrux + 5238,
+    instrux + 5239,
+    instrux + 5240,
+    instrux + 5241,
+    instrux + 5242,
+    instrux + 5243,
+};
+
+static const struct itemplate * const itable_evex01164[] = {
+    instrux + 5421,
+    instrux + 5422,
+    instrux + 5423,
+};
+
+static const struct itemplate * const itable_evex01165[] = {
+    instrux + 5430,
+    instrux + 5431,
+    instrux + 5432,
+};
+
+static const struct itemplate * const itable_evex01166[] = {
+    instrux + 5424,
+    instrux + 5425,
+    instrux + 5426,
+};
+
+static const struct itemplate * const itable_evex01167[] = {
+    instrux + 5250,
+    instrux + 5251,
+    instrux + 5252,
+    instrux + 5253,
+    instrux + 5254,
+    instrux + 5255,
+};
+
+static const struct itemplate * const itable_evex01168[] = {
+    instrux + 6514,
+    instrux + 6515,
+    instrux + 6516,
+    instrux + 6517,
+    instrux + 6518,
+    instrux + 6519,
+};
+
+static const struct itemplate * const itable_evex01169[] = {
+    instrux + 6532,
+    instrux + 6533,
+    instrux + 6534,
+    instrux + 6535,
+    instrux + 6536,
+    instrux + 6537,
+};
+
+static const struct itemplate * const itable_evex0116A[] = {
+    instrux + 6520,
+    instrux + 6521,
+    instrux + 6522,
+    instrux + 6523,
+    instrux + 6524,
+    instrux + 6525,
+};
+
+static const struct itemplate * const itable_evex0116B[] = {
+    instrux + 5232,
+    instrux + 5233,
+    instrux + 5234,
+    instrux + 5235,
+    instrux + 5236,
+    instrux + 5237,
+};
+
+static const struct itemplate * const itable_evex0116C[] = {
+    instrux + 6550,
+    instrux + 6551,
+    instrux + 6552,
+    instrux + 6553,
+    instrux + 6554,
+    instrux + 6555,
+};
+
+static const struct itemplate * const itable_evex0116D[] = {
+    instrux + 6526,
+    instrux + 6527,
+    instrux + 6528,
+    instrux + 6529,
+    instrux + 6530,
+    instrux + 6531,
+};
+
+static const struct itemplate * const itable_evex0116E[] = {
+    instrux + 5083,
+    instrux + 5152,
+};
+
+static const struct itemplate * const itable_evex0116F[] = {
+    instrux + 5088,
+    instrux + 5089,
+    instrux + 5090,
+    instrux + 5094,
+    instrux + 5095,
+    instrux + 5096,
+};
+
+static const struct itemplate * const itable_evex01170[] = {
+    instrux + 6253,
+    instrux + 6254,
+    instrux + 6255,
+};
+
+static const struct itemplate * const itable_evex01171[] = {
+    instrux + 6316,
+    instrux + 6317,
+    instrux + 6318,
+    instrux + 6319,
+    instrux + 6320,
+    instrux + 6321,
+    instrux + 6370,
+    instrux + 6371,
+    instrux + 6372,
+    instrux + 6373,
+    instrux + 6374,
+    instrux + 6375,
+    instrux + 6430,
+    instrux + 6431,
+    instrux + 6432,
+    instrux + 6433,
+    instrux + 6434,
+    instrux + 6435,
+};
+
+static const struct itemplate * const itable_evex01172[] = {
+    instrux + 6181,
+    instrux + 6182,
+    instrux + 6183,
+    instrux + 6184,
+    instrux + 6185,
+    instrux + 6186,
+    instrux + 6187,
+    instrux + 6188,
+    instrux + 6189,
+    instrux + 6190,
+    instrux + 6191,
+    instrux + 6192,
+    instrux + 6205,
+    instrux + 6206,
+    instrux + 6207,
+    instrux + 6208,
+    instrux + 6209,
+    instrux + 6210,
+    instrux + 6211,
+    instrux + 6212,
+    instrux + 6213,
+    instrux + 6214,
+    instrux + 6215,
+    instrux + 6216,
+    instrux + 6268,
+    instrux + 6269,
+    instrux + 6270,
+    instrux + 6271,
+    instrux + 6272,
+    instrux + 6273,
+    instrux + 6328,
+    instrux + 6329,
+    instrux + 6330,
+    instrux + 6331,
+    instrux + 6332,
+    instrux + 6333,
+    instrux + 6340,
+    instrux + 6341,
+    instrux + 6342,
+    instrux + 6343,
+    instrux + 6344,
+    instrux + 6345,
+    instrux + 6382,
+    instrux + 6383,
+    instrux + 6384,
+    instrux + 6385,
+    instrux + 6386,
+    instrux + 6387,
+};
+
+static const struct itemplate * const itable_evex01173[] = {
+    instrux + 6274,
+    instrux + 6275,
+    instrux + 6276,
+    instrux + 6277,
+    instrux + 6278,
+    instrux + 6279,
+    instrux + 6286,
+    instrux + 6287,
+    instrux + 6288,
+    instrux + 6289,
+    instrux + 6290,
+    instrux + 6291,
+    instrux + 6388,
+    instrux + 6389,
+    instrux + 6390,
+    instrux + 6391,
+    instrux + 6392,
+    instrux + 6393,
+    instrux + 6400,
+    instrux + 6401,
+    instrux + 6402,
+    instrux + 6403,
+    instrux + 6404,
+    instrux + 6405,
+};
+
+static const struct itemplate * const itable_evex01174[] = {
+    instrux + 5409,
+    instrux + 5410,
+    instrux + 5411,
+};
+
+static const struct itemplate * const itable_evex01175[] = {
+    instrux + 5418,
+    instrux + 5419,
+    instrux + 5420,
+};
+
+static const struct itemplate * const itable_evex01176[] = {
+    instrux + 5412,
+    instrux + 5413,
+    instrux + 5414,
+};
+
+static const struct itemplate * const itable_evex01178[] = {
+    instrux + 4713,
+    instrux + 4714,
+    instrux + 4715,
+    instrux + 4725,
+    instrux + 4726,
+    instrux + 4727,
+};
+
+static const struct itemplate * const itable_evex01179[] = {
+    instrux + 4657,
+    instrux + 4658,
+    instrux + 4659,
+    instrux + 4681,
+    instrux + 4682,
+    instrux + 4683,
+};
+
+static const struct itemplate * const itable_evex0117A[] = {
+    instrux + 4707,
+    instrux + 4708,
+    instrux + 4709,
+    instrux + 4719,
+    instrux + 4720,
+    instrux + 4721,
+};
+
+static const struct itemplate * const itable_evex0117B[] = {
+    instrux + 4651,
+    instrux + 4652,
+    instrux + 4653,
+    instrux + 4675,
+    instrux + 4676,
+    instrux + 4677,
+};
+
+static const struct itemplate * const itable_evex0117E[] = {
+    instrux + 5084,
+    instrux + 5153,
+};
+
+static const struct itemplate * const itable_evex0117F[] = {
+    instrux + 5091,
+    instrux + 5092,
+    instrux + 5093,
+    instrux + 5097,
+    instrux + 5098,
+    instrux + 5099,
+};
+
+static const struct itemplate * const itable_evex011C2[] = {
+    instrux + 4249,
+    instrux + 4250,
+    instrux + 4251,
+    instrux + 4257,
+    instrux + 4258,
+    instrux + 4259,
+    instrux + 4265,
+    instrux + 4266,
+    instrux + 4267,
+    instrux + 4273,
+    instrux + 4274,
+    instrux + 4275,
+    instrux + 4281,
+    instrux + 4282,
+    instrux + 4283,
+    instrux + 4289,
+    instrux + 4290,
+    instrux + 4291,
+    instrux + 4297,
+    instrux + 4298,
+    instrux + 4299,
+    instrux + 4305,
+    instrux + 4306,
+    instrux + 4307,
+    instrux + 4313,
+    instrux + 4314,
+    instrux + 4315,
+    instrux + 4321,
+    instrux + 4322,
+    instrux + 4323,
+    instrux + 4329,
+    instrux + 4330,
+    instrux + 4331,
+    instrux + 4337,
+    instrux + 4338,
+    instrux + 4339,
+    instrux + 4345,
+    instrux + 4346,
+    instrux + 4347,
+    instrux + 4353,
+    instrux + 4354,
+    instrux + 4355,
+    instrux + 4361,
+    instrux + 4362,
+    instrux + 4363,
+    instrux + 4369,
+    instrux + 4370,
+    instrux + 4371,
+    instrux + 4377,
+    instrux + 4378,
+    instrux + 4379,
+    instrux + 4385,
+    instrux + 4386,
+    instrux + 4387,
+    instrux + 4393,
+    instrux + 4394,
+    instrux + 4395,
+    instrux + 4401,
+    instrux + 4402,
+    instrux + 4403,
+    instrux + 4409,
+    instrux + 4410,
+    instrux + 4411,
+    instrux + 4417,
+    instrux + 4418,
+    instrux + 4419,
+    instrux + 4425,
+    instrux + 4426,
+    instrux + 4427,
+    instrux + 4433,
+    instrux + 4434,
+    instrux + 4435,
+    instrux + 4441,
+    instrux + 4442,
+    instrux + 4443,
+    instrux + 4449,
+    instrux + 4450,
+    instrux + 4451,
+    instrux + 4457,
+    instrux + 4458,
+    instrux + 4459,
+    instrux + 4465,
+    instrux + 4466,
+    instrux + 4467,
+    instrux + 4473,
+    instrux + 4474,
+    instrux + 4475,
+    instrux + 4481,
+    instrux + 4482,
+    instrux + 4483,
+    instrux + 4489,
+    instrux + 4490,
+    instrux + 4491,
+    instrux + 4497,
+    instrux + 4498,
+    instrux + 4499,
+    instrux + 4505,
+    instrux + 4506,
+    instrux + 4507,
+    instrux + 4513,
+    instrux + 4514,
+    instrux + 4515,
+    instrux + 4521,
+    instrux + 4522,
+    instrux + 4523,
+    instrux + 4529,
+    instrux + 4530,
+    instrux + 4531,
+    instrux + 4537,
+    instrux + 4538,
+    instrux + 4539,
+    instrux + 4545,
+    instrux + 4546,
+    instrux + 4547,
+    instrux + 4553,
+    instrux + 4554,
+    instrux + 4555,
+    instrux + 4561,
+    instrux + 4562,
+    instrux + 4563,
+    instrux + 4569,
+    instrux + 4570,
+    instrux + 4571,
+    instrux + 4577,
+    instrux + 4578,
+    instrux + 4579,
+    instrux + 4585,
+    instrux + 4586,
+    instrux + 4587,
+    instrux + 4593,
+    instrux + 4594,
+    instrux + 4595,
+    instrux + 4601,
+    instrux + 4602,
+    instrux + 4603,
+    instrux + 4609,
+    instrux + 4610,
+    instrux + 4611,
+    instrux + 4617,
+    instrux + 4618,
+    instrux + 4619,
+};
+
+static const struct itemplate * const itable_evex011C4[] = {
+    instrux + 5823,
+    instrux + 5824,
+    instrux + 5825,
+    instrux + 5826,
+};
+
+static const struct itemplate * const itable_evex011C5[] = {
+    instrux + 5800,
+    instrux + 5801,
+    instrux + 5802,
+};
+
+static const struct itemplate * const itable_evex011C6[] = {
+    instrux + 6694,
+    instrux + 6695,
+    instrux + 6696,
+    instrux + 6697,
+    instrux + 6698,
+    instrux + 6699,
+};
+
+static const struct itemplate * const itable_evex011D1[] = {
+    instrux + 6424,
+    instrux + 6425,
+    instrux + 6426,
+    instrux + 6427,
+    instrux + 6428,
+    instrux + 6429,
+};
+
+static const struct itemplate * const itable_evex011D2[] = {
+    instrux + 6376,
+    instrux + 6377,
+    instrux + 6378,
+    instrux + 6379,
+    instrux + 6380,
+    instrux + 6381,
+};
+
+static const struct itemplate * const itable_evex011D3[] = {
+    instrux + 6394,
+    instrux + 6395,
+    instrux + 6396,
+    instrux + 6397,
+    instrux + 6398,
+    instrux + 6399,
+};
+
+static const struct itemplate * const itable_evex011D4[] = {
+    instrux + 5268,
+    instrux + 5269,
+    instrux + 5270,
+    instrux + 5271,
+    instrux + 5272,
+    instrux + 5273,
+};
+
+static const struct itemplate * const itable_evex011D5[] = {
+    instrux + 6151,
+    instrux + 6152,
+    instrux + 6153,
+    instrux + 6154,
+    instrux + 6155,
+    instrux + 6156,
+};
+
+static const struct itemplate * const itable_evex011D6[] = {
+    instrux + 5155,
+};
+
+static const struct itemplate * const itable_evex011D8[] = {
+    instrux + 6466,
+    instrux + 6467,
+    instrux + 6468,
+    instrux + 6469,
+    instrux + 6470,
+    instrux + 6471,
+};
+
+static const struct itemplate * const itable_evex011D9[] = {
+    instrux + 6472,
+    instrux + 6473,
+    instrux + 6474,
+    instrux + 6475,
+    instrux + 6476,
+    instrux + 6477,
+};
+
+static const struct itemplate * const itable_evex011DA[] = {
+    instrux + 5923,
+    instrux + 5924,
+    instrux + 5925,
+    instrux + 5926,
+    instrux + 5927,
+    instrux + 5928,
+};
+
+static const struct itemplate * const itable_evex011DB[] = {
+    instrux + 5310,
+    instrux + 5311,
+    instrux + 5312,
+    instrux + 5313,
+    instrux + 5314,
+    instrux + 5315,
+    instrux + 5328,
+    instrux + 5329,
+    instrux + 5330,
+    instrux + 5331,
+    instrux + 5332,
+    instrux + 5333,
+};
+
+static const struct itemplate * const itable_evex011DC[] = {
+    instrux + 5286,
+    instrux + 5287,
+    instrux + 5288,
+    instrux + 5289,
+    instrux + 5290,
+    instrux + 5291,
+};
+
+static const struct itemplate * const itable_evex011DD[] = {
+    instrux + 5292,
+    instrux + 5293,
+    instrux + 5294,
+    instrux + 5295,
+    instrux + 5296,
+    instrux + 5297,
+};
+
+static const struct itemplate * const itable_evex011DE[] = {
+    instrux + 5875,
+    instrux + 5876,
+    instrux + 5877,
+    instrux + 5878,
+    instrux + 5879,
+    instrux + 5880,
+};
+
+static const struct itemplate * const itable_evex011DF[] = {
+    instrux + 5316,
+    instrux + 5317,
+    instrux + 5318,
+    instrux + 5319,
+    instrux + 5320,
+    instrux + 5321,
+    instrux + 5322,
+    instrux + 5323,
+    instrux + 5324,
+    instrux + 5325,
+    instrux + 5326,
+    instrux + 5327,
+};
+
+static const struct itemplate * const itable_evex011E0[] = {
+    instrux + 5334,
+    instrux + 5335,
+    instrux + 5336,
+    instrux + 5337,
+    instrux + 5338,
+    instrux + 5339,
+};
+
+static const struct itemplate * const itable_evex011E1[] = {
+    instrux + 6364,
+    instrux + 6365,
+    instrux + 6366,
+    instrux + 6367,
+    instrux + 6368,
+    instrux + 6369,
+};
+
+static const struct itemplate * const itable_evex011E2[] = {
+    instrux + 6322,
+    instrux + 6323,
+    instrux + 6324,
+    instrux + 6325,
+    instrux + 6326,
+    instrux + 6327,
+    instrux + 6334,
+    instrux + 6335,
+    instrux + 6336,
+    instrux + 6337,
+    instrux + 6338,
+    instrux + 6339,
+};
+
+static const struct itemplate * const itable_evex011E3[] = {
+    instrux + 5340,
+    instrux + 5341,
+    instrux + 5342,
+    instrux + 5343,
+    instrux + 5344,
+    instrux + 5345,
+};
+
+static const struct itemplate * const itable_evex011E4[] = {
+    instrux + 6127,
+    instrux + 6128,
+    instrux + 6129,
+    instrux + 6130,
+    instrux + 6131,
+    instrux + 6132,
+};
+
+static const struct itemplate * const itable_evex011E5[] = {
+    instrux + 6133,
+    instrux + 6134,
+    instrux + 6135,
+    instrux + 6136,
+    instrux + 6137,
+    instrux + 6138,
+};
+
+static const struct itemplate * const itable_evex011E6[] = {
+    instrux + 4704,
+    instrux + 4705,
+    instrux + 4706,
+};
+
+static const struct itemplate * const itable_evex011E7[] = {
+    instrux + 5140,
+    instrux + 5141,
+    instrux + 5142,
+};
+
+static const struct itemplate * const itable_evex011E8[] = {
+    instrux + 6454,
+    instrux + 6455,
+    instrux + 6456,
+    instrux + 6457,
+    instrux + 6458,
+    instrux + 6459,
+};
+
+static const struct itemplate * const itable_evex011E9[] = {
+    instrux + 6460,
+    instrux + 6461,
+    instrux + 6462,
+    instrux + 6463,
+    instrux + 6464,
+    instrux + 6465,
+};
+
+static const struct itemplate * const itable_evex011EA[] = {
+    instrux + 5917,
+    instrux + 5918,
+    instrux + 5919,
+    instrux + 5920,
+    instrux + 5921,
+    instrux + 5922,
+};
+
+static const struct itemplate * const itable_evex011EB[] = {
+    instrux + 6169,
+    instrux + 6170,
+    instrux + 6171,
+    instrux + 6172,
+    instrux + 6173,
+    instrux + 6174,
+    instrux + 6175,
+    instrux + 6176,
+    instrux + 6177,
+    instrux + 6178,
+    instrux + 6179,
+    instrux + 6180,
+};
+
+static const struct itemplate * const itable_evex011EC[] = {
+    instrux + 5274,
+    instrux + 5275,
+    instrux + 5276,
+    instrux + 5277,
+    instrux + 5278,
+    instrux + 5279,
+};
+
+static const struct itemplate * const itable_evex011ED[] = {
+    instrux + 5280,
+    instrux + 5281,
+    instrux + 5282,
+    instrux + 5283,
+    instrux + 5284,
+    instrux + 5285,
+};
+
+static const struct itemplate * const itable_evex011EE[] = {
+    instrux + 5869,
+    instrux + 5870,
+    instrux + 5871,
+    instrux + 5872,
+    instrux + 5873,
+    instrux + 5874,
+};
+
+static const struct itemplate * const itable_evex011EF[] = {
+    instrux + 6562,
+    instrux + 6563,
+    instrux + 6564,
+    instrux + 6565,
+    instrux + 6566,
+    instrux + 6567,
+    instrux + 6568,
+    instrux + 6569,
+    instrux + 6570,
+    instrux + 6571,
+    instrux + 6572,
+    instrux + 6573,
+};
+
+static const struct itemplate * const itable_evex011F1[] = {
+    instrux + 6310,
+    instrux + 6311,
+    instrux + 6312,
+    instrux + 6313,
+    instrux + 6314,
+    instrux + 6315,
+};
+
+static const struct itemplate * const itable_evex011F2[] = {
+    instrux + 6262,
+    instrux + 6263,
+    instrux + 6264,
+    instrux + 6265,
+    instrux + 6266,
+    instrux + 6267,
+};
+
+static const struct itemplate * const itable_evex011F3[] = {
+    instrux + 6280,
+    instrux + 6281,
+    instrux + 6282,
+    instrux + 6283,
+    instrux + 6284,
+    instrux + 6285,
+};
+
+static const struct itemplate * const itable_evex011F4[] = {
+    instrux + 6163,
+    instrux + 6164,
+    instrux + 6165,
+    instrux + 6166,
+    instrux + 6167,
+    instrux + 6168,
+};
+
+static const struct itemplate * const itable_evex011F5[] = {
+    instrux + 5845,
+    instrux + 5846,
+    instrux + 5847,
+    instrux + 5848,
+    instrux + 5849,
+    instrux + 5850,
+};
+
+static const struct itemplate * const itable_evex011F6[] = {
+    instrux + 6229,
+    instrux + 6230,
+    instrux + 6231,
+    instrux + 6232,
+    instrux + 6233,
+    instrux + 6234,
+};
+
+static const struct itemplate * const itable_evex011F8[] = {
+    instrux + 6436,
+    instrux + 6437,
+    instrux + 6438,
+    instrux + 6439,
+    instrux + 6440,
+    instrux + 6441,
+};
+
+static const struct itemplate * const itable_evex011F9[] = {
+    instrux + 6478,
+    instrux + 6479,
+    instrux + 6480,
+    instrux + 6481,
+    instrux + 6482,
+    instrux + 6483,
+};
+
+static const struct itemplate * const itable_evex011FA[] = {
+    instrux + 6442,
+    instrux + 6443,
+    instrux + 6444,
+    instrux + 6445,
+    instrux + 6446,
+    instrux + 6447,
+};
+
+static const struct itemplate * const itable_evex011FB[] = {
+    instrux + 6448,
+    instrux + 6449,
+    instrux + 6450,
+    instrux + 6451,
+    instrux + 6452,
+    instrux + 6453,
+};
+
+static const struct itemplate * const itable_evex011FC[] = {
+    instrux + 5256,
+    instrux + 5257,
+    instrux + 5258,
+    instrux + 5259,
+    instrux + 5260,
+    instrux + 5261,
+};
+
+static const struct itemplate * const itable_evex011FD[] = {
+    instrux + 5298,
+    instrux + 5299,
+    instrux + 5300,
+    instrux + 5301,
+    instrux + 5302,
+    instrux + 5303,
+};
+
+static const struct itemplate * const itable_evex011FE[] = {
+    instrux + 5262,
+    instrux + 5263,
+    instrux + 5264,
+    instrux + 5265,
+    instrux + 5266,
+    instrux + 5267,
+};
+
+static const struct itemplate * const itable_evex01210[] = {
+    instrux + 5168,
+    instrux + 5170,
+    instrux + 5171,
+};
+
+static const struct itemplate * const itable_evex01211[] = {
+    instrux + 5169,
+    instrux + 5172,
+    instrux + 5173,
+};
+
+static const struct itemplate * const itable_evex01212[] = {
+    instrux + 5165,
+    instrux + 5166,
+    instrux + 5167,
+};
+
+static const struct itemplate * const itable_evex01216[] = {
+    instrux + 5162,
+    instrux + 5163,
+    instrux + 5164,
+};
+
+static const struct itemplate * const itable_evex0122A[] = {
+    instrux + 4697,
+    instrux + 4698,
+};
+
+static const struct itemplate * const itable_evex0122C[] = {
+    instrux + 4732,
+    instrux + 4733,
+};
+
+static const struct itemplate * const itable_evex0122D[] = {
+    instrux + 4700,
+    instrux + 4701,
+};
+
+static const struct itemplate * const itable_evex01251[] = {
+    instrux + 6714,
+    instrux + 6715,
+};
+
+static const struct itemplate * const itable_evex01258[] = {
+    instrux + 4178,
+    instrux + 4179,
+};
+
+static const struct itemplate * const itable_evex01259[] = {
+    instrux + 5206,
+    instrux + 5207,
+};
+
+static const struct itemplate * const itable_evex0125A[] = {
+    instrux + 4699,
+};
+
+static const struct itemplate * const itable_evex0125B[] = {
+    instrux + 4716,
+    instrux + 4717,
+    instrux + 4718,
+};
+
+static const struct itemplate * const itable_evex0125C[] = {
+    instrux + 6730,
+    instrux + 6731,
+};
+
+static const struct itemplate * const itable_evex0125D[] = {
+    instrux + 5063,
+    instrux + 5064,
+};
+
+static const struct itemplate * const itable_evex0125E[] = {
+    instrux + 4772,
+    instrux + 4773,
+};
+
+static const struct itemplate * const itable_evex0125F[] = {
+    instrux + 5047,
+    instrux + 5048,
+};
+
+static const struct itemplate * const itable_evex0126F[] = {
+    instrux + 5106,
+    instrux + 5107,
+    instrux + 5108,
+    instrux + 5112,
+    instrux + 5113,
+    instrux + 5114,
+};
+
+static const struct itemplate * const itable_evex01270[] = {
+    instrux + 6256,
+    instrux + 6257,
+    instrux + 6258,
+};
+
+static const struct itemplate * const itable_evex01278[] = {
+    instrux + 4734,
+    instrux + 4735,
+};
+
+static const struct itemplate * const itable_evex01279[] = {
+    instrux + 4702,
+    instrux + 4703,
+};
+
+static const struct itemplate * const itable_evex0127A[] = {
+    instrux + 4736,
+    instrux + 4737,
+    instrux + 4738,
+    instrux + 4742,
+    instrux + 4743,
+    instrux + 4744,
+};
+
+static const struct itemplate * const itable_evex0127B[] = {
+    instrux + 4750,
+    instrux + 4751,
+};
+
+static const struct itemplate * const itable_evex0127E[] = {
+    instrux + 5154,
+};
+
+static const struct itemplate * const itable_evex0127F[] = {
+    instrux + 5109,
+    instrux + 5110,
+    instrux + 5111,
+    instrux + 5115,
+    instrux + 5116,
+    instrux + 5117,
+};
+
+static const struct itemplate * const itable_evex012C2[] = {
+    instrux + 4256,
+    instrux + 4264,
+    instrux + 4272,
+    instrux + 4280,
+    instrux + 4288,
+    instrux + 4296,
+    instrux + 4304,
+    instrux + 4312,
+    instrux + 4320,
+    instrux + 4328,
+    instrux + 4336,
+    instrux + 4344,
+    instrux + 4352,
+    instrux + 4360,
+    instrux + 4368,
+    instrux + 4376,
+    instrux + 4384,
+    instrux + 4392,
+    instrux + 4400,
+    instrux + 4408,
+    instrux + 4416,
+    instrux + 4424,
+    instrux + 4432,
+    instrux + 4440,
+    instrux + 4448,
+    instrux + 4456,
+    instrux + 4464,
+    instrux + 4472,
+    instrux + 4480,
+    instrux + 4488,
+    instrux + 4496,
+    instrux + 4504,
+    instrux + 4512,
+    instrux + 4520,
+    instrux + 4528,
+    instrux + 4536,
+    instrux + 4544,
+    instrux + 4552,
+    instrux + 4560,
+    instrux + 4568,
+    instrux + 4576,
+    instrux + 4584,
+    instrux + 4592,
+    instrux + 4600,
+    instrux + 4608,
+    instrux + 4616,
+    instrux + 4624,
+};
+
+static const struct itemplate * const itable_evex012E6[] = {
+    instrux + 4639,
+    instrux + 4640,
+    instrux + 4641,
+    instrux + 4684,
+    instrux + 4685,
+    instrux + 4686,
+};
+
+static const struct itemplate * const itable_evex01310[] = {
+    instrux + 5156,
+    instrux + 5158,
+    instrux + 5159,
+};
+
+static const struct itemplate * const itable_evex01311[] = {
+    instrux + 5157,
+    instrux + 5160,
+    instrux + 5161,
+};
+
+static const struct itemplate * const itable_evex01312[] = {
+    instrux + 5085,
+    instrux + 5086,
+    instrux + 5087,
+};
+
+static const struct itemplate * const itable_evex0132A[] = {
+    instrux + 4695,
+    instrux + 4696,
+};
+
+static const struct itemplate * const itable_evex0132C[] = {
+    instrux + 4728,
+    instrux + 4729,
+};
+
+static const struct itemplate * const itable_evex0132D[] = {
+    instrux + 4690,
+    instrux + 4691,
+};
+
+static const struct itemplate * const itable_evex01351[] = {
+    instrux + 6712,
+    instrux + 6713,
+};
+
+static const struct itemplate * const itable_evex01358[] = {
+    instrux + 4176,
+    instrux + 4177,
+};
+
+static const struct itemplate * const itable_evex01359[] = {
+    instrux + 5204,
+    instrux + 5205,
+};
+
+static const struct itemplate * const itable_evex0135A[] = {
+    instrux + 4692,
+};
+
+static const struct itemplate * const itable_evex0135C[] = {
+    instrux + 6728,
+    instrux + 6729,
+};
+
+static const struct itemplate * const itable_evex0135D[] = {
+    instrux + 5061,
+    instrux + 5062,
+};
+
+static const struct itemplate * const itable_evex0135E[] = {
+    instrux + 4770,
+    instrux + 4771,
+};
+
+static const struct itemplate * const itable_evex0135F[] = {
+    instrux + 5045,
+    instrux + 5046,
+};
+
+static const struct itemplate * const itable_evex0136F[] = {
+    instrux + 5100,
+    instrux + 5101,
+    instrux + 5102,
+    instrux + 5118,
+    instrux + 5119,
+    instrux + 5120,
+};
+
+static const struct itemplate * const itable_evex01370[] = {
+    instrux + 6259,
+    instrux + 6260,
+    instrux + 6261,
+};
+
+static const struct itemplate * const itable_evex01378[] = {
+    instrux + 4730,
+    instrux + 4731,
+};
+
+static const struct itemplate * const itable_evex01379[] = {
+    instrux + 4693,
+    instrux + 4694,
+};
+
+static const struct itemplate * const itable_evex0137A[] = {
+    instrux + 4739,
+    instrux + 4740,
+    instrux + 4741,
+    instrux + 4745,
+    instrux + 4746,
+    instrux + 4747,
+};
+
+static const struct itemplate * const itable_evex0137B[] = {
+    instrux + 4748,
+    instrux + 4749,
+};
+
+static const struct itemplate * const itable_evex0137F[] = {
+    instrux + 5103,
+    instrux + 5104,
+    instrux + 5105,
+    instrux + 5121,
+    instrux + 5122,
+    instrux + 5123,
+};
+
+static const struct itemplate * const itable_evex013C2[] = {
+    instrux + 4255,
+    instrux + 4263,
+    instrux + 4271,
+    instrux + 4279,
+    instrux + 4287,
+    instrux + 4295,
+    instrux + 4303,
+    instrux + 4311,
+    instrux + 4319,
+    instrux + 4327,
+    instrux + 4335,
+    instrux + 4343,
+    instrux + 4351,
+    instrux + 4359,
+    instrux + 4367,
+    instrux + 4375,
+    instrux + 4383,
+    instrux + 4391,
+    instrux + 4399,
+    instrux + 4407,
+    instrux + 4415,
+    instrux + 4423,
+    instrux + 4431,
+    instrux + 4439,
+    instrux + 4447,
+    instrux + 4455,
+    instrux + 4463,
+    instrux + 4471,
+    instrux + 4479,
+    instrux + 4487,
+    instrux + 4495,
+    instrux + 4503,
+    instrux + 4511,
+    instrux + 4519,
+    instrux + 4527,
+    instrux + 4535,
+    instrux + 4543,
+    instrux + 4551,
+    instrux + 4559,
+    instrux + 4567,
+    instrux + 4575,
+    instrux + 4583,
+    instrux + 4591,
+    instrux + 4599,
+    instrux + 4607,
+    instrux + 4615,
+    instrux + 4623,
+};
+
+static const struct itemplate * const itable_evex013E6[] = {
+    instrux + 4645,
+    instrux + 4646,
+    instrux + 4647,
+};
+
+static const struct itemplate * const itable_evex02100[] = {
+    instrux + 6247,
+    instrux + 6248,
+    instrux + 6249,
+    instrux + 6250,
+    instrux + 6251,
+    instrux + 6252,
+};
+
+static const struct itemplate * const itable_evex02104[] = {
+    instrux + 5839,
+    instrux + 5840,
+    instrux + 5841,
+    instrux + 5842,
+    instrux + 5843,
+    instrux + 5844,
+};
+
+static const struct itemplate * const itable_evex0210B[] = {
+    instrux + 6121,
+    instrux + 6122,
+    instrux + 6123,
+    instrux + 6124,
+    instrux + 6125,
+    instrux + 6126,
+};
+
+static const struct itemplate * const itable_evex0210C[] = {
+    instrux + 5731,
+    instrux + 5732,
+    instrux + 5733,
+    instrux + 5734,
+    instrux + 5735,
+    instrux + 5736,
+};
+
+static const struct itemplate * const itable_evex0210D[] = {
+    instrux + 5722,
+    instrux + 5723,
+    instrux + 5724,
+    instrux + 5725,
+    instrux + 5726,
+    instrux + 5727,
+};
+
+static const struct itemplate * const itable_evex02110[] = {
+    instrux + 6418,
+    instrux + 6419,
+    instrux + 6420,
+    instrux + 6421,
+    instrux + 6422,
+    instrux + 6423,
+};
+
+static const struct itemplate * const itable_evex02111[] = {
+    instrux + 6358,
+    instrux + 6359,
+    instrux + 6360,
+    instrux + 6361,
+    instrux + 6362,
+    instrux + 6363,
+};
+
+static const struct itemplate * const itable_evex02112[] = {
+    instrux + 6304,
+    instrux + 6305,
+    instrux + 6306,
+    instrux + 6307,
+    instrux + 6308,
+    instrux + 6309,
+};
+
+static const struct itemplate * const itable_evex02113[] = {
+    instrux + 4660,
+    instrux + 4661,
+    instrux + 4662,
+    instrux + 7054,
+    instrux + 7055,
+    instrux + 7056,
+};
+
+static const struct itemplate * const itable_evex02114[] = {
+    instrux + 6217,
+    instrux + 6218,
+    instrux + 6219,
+    instrux + 6220,
+    instrux + 6221,
+    instrux + 6222,
+    instrux + 6223,
+    instrux + 6224,
+    instrux + 6225,
+    instrux + 6226,
+    instrux + 6227,
+    instrux + 6228,
+};
+
+static const struct itemplate * const itable_evex02115[] = {
+    instrux + 6193,
+    instrux + 6194,
+    instrux + 6195,
+    instrux + 6196,
+    instrux + 6197,
+    instrux + 6198,
+    instrux + 6199,
+    instrux + 6200,
+    instrux + 6201,
+    instrux + 6202,
+    instrux + 6203,
+    instrux + 6204,
+};
+
+static const struct itemplate * const itable_evex02116[] = {
+    instrux + 5739,
+    instrux + 5740,
+    instrux + 5741,
+    instrux + 5742,
+    instrux + 5743,
+    instrux + 5744,
+    instrux + 5745,
+    instrux + 5746,
+};
+
+static const struct itemplate * const itable_evex02118[] = {
+    instrux + 4243,
+    instrux + 4244,
+    instrux + 4245,
+    instrux + 4246,
+    instrux + 4247,
+    instrux + 4248,
+};
+
+static const struct itemplate * const itable_evex02119[] = {
+    instrux + 4222,
+    instrux + 4223,
+    instrux + 4239,
+    instrux + 4240,
+    instrux + 4241,
+    instrux + 4242,
+};
+
+static const struct itemplate * const itable_evex0211A[] = {
+    instrux + 4224,
+    instrux + 4225,
+    instrux + 4227,
+    instrux + 4228,
+};
+
+static const struct itemplate * const itable_evex0211B[] = {
+    instrux + 4226,
+    instrux + 4229,
+};
+
+static const struct itemplate * const itable_evex0211C[] = {
+    instrux + 5220,
+    instrux + 5221,
+    instrux + 5222,
+};
+
+static const struct itemplate * const itable_evex0211D[] = {
+    instrux + 5229,
+    instrux + 5230,
+    instrux + 5231,
+};
+
+static const struct itemplate * const itable_evex0211E[] = {
+    instrux + 5223,
+    instrux + 5224,
+    instrux + 5225,
+};
+
+static const struct itemplate * const itable_evex0211F[] = {
+    instrux + 5226,
+    instrux + 5227,
+    instrux + 5228,
+};
+
+static const struct itemplate * const itable_evex02120[] = {
+    instrux + 6040,
+    instrux + 6041,
+    instrux + 6042,
+};
+
+static const struct itemplate * const itable_evex02121[] = {
+    instrux + 6034,
+    instrux + 6035,
+    instrux + 6036,
+};
+
+static const struct itemplate * const itable_evex02122[] = {
+    instrux + 6037,
+    instrux + 6038,
+    instrux + 6039,
+};
+
+static const struct itemplate * const itable_evex02123[] = {
+    instrux + 6046,
+    instrux + 6047,
+    instrux + 6048,
+};
+
+static const struct itemplate * const itable_evex02124[] = {
+    instrux + 6049,
+    instrux + 6050,
+    instrux + 6051,
+};
+
+static const struct itemplate * const itable_evex02125[] = {
+    instrux + 6043,
+    instrux + 6044,
+    instrux + 6045,
+};
+
+static const struct itemplate * const itable_evex02126[] = {
+    instrux + 6490,
+    instrux + 6491,
+    instrux + 6492,
+    instrux + 6499,
+    instrux + 6500,
+    instrux + 6501,
+};
+
+static const struct itemplate * const itable_evex02127[] = {
+    instrux + 6493,
+    instrux + 6494,
+    instrux + 6495,
+    instrux + 6496,
+    instrux + 6497,
+    instrux + 6498,
+};
+
+static const struct itemplate * const itable_evex02128[] = {
+    instrux + 6115,
+    instrux + 6116,
+    instrux + 6117,
+    instrux + 6118,
+    instrux + 6119,
+    instrux + 6120,
+};
+
+static const struct itemplate * const itable_evex02129[] = {
+    instrux + 5415,
+    instrux + 5416,
+    instrux + 5417,
+};
+
+static const struct itemplate * const itable_evex0212A[] = {
+    instrux + 5143,
+    instrux + 5144,
+    instrux + 5145,
+};
+
+static const struct itemplate * const itable_evex0212B[] = {
+    instrux + 5244,
+    instrux + 5245,
+    instrux + 5246,
+    instrux + 5247,
+    instrux + 5248,
+    instrux + 5249,
+};
+
+static const struct itemplate * const itable_evex0212C[] = {
+    instrux + 6642,
+    instrux + 6643,
+    instrux + 6644,
+    instrux + 6645,
+    instrux + 6646,
+    instrux + 6647,
+    instrux + 6648,
+    instrux + 6649,
+    instrux + 6650,
+    instrux + 6651,
+    instrux + 6652,
+    instrux + 6653,
+};
+
+static const struct itemplate * const itable_evex0212D[] = {
+    instrux + 6654,
+    instrux + 6655,
+    instrux + 6656,
+    instrux + 6657,
+};
+
+static const struct itemplate * const itable_evex02130[] = {
+    instrux + 6103,
+    instrux + 6104,
+    instrux + 6105,
+};
+
+static const struct itemplate * const itable_evex02131[] = {
+    instrux + 6097,
+    instrux + 6098,
+    instrux + 6099,
+};
+
+static const struct itemplate * const itable_evex02132[] = {
+    instrux + 6100,
+    instrux + 6101,
+    instrux + 6102,
+};
+
+static const struct itemplate * const itable_evex02133[] = {
+    instrux + 6109,
+    instrux + 6110,
+    instrux + 6111,
+};
+
+static const struct itemplate * const itable_evex02134[] = {
+    instrux + 6112,
+    instrux + 6113,
+    instrux + 6114,
+};
+
+static const struct itemplate * const itable_evex02135[] = {
+    instrux + 6106,
+    instrux + 6107,
+    instrux + 6108,
+};
+
+static const struct itemplate * const itable_evex02136[] = {
+    instrux + 5697,
+    instrux + 5698,
+    instrux + 5699,
+    instrux + 5700,
+    instrux + 5749,
+    instrux + 5750,
+    instrux + 5751,
+    instrux + 5752,
+};
+
+static const struct itemplate * const itable_evex02137[] = {
+    instrux + 5427,
+    instrux + 5428,
+    instrux + 5429,
+};
+
+static const struct itemplate * const itable_evex02138[] = {
+    instrux + 5899,
+    instrux + 5900,
+    instrux + 5901,
+    instrux + 5902,
+    instrux + 5903,
+    instrux + 5904,
+};
+
+static const struct itemplate * const itable_evex02139[] = {
+    instrux + 5905,
+    instrux + 5906,
+    instrux + 5907,
+    instrux + 5908,
+    instrux + 5909,
+    instrux + 5910,
+    instrux + 5911,
+    instrux + 5912,
+    instrux + 5913,
+    instrux + 5914,
+    instrux + 5915,
+    instrux + 5916,
+};
+
+static const struct itemplate * const itable_evex0213A[] = {
+    instrux + 5941,
+    instrux + 5942,
+    instrux + 5943,
+    instrux + 5944,
+    instrux + 5945,
+    instrux + 5946,
+};
+
+static const struct itemplate * const itable_evex0213B[] = {
+    instrux + 5929,
+    instrux + 5930,
+    instrux + 5931,
+    instrux + 5932,
+    instrux + 5933,
+    instrux + 5934,
+    instrux + 5935,
+    instrux + 5936,
+    instrux + 5937,
+    instrux + 5938,
+    instrux + 5939,
+    instrux + 5940,
+};
+
+static const struct itemplate * const itable_evex0213C[] = {
+    instrux + 5851,
+    instrux + 5852,
+    instrux + 5853,
+    instrux + 5854,
+    instrux + 5855,
+    instrux + 5856,
+};
+
+static const struct itemplate * const itable_evex0213D[] = {
+    instrux + 5857,
+    instrux + 5858,
+    instrux + 5859,
+    instrux + 5860,
+    instrux + 5861,
+    instrux + 5862,
+    instrux + 5863,
+    instrux + 5864,
+    instrux + 5865,
+    instrux + 5866,
+    instrux + 5867,
+    instrux + 5868,
+};
+
+static const struct itemplate * const itable_evex0213E[] = {
+    instrux + 5893,
+    instrux + 5894,
+    instrux + 5895,
+    instrux + 5896,
+    instrux + 5897,
+    instrux + 5898,
+};
+
+static const struct itemplate * const itable_evex0213F[] = {
+    instrux + 5881,
+    instrux + 5882,
+    instrux + 5883,
+    instrux + 5884,
+    instrux + 5885,
+    instrux + 5886,
+    instrux + 5887,
+    instrux + 5888,
+    instrux + 5889,
+    instrux + 5890,
+    instrux + 5891,
+    instrux + 5892,
+};
+
+static const struct itemplate * const itable_evex02140[] = {
+    instrux + 6139,
+    instrux + 6140,
+    instrux + 6141,
+    instrux + 6142,
+    instrux + 6143,
+    instrux + 6144,
+    instrux + 6145,
+    instrux + 6146,
+    instrux + 6147,
+    instrux + 6148,
+    instrux + 6149,
+    instrux + 6150,
+};
+
+static const struct itemplate * const itable_evex02142[] = {
+    instrux + 4991,
+    instrux + 4992,
+    instrux + 4993,
+    instrux + 4994,
+    instrux + 4995,
+    instrux + 4996,
+};
+
+static const struct itemplate * const itable_evex02143[] = {
+    instrux + 4997,
+    instrux + 4998,
+};
+
+static const struct itemplate * const itable_evex02144[] = {
+    instrux + 5827,
+    instrux + 5828,
+    instrux + 5829,
+    instrux + 5830,
+    instrux + 5831,
+    instrux + 5832,
+};
+
+static const struct itemplate * const itable_evex02145[] = {
+    instrux + 6406,
+    instrux + 6407,
+    instrux + 6408,
+    instrux + 6409,
+    instrux + 6410,
+    instrux + 6411,
+    instrux + 6412,
+    instrux + 6413,
+    instrux + 6414,
+    instrux + 6415,
+    instrux + 6416,
+    instrux + 6417,
+};
+
+static const struct itemplate * const itable_evex02146[] = {
+    instrux + 6346,
+    instrux + 6347,
+    instrux + 6348,
+    instrux + 6349,
+    instrux + 6350,
+    instrux + 6351,
+    instrux + 6352,
+    instrux + 6353,
+    instrux + 6354,
+    instrux + 6355,
+    instrux + 6356,
+    instrux + 6357,
+};
+
+static const struct itemplate * const itable_evex02147[] = {
+    instrux + 6292,
+    instrux + 6293,
+    instrux + 6294,
+    instrux + 6295,
+    instrux + 6296,
+    instrux + 6297,
+    instrux + 6298,
+    instrux + 6299,
+    instrux + 6300,
+    instrux + 6301,
+    instrux + 6302,
+    instrux + 6303,
+};
+
+static const struct itemplate * const itable_evex0214C[] = {
+    instrux + 6590,
+    instrux + 6591,
+    instrux + 6592,
+    instrux + 6593,
+    instrux + 6594,
+    instrux + 6595,
+};
+
+static const struct itemplate * const itable_evex0214D[] = {
+    instrux + 6596,
+    instrux + 6597,
+    instrux + 6598,
+    instrux + 6599,
+};
+
+static const struct itemplate * const itable_evex0214E[] = {
+    instrux + 6626,
+    instrux + 6627,
+    instrux + 6628,
+    instrux + 6629,
+    instrux + 6630,
+    instrux + 6631,
+};
+
+static const struct itemplate * const itable_evex0214F[] = {
+    instrux + 6632,
+    instrux + 6633,
+    instrux + 6634,
+    instrux + 6635,
+};
+
+static const struct itemplate * const itable_evex02150[] = {
+    instrux + 6917,
+    instrux + 6918,
+    instrux + 6919,
+    instrux + 6920,
+    instrux + 6921,
+    instrux + 6922,
+};
+
+static const struct itemplate * const itable_evex02151[] = {
+    instrux + 6923,
+    instrux + 6924,
+    instrux + 6925,
+    instrux + 6926,
+    instrux + 6927,
+    instrux + 6928,
+};
+
+static const struct itemplate * const itable_evex02152[] = {
+    instrux + 6929,
+    instrux + 6930,
+    instrux + 6931,
+    instrux + 6932,
+    instrux + 6933,
+    instrux + 6934,
+};
+
+static const struct itemplate * const itable_evex02153[] = {
+    instrux + 6935,
+    instrux + 6936,
+    instrux + 6937,
+    instrux + 6938,
+    instrux + 6939,
+    instrux + 6940,
+};
+
+static const struct itemplate * const itable_evex02154[] = {
+    instrux + 6941,
+    instrux + 6942,
+    instrux + 6943,
+    instrux + 6944,
+    instrux + 6945,
+    instrux + 6946,
+};
+
+static const struct itemplate * const itable_evex02155[] = {
+    instrux + 6947,
+    instrux + 6948,
+    instrux + 6949,
+    instrux + 6950,
+    instrux + 6951,
+    instrux + 6952,
+};
+
+static const struct itemplate * const itable_evex02158[] = {
+    instrux + 5373,
+    instrux + 5374,
+    instrux + 5375,
+    instrux + 5376,
+    instrux + 5377,
+    instrux + 5378,
+};
+
+static const struct itemplate * const itable_evex02159[] = {
+    instrux + 4230,
+    instrux + 4231,
+    instrux + 4232,
+    instrux + 5388,
+    instrux + 5389,
+    instrux + 5390,
+    instrux + 5391,
+    instrux + 5392,
+    instrux + 5393,
+};
+
+static const struct itemplate * const itable_evex0215A[] = {
+    instrux + 4233,
+    instrux + 4234,
+    instrux + 4236,
+    instrux + 4237,
+};
+
+static const struct itemplate * const itable_evex0215B[] = {
+    instrux + 4235,
+    instrux + 4238,
+};
+
+static const struct itemplate * const itable_evex02162[] = {
+    instrux + 6839,
+    instrux + 6840,
+    instrux + 6841,
+    instrux + 6842,
+    instrux + 6843,
+    instrux + 6844,
+};
+
+static const struct itemplate * const itable_evex02163[] = {
+    instrux + 6827,
+    instrux + 6828,
+    instrux + 6829,
+    instrux + 6830,
+    instrux + 6831,
+    instrux + 6832,
+    instrux + 6833,
+    instrux + 6834,
+    instrux + 6835,
+    instrux + 6836,
+    instrux + 6837,
+    instrux + 6838,
+};
+
+static const struct itemplate * const itable_evex02164[] = {
+    instrux + 5349,
+    instrux + 5350,
+    instrux + 5351,
+    instrux + 5352,
+    instrux + 5353,
+    instrux + 5354,
+};
+
+static const struct itemplate * const itable_evex02165[] = {
+    instrux + 4216,
+    instrux + 4217,
+    instrux + 4218,
+    instrux + 4219,
+    instrux + 4220,
+    instrux + 4221,
+};
+
+static const struct itemplate * const itable_evex02166[] = {
+    instrux + 5346,
+    instrux + 5347,
+    instrux + 5348,
+    instrux + 5355,
+    instrux + 5356,
+    instrux + 5357,
+};
+
+static const struct itemplate * const itable_evex02170[] = {
+    instrux + 6863,
+    instrux + 6864,
+    instrux + 6865,
+    instrux + 6866,
+    instrux + 6867,
+    instrux + 6868,
+};
+
+static const struct itemplate * const itable_evex02171[] = {
+    instrux + 6869,
+    instrux + 6870,
+    instrux + 6871,
+    instrux + 6872,
+    instrux + 6873,
+    instrux + 6874,
+    instrux + 6875,
+    instrux + 6876,
+    instrux + 6877,
+    instrux + 6878,
+    instrux + 6879,
+    instrux + 6880,
+};
+
+static const struct itemplate * const itable_evex02172[] = {
+    instrux + 6899,
+    instrux + 6900,
+    instrux + 6901,
+    instrux + 6902,
+    instrux + 6903,
+    instrux + 6904,
+};
+
+static const struct itemplate * const itable_evex02173[] = {
+    instrux + 6905,
+    instrux + 6906,
+    instrux + 6907,
+    instrux + 6908,
+    instrux + 6909,
+    instrux + 6910,
+    instrux + 6911,
+    instrux + 6912,
+    instrux + 6913,
+    instrux + 6914,
+    instrux + 6915,
+    instrux + 6916,
+};
+
+static const struct itemplate * const itable_evex02175[] = {
+    instrux + 5701,
+    instrux + 5702,
+    instrux + 5703,
+    instrux + 5716,
+    instrux + 5717,
+    instrux + 5718,
+};
+
+static const struct itemplate * const itable_evex02176[] = {
+    instrux + 5704,
+    instrux + 5705,
+    instrux + 5706,
+    instrux + 5713,
+    instrux + 5714,
+    instrux + 5715,
+};
+
+static const struct itemplate * const itable_evex02177[] = {
+    instrux + 5707,
+    instrux + 5708,
+    instrux + 5709,
+    instrux + 5710,
+    instrux + 5711,
+    instrux + 5712,
+};
+
+static const struct itemplate * const itable_evex02178[] = {
+    instrux + 5358,
+    instrux + 5359,
+    instrux + 5360,
+};
+
+static const struct itemplate * const itable_evex02179[] = {
+    instrux + 5397,
+    instrux + 5398,
+    instrux + 5399,
+};
+
+static const struct itemplate * const itable_evex0217A[] = {
+    instrux + 5361,
+    instrux + 5362,
+    instrux + 5363,
+    instrux + 5364,
+    instrux + 5365,
+    instrux + 5366,
+    instrux + 5367,
+    instrux + 5368,
+    instrux + 5369,
+    instrux + 5370,
+    instrux + 5371,
+    instrux + 5372,
+};
+
+static const struct itemplate * const itable_evex0217B[] = {
+    instrux + 5400,
+    instrux + 5401,
+    instrux + 5402,
+    instrux + 5403,
+    instrux + 5404,
+    instrux + 5405,
+    instrux + 5406,
+    instrux + 5407,
+    instrux + 5408,
+};
+
+static const struct itemplate * const itable_evex0217C[] = {
+    instrux + 5379,
+    instrux + 5380,
+    instrux + 5381,
+    instrux + 5394,
+    instrux + 5395,
+    instrux + 5396,
+};
+
+static const struct itemplate * const itable_evex0217D[] = {
+    instrux + 5753,
+    instrux + 5754,
+    instrux + 5755,
+    instrux + 5768,
+    instrux + 5769,
+    instrux + 5770,
+};
+
+static const struct itemplate * const itable_evex0217E[] = {
+    instrux + 5756,
+    instrux + 5757,
+    instrux + 5758,
+    instrux + 5765,
+    instrux + 5766,
+    instrux + 5767,
+};
+
+static const struct itemplate * const itable_evex0217F[] = {
+    instrux + 5759,
+    instrux + 5760,
+    instrux + 5761,
+    instrux + 5762,
+    instrux + 5763,
+    instrux + 5764,
+};
+
+static const struct itemplate * const itable_evex02183[] = {
+    instrux + 6157,
+    instrux + 6158,
+    instrux + 6159,
+    instrux + 6160,
+    instrux + 6161,
+    instrux + 6162,
+};
+
+static const struct itemplate * const itable_evex02188[] = {
+    instrux + 4776,
+    instrux + 4777,
+    instrux + 4778,
+    instrux + 4779,
+    instrux + 4780,
+    instrux + 4781,
+    instrux + 4782,
+    instrux + 4783,
+    instrux + 4784,
+    instrux + 4785,
+    instrux + 4786,
+    instrux + 4787,
+};
+
+static const struct itemplate * const itable_evex02189[] = {
+    instrux + 5777,
+    instrux + 5778,
+    instrux + 5779,
+    instrux + 5780,
+    instrux + 5781,
+    instrux + 5782,
+    instrux + 5783,
+    instrux + 5784,
+    instrux + 5785,
+    instrux + 5786,
+    instrux + 5787,
+    instrux + 5788,
+};
+
+static const struct itemplate * const itable_evex0218A[] = {
+    instrux + 4627,
+    instrux + 4628,
+    instrux + 4629,
+    instrux + 4630,
+    instrux + 4631,
+    instrux + 4632,
+    instrux + 4633,
+    instrux + 4634,
+    instrux + 4635,
+    instrux + 4636,
+    instrux + 4637,
+    instrux + 4638,
+};
+
+static const struct itemplate * const itable_evex0218B[] = {
+    instrux + 5673,
+    instrux + 5674,
+    instrux + 5675,
+    instrux + 5676,
+    instrux + 5677,
+    instrux + 5678,
+    instrux + 5679,
+    instrux + 5680,
+    instrux + 5681,
+    instrux + 5682,
+    instrux + 5683,
+    instrux + 5684,
+};
+
+static const struct itemplate * const itable_evex0218D[] = {
+    instrux + 5691,
+    instrux + 5692,
+    instrux + 5693,
+    instrux + 5694,
+    instrux + 5695,
+    instrux + 5696,
+    instrux + 5771,
+    instrux + 5772,
+    instrux + 5773,
+    instrux + 5774,
+    instrux + 5775,
+    instrux + 5776,
+};
+
+static const struct itemplate * const itable_evex0218F[] = {
+    instrux + 6953,
+    instrux + 6954,
+    instrux + 6955,
+};
+
+static const struct itemplate * const itable_evex02190[] = {
+    instrux + 5803,
+    instrux + 5804,
+    instrux + 5805,
+    instrux + 5806,
+    instrux + 5807,
+    instrux + 5808,
+};
+
+static const struct itemplate * const itable_evex02191[] = {
+    instrux + 5809,
+    instrux + 5810,
+    instrux + 5811,
+    instrux + 5812,
+    instrux + 5813,
+    instrux + 5814,
+};
+
+static const struct itemplate * const itable_evex02192[] = {
+    instrux + 4971,
+    instrux + 4972,
+    instrux + 4973,
+    instrux + 4974,
+    instrux + 4975,
+    instrux + 4976,
+};
+
+static const struct itemplate * const itable_evex02193[] = {
+    instrux + 4985,
+    instrux + 4986,
+    instrux + 4987,
+    instrux + 4988,
+    instrux + 4989,
+    instrux + 4990,
+};
+
+static const struct itemplate * const itable_evex02196[] = {
+    instrux + 4855,
+    instrux + 4856,
+    instrux + 4857,
+    instrux + 4858,
+    instrux + 4859,
+    instrux + 4860,
+};
+
+static const struct itemplate * const itable_evex02197[] = {
+    instrux + 4897,
+    instrux + 4898,
+    instrux + 4899,
+    instrux + 4900,
+    instrux + 4901,
+    instrux + 4902,
+};
+
+static const struct itemplate * const itable_evex02198[] = {
+    instrux + 4831,
+    instrux + 4832,
+    instrux + 4833,
+    instrux + 4834,
+    instrux + 4835,
+    instrux + 4836,
+};
+
+static const struct itemplate * const itable_evex02199[] = {
+    instrux + 4837,
+    instrux + 4838,
+};
+
+static const struct itemplate * const itable_evex0219A[] = {
+    instrux + 4873,
+    instrux + 4874,
+    instrux + 4875,
+    instrux + 4876,
+    instrux + 4877,
+    instrux + 4878,
+};
+
+static const struct itemplate * const itable_evex0219B[] = {
+    instrux + 4879,
+    instrux + 4880,
+};
+
+static const struct itemplate * const itable_evex0219C[] = {
+    instrux + 4915,
+    instrux + 4916,
+    instrux + 4917,
+    instrux + 4918,
+    instrux + 4919,
+    instrux + 4920,
+};
+
+static const struct itemplate * const itable_evex0219D[] = {
+    instrux + 4921,
+    instrux + 4922,
+};
+
+static const struct itemplate * const itable_evex0219E[] = {
+    instrux + 4939,
+    instrux + 4940,
+    instrux + 4941,
+    instrux + 4942,
+    instrux + 4943,
+    instrux + 4944,
+};
+
+static const struct itemplate * const itable_evex0219F[] = {
+    instrux + 4945,
+    instrux + 4946,
+};
+
+static const struct itemplate * const itable_evex021A0[] = {
+    instrux + 6235,
+    instrux + 6236,
+    instrux + 6237,
+    instrux + 6238,
+    instrux + 6239,
+    instrux + 6240,
+};
+
+static const struct itemplate * const itable_evex021A1[] = {
+    instrux + 6241,
+    instrux + 6242,
+    instrux + 6243,
+    instrux + 6244,
+    instrux + 6245,
+    instrux + 6246,
+};
+
+static const struct itemplate * const itable_evex021A2[] = {
+    instrux + 6658,
+    instrux + 6659,
+    instrux + 6660,
+    instrux + 6661,
+    instrux + 6662,
+    instrux + 6663,
+};
+
+static const struct itemplate * const itable_evex021A3[] = {
+    instrux + 6672,
+    instrux + 6673,
+    instrux + 6674,
+    instrux + 6675,
+    instrux + 6676,
+    instrux + 6677,
+};
+
+static const struct itemplate * const itable_evex021A6[] = {
+    instrux + 4861,
+    instrux + 4862,
+    instrux + 4863,
+    instrux + 4864,
+    instrux + 4865,
+    instrux + 4866,
+};
+
+static const struct itemplate * const itable_evex021A7[] = {
+    instrux + 4903,
+    instrux + 4904,
+    instrux + 4905,
+    instrux + 4906,
+    instrux + 4907,
+    instrux + 4908,
+};
+
+static const struct itemplate * const itable_evex021A8[] = {
+    instrux + 4839,
+    instrux + 4840,
+    instrux + 4841,
+    instrux + 4842,
+    instrux + 4843,
+    instrux + 4844,
+};
+
+static const struct itemplate * const itable_evex021A9[] = {
+    instrux + 4845,
+    instrux + 4846,
+};
+
+static const struct itemplate * const itable_evex021AA[] = {
+    instrux + 4881,
+    instrux + 4882,
+    instrux + 4883,
+    instrux + 4884,
+    instrux + 4885,
+    instrux + 4886,
+};
+
+static const struct itemplate * const itable_evex021AB[] = {
+    instrux + 4887,
+    instrux + 4888,
+};
+
+static const struct itemplate * const itable_evex021AC[] = {
+    instrux + 4923,
+    instrux + 4924,
+    instrux + 4925,
+    instrux + 4926,
+    instrux + 4927,
+    instrux + 4928,
+};
+
+static const struct itemplate * const itable_evex021AD[] = {
+    instrux + 4929,
+    instrux + 4930,
+};
+
+static const struct itemplate * const itable_evex021AE[] = {
+    instrux + 4947,
+    instrux + 4948,
+    instrux + 4949,
+    instrux + 4950,
+    instrux + 4951,
+    instrux + 4952,
+};
+
+static const struct itemplate * const itable_evex021AF[] = {
+    instrux + 4953,
+    instrux + 4954,
+};
+
+static const struct itemplate * const itable_evex021B4[] = {
+    instrux + 5836,
+    instrux + 5837,
+    instrux + 5838,
+};
+
+static const struct itemplate * const itable_evex021B5[] = {
+    instrux + 5833,
+    instrux + 5834,
+    instrux + 5835,
+};
+
+static const struct itemplate * const itable_evex021B6[] = {
+    instrux + 4867,
+    instrux + 4868,
+    instrux + 4869,
+    instrux + 4870,
+    instrux + 4871,
+    instrux + 4872,
+};
+
+static const struct itemplate * const itable_evex021B7[] = {
+    instrux + 4909,
+    instrux + 4910,
+    instrux + 4911,
+    instrux + 4912,
+    instrux + 4913,
+    instrux + 4914,
+};
+
+static const struct itemplate * const itable_evex021B8[] = {
+    instrux + 4847,
+    instrux + 4848,
+    instrux + 4849,
+    instrux + 4850,
+    instrux + 4851,
+    instrux + 4852,
+};
+
+static const struct itemplate * const itable_evex021B9[] = {
+    instrux + 4853,
+    instrux + 4854,
+};
+
+static const struct itemplate * const itable_evex021BA[] = {
+    instrux + 4889,
+    instrux + 4890,
+    instrux + 4891,
+    instrux + 4892,
+    instrux + 4893,
+    instrux + 4894,
+};
+
+static const struct itemplate * const itable_evex021BB[] = {
+    instrux + 4895,
+    instrux + 4896,
+};
+
+static const struct itemplate * const itable_evex021BC[] = {
+    instrux + 4931,
+    instrux + 4932,
+    instrux + 4933,
+    instrux + 4934,
+    instrux + 4935,
+    instrux + 4936,
+};
+
+static const struct itemplate * const itable_evex021BD[] = {
+    instrux + 4937,
+    instrux + 4938,
+};
+
+static const struct itemplate * const itable_evex021BE[] = {
+    instrux + 4955,
+    instrux + 4956,
+    instrux + 4957,
+    instrux + 4958,
+    instrux + 4959,
+    instrux + 4960,
+};
+
+static const struct itemplate * const itable_evex021BF[] = {
+    instrux + 4961,
+    instrux + 4962,
+};
+
+static const struct itemplate * const itable_evex021C4[] = {
+    instrux + 5685,
+    instrux + 5686,
+    instrux + 5687,
+    instrux + 5688,
+    instrux + 5689,
+    instrux + 5690,
+};
+
+static const struct itemplate * const itable_evex021C6[] = {
+    instrux + 4977,
+    instrux + 4978,
+    instrux + 4981,
+    instrux + 4982,
+    instrux + 6664,
+    instrux + 6665,
+    instrux + 6668,
+    instrux + 6669,
+};
+
+static const struct itemplate * const itable_evex021C7[] = {
+    instrux + 4979,
+    instrux + 4980,
+    instrux + 4983,
+    instrux + 4984,
+    instrux + 6666,
+    instrux + 6667,
+    instrux + 6670,
+    instrux + 6671,
+};
+
+static const struct itemplate * const itable_evex021C8[] = {
+    instrux + 4774,
+    instrux + 4775,
+};
+
+static const struct itemplate * const itable_evex021CA[] = {
+    instrux + 6600,
+    instrux + 6601,
+};
+
+static const struct itemplate * const itable_evex021CB[] = {
+    instrux + 6602,
+    instrux + 6603,
+    instrux + 6604,
+    instrux + 6605,
+};
+
+static const struct itemplate * const itable_evex021CC[] = {
+    instrux + 6636,
+    instrux + 6637,
+};
+
+static const struct itemplate * const itable_evex021CD[] = {
+    instrux + 6638,
+    instrux + 6639,
+    instrux + 6640,
+    instrux + 6641,
+};
+
+static const struct itemplate * const itable_evex021CF[] = {
+    instrux + 6821,
+    instrux + 6822,
+    instrux + 6823,
+    instrux + 6824,
+    instrux + 6825,
+    instrux + 6826,
+};
+
+static const struct itemplate * const itable_evex021DC[] = {
+    instrux + 1901,
+    instrux + 1902,
+    instrux + 1903,
+    instrux + 1904,
+    instrux + 1917,
+    instrux + 1918,
+};
+
+static const struct itemplate * const itable_evex021DD[] = {
+    instrux + 1905,
+    instrux + 1906,
+    instrux + 1907,
+    instrux + 1908,
+    instrux + 1919,
+    instrux + 1920,
+};
+
+static const struct itemplate * const itable_evex021DE[] = {
+    instrux + 1909,
+    instrux + 1910,
+    instrux + 1911,
+    instrux + 1912,
+    instrux + 1921,
+    instrux + 1922,
+};
+
+static const struct itemplate * const itable_evex021DF[] = {
+    instrux + 1913,
+    instrux + 1914,
+    instrux + 1915,
+    instrux + 1916,
+    instrux + 1923,
+    instrux + 1924,
+};
+
+static const struct itemplate * const itable_evex02210[] = {
+    instrux + 6082,
+    instrux + 6083,
+    instrux + 6084,
+    instrux + 6085,
+    instrux + 6086,
+    instrux + 6087,
+};
+
+static const struct itemplate * const itable_evex02211[] = {
+    instrux + 6052,
+    instrux + 6053,
+    instrux + 6054,
+    instrux + 6055,
+    instrux + 6056,
+    instrux + 6057,
+};
+
+static const struct itemplate * const itable_evex02212[] = {
+    instrux + 6064,
+    instrux + 6065,
+    instrux + 6066,
+    instrux + 6067,
+    instrux + 6068,
+    instrux + 6069,
+};
+
+static const struct itemplate * const itable_evex02213[] = {
+    instrux + 6058,
+    instrux + 6059,
+    instrux + 6060,
+    instrux + 6061,
+    instrux + 6062,
+    instrux + 6063,
+};
+
+static const struct itemplate * const itable_evex02214[] = {
+    instrux + 6076,
+    instrux + 6077,
+    instrux + 6078,
+    instrux + 6079,
+    instrux + 6080,
+    instrux + 6081,
+};
+
+static const struct itemplate * const itable_evex02215[] = {
+    instrux + 6070,
+    instrux + 6071,
+    instrux + 6072,
+    instrux + 6073,
+    instrux + 6074,
+    instrux + 6075,
+};
+
+static const struct itemplate * const itable_evex02220[] = {
+    instrux + 6028,
+    instrux + 6029,
+    instrux + 6030,
+    instrux + 6031,
+    instrux + 6032,
+    instrux + 6033,
+};
+
+static const struct itemplate * const itable_evex02221[] = {
+    instrux + 5998,
+    instrux + 5999,
+    instrux + 6000,
+    instrux + 6001,
+    instrux + 6002,
+    instrux + 6003,
+};
+
+static const struct itemplate * const itable_evex02222[] = {
+    instrux + 6010,
+    instrux + 6011,
+    instrux + 6012,
+    instrux + 6013,
+    instrux + 6014,
+    instrux + 6015,
+};
+
+static const struct itemplate * const itable_evex02223[] = {
+    instrux + 6004,
+    instrux + 6005,
+    instrux + 6006,
+    instrux + 6007,
+    instrux + 6008,
+    instrux + 6009,
+};
+
+static const struct itemplate * const itable_evex02224[] = {
+    instrux + 6022,
+    instrux + 6023,
+    instrux + 6024,
+    instrux + 6025,
+    instrux + 6026,
+    instrux + 6027,
+};
+
+static const struct itemplate * const itable_evex02225[] = {
+    instrux + 6016,
+    instrux + 6017,
+    instrux + 6018,
+    instrux + 6019,
+    instrux + 6020,
+    instrux + 6021,
+};
+
+static const struct itemplate * const itable_evex02226[] = {
+    instrux + 6502,
+    instrux + 6503,
+    instrux + 6504,
+    instrux + 6511,
+    instrux + 6512,
+    instrux + 6513,
+};
+
+static const struct itemplate * const itable_evex02227[] = {
+    instrux + 6505,
+    instrux + 6506,
+    instrux + 6507,
+    instrux + 6508,
+    instrux + 6509,
+    instrux + 6510,
+};
+
+static const struct itemplate * const itable_evex02228[] = {
+    instrux + 5965,
+    instrux + 5966,
+    instrux + 5967,
+    instrux + 5974,
+    instrux + 5975,
+    instrux + 5976,
+};
+
+static const struct itemplate * const itable_evex02229[] = {
+    instrux + 5947,
+    instrux + 5948,
+    instrux + 5949,
+    instrux + 6088,
+    instrux + 6089,
+    instrux + 6090,
+};
+
+static const struct itemplate * const itable_evex0222A[] = {
+    instrux + 5382,
+    instrux + 5383,
+    instrux + 5384,
+};
+
+static const struct itemplate * const itable_evex02230[] = {
+    instrux + 6091,
+    instrux + 6092,
+    instrux + 6093,
+    instrux + 6094,
+    instrux + 6095,
+    instrux + 6096,
+};
+
+static const struct itemplate * const itable_evex02231[] = {
+    instrux + 5953,
+    instrux + 5954,
+    instrux + 5955,
+    instrux + 5956,
+    instrux + 5957,
+    instrux + 5958,
+};
+
+static const struct itemplate * const itable_evex02232[] = {
+    instrux + 5980,
+    instrux + 5981,
+    instrux + 5982,
+    instrux + 5983,
+    instrux + 5984,
+    instrux + 5985,
+};
+
+static const struct itemplate * const itable_evex02233[] = {
+    instrux + 5959,
+    instrux + 5960,
+    instrux + 5961,
+    instrux + 5962,
+    instrux + 5963,
+    instrux + 5964,
+};
+
+static const struct itemplate * const itable_evex02234[] = {
+    instrux + 5992,
+    instrux + 5993,
+    instrux + 5994,
+    instrux + 5995,
+    instrux + 5996,
+    instrux + 5997,
+};
+
+static const struct itemplate * const itable_evex02235[] = {
+    instrux + 5986,
+    instrux + 5987,
+    instrux + 5988,
+    instrux + 5989,
+    instrux + 5990,
+    instrux + 5991,
+};
+
+static const struct itemplate * const itable_evex02238[] = {
+    instrux + 5968,
+    instrux + 5969,
+    instrux + 5970,
+    instrux + 5971,
+    instrux + 5972,
+    instrux + 5973,
+};
+
+static const struct itemplate * const itable_evex02239[] = {
+    instrux + 5950,
+    instrux + 5951,
+    instrux + 5952,
+    instrux + 5977,
+    instrux + 5978,
+    instrux + 5979,
+};
+
+static const struct itemplate * const itable_evex0223A[] = {
+    instrux + 5385,
+    instrux + 5386,
+    instrux + 5387,
+};
+
+static const struct itemplate * const itable_evex02252[] = {
+    instrux + 7002,
+    instrux + 7003,
+    instrux + 7004,
+    instrux + 7005,
+    instrux + 7006,
+    instrux + 7007,
+};
+
+static const struct itemplate * const itable_evex02272[] = {
+    instrux + 6996,
+    instrux + 6997,
+    instrux + 6998,
+    instrux + 6999,
+    instrux + 7000,
+    instrux + 7001,
+};
+
+static const struct itemplate * const itable_evex02352[] = {
+    instrux + 6961,
+};
+
+static const struct itemplate * const itable_evex02353[] = {
+    instrux + 6960,
+};
+
+static const struct itemplate * const itable_evex02368[] = {
+    instrux + 7008,
+    instrux + 7009,
+    instrux + 7010,
+};
+
+static const struct itemplate * const itable_evex02372[] = {
+    instrux + 6990,
+    instrux + 6991,
+    instrux + 6992,
+    instrux + 6993,
+    instrux + 6994,
+    instrux + 6995,
+};
+
+static const struct itemplate * const itable_evex0239A[] = {
+    instrux + 6956,
+};
+
+static const struct itemplate * const itable_evex0239B[] = {
+    instrux + 6958,
+};
+
+static const struct itemplate * const itable_evex023AA[] = {
+    instrux + 6957,
+};
+
+static const struct itemplate * const itable_evex023AB[] = {
+    instrux + 6959,
+};
+
+static const struct itemplate * const itable_evex03008[] = {
+    instrux + 7362,
+    instrux + 7363,
+    instrux + 7364,
+};
+
+static const struct itemplate * const itable_evex0300A[] = {
+    instrux + 7365,
+    instrux + 7366,
+};
+
+static const struct itemplate * const itable_evex03025[] = {
+    instrux + 7321,
+    instrux + 7322,
+    instrux + 7323,
+};
+
+static const struct itemplate * const itable_evex03027[] = {
+    instrux + 7324,
+};
+
+static const struct itemplate * const itable_evex03056[] = {
+    instrux + 7357,
+    instrux + 7358,
+    instrux + 7359,
+};
+
+static const struct itemplate * const itable_evex03057[] = {
+    instrux + 7360,
+    instrux + 7361,
+};
+
+static const struct itemplate * const itable_evex03066[] = {
+    instrux + 7313,
+    instrux + 7314,
+    instrux + 7315,
+};
+
+static const struct itemplate * const itable_evex03067[] = {
+    instrux + 7316,
+};
+
+static const struct itemplate * const itable_evex030C2[] = {
+    instrux + 7031,
+    instrux + 7032,
+    instrux + 7033,
+    instrux + 7034,
+    instrux + 7035,
+    instrux + 7036,
+};
+
+static const struct itemplate * const itable_evex03100[] = {
+    instrux + 5747,
+    instrux + 5748,
+};
+
+static const struct itemplate * const itable_evex03101[] = {
+    instrux + 5737,
+    instrux + 5738,
+};
+
+static const struct itemplate * const itable_evex03103[] = {
+    instrux + 4180,
+    instrux + 4181,
+    instrux + 4182,
+    instrux + 4183,
+    instrux + 4184,
+    instrux + 4185,
+    instrux + 4186,
+    instrux + 4187,
+    instrux + 4188,
+    instrux + 4189,
+    instrux + 4190,
+    instrux + 4191,
+};
+
+static const struct itemplate * const itable_evex03104[] = {
+    instrux + 5728,
+    instrux + 5729,
+    instrux + 5730,
+};
+
+static const struct itemplate * const itable_evex03105[] = {
+    instrux + 5719,
+    instrux + 5720,
+    instrux + 5721,
+};
+
+static const struct itemplate * const itable_evex03108[] = {
+    instrux + 6619,
+    instrux + 6620,
+    instrux + 6621,
+};
+
+static const struct itemplate * const itable_evex03109[] = {
+    instrux + 6616,
+    instrux + 6617,
+    instrux + 6618,
+};
+
+static const struct itemplate * const itable_evex0310A[] = {
+    instrux + 6624,
+    instrux + 6625,
+};
+
+static const struct itemplate * const itable_evex0310B[] = {
+    instrux + 6622,
+    instrux + 6623,
+};
+
+static const struct itemplate * const itable_evex0310F[] = {
+    instrux + 5304,
+    instrux + 5305,
+    instrux + 5306,
+    instrux + 5307,
+    instrux + 5308,
+    instrux + 5309,
+};
+
+static const struct itemplate * const itable_evex03114[] = {
+    instrux + 5789,
+    instrux + 5790,
+    instrux + 5791,
+    instrux + 5792,
+    instrux + 5793,
+};
+
+static const struct itemplate * const itable_evex03115[] = {
+    instrux + 5796,
+    instrux + 5797,
+    instrux + 5798,
+    instrux + 5799,
+};
+
+static const struct itemplate * const itable_evex03116[] = {
+    instrux + 5794,
+    instrux + 5795,
+};
+
+static const struct itemplate * const itable_evex03117[] = {
+    instrux + 4812,
+    instrux + 4813,
+    instrux + 4814,
+};
+
+static const struct itemplate * const itable_evex03118[] = {
+    instrux + 5007,
+    instrux + 5008,
+    instrux + 5009,
+    instrux + 5010,
+    instrux + 5013,
+    instrux + 5014,
+    instrux + 5015,
+    instrux + 5016,
+};
+
+static const struct itemplate * const itable_evex03119[] = {
+    instrux + 4788,
+    instrux + 4789,
+    instrux + 4790,
+    instrux + 4791,
+    instrux + 4794,
+    instrux + 4795,
+    instrux + 4796,
+    instrux + 4797,
+};
+
+static const struct itemplate * const itable_evex0311A[] = {
+    instrux + 5011,
+    instrux + 5012,
+    instrux + 5017,
+    instrux + 5018,
+};
+
+static const struct itemplate * const itable_evex0311B[] = {
+    instrux + 4792,
+    instrux + 4793,
+    instrux + 4798,
+    instrux + 4799,
+};
+
+static const struct itemplate * const itable_evex0311D[] = {
+    instrux + 4669,
+    instrux + 4670,
+    instrux + 4671,
+    instrux + 4672,
+    instrux + 4673,
+    instrux + 4674,
+    instrux + 7077,
+    instrux + 7078,
+    instrux + 7079,
+    instrux + 7080,
+    instrux + 7081,
+    instrux + 7082,
+};
+
+static const struct itemplate * const itable_evex0311E[] = {
+    instrux + 5445,
+    instrux + 5446,
+    instrux + 5447,
+    instrux + 5448,
+    instrux + 5449,
+    instrux + 5450,
+    instrux + 5469,
+    instrux + 5470,
+    instrux + 5471,
+    instrux + 5472,
+    instrux + 5473,
+    instrux + 5474,
+    instrux + 5493,
+    instrux + 5494,
+    instrux + 5495,
+    instrux + 5496,
+    instrux + 5497,
+    instrux + 5498,
+    instrux + 5517,
+    instrux + 5518,
+    instrux + 5519,
+    instrux + 5520,
+    instrux + 5521,
+    instrux + 5522,
+    instrux + 5541,
+    instrux + 5542,
+    instrux + 5543,
+    instrux + 5544,
+    instrux + 5545,
+    instrux + 5546,
+    instrux + 5565,
+    instrux + 5566,
+    instrux + 5567,
+    instrux + 5568,
+    instrux + 5569,
+    instrux + 5570,
+    instrux + 5589,
+    instrux + 5590,
+    instrux + 5591,
+    instrux + 5592,
+    instrux + 5593,
+    instrux + 5594,
+    instrux + 5613,
+    instrux + 5614,
+    instrux + 5615,
+    instrux + 5616,
+    instrux + 5617,
+    instrux + 5618,
+    instrux + 5637,
+    instrux + 5638,
+    instrux + 5639,
+    instrux + 5640,
+    instrux + 5641,
+    instrux + 5642,
+    instrux + 5661,
+    instrux + 5662,
+    instrux + 5663,
+    instrux + 5664,
+    instrux + 5665,
+    instrux + 5666,
+};
+
+static const struct itemplate * const itable_evex0311F[] = {
+    instrux + 5436,
+    instrux + 5437,
+    instrux + 5438,
+    instrux + 5439,
+    instrux + 5440,
+    instrux + 5441,
+    instrux + 5460,
+    instrux + 5461,
+    instrux + 5462,
+    instrux + 5463,
+    instrux + 5464,
+    instrux + 5465,
+    instrux + 5484,
+    instrux + 5485,
+    instrux + 5486,
+    instrux + 5487,
+    instrux + 5488,
+    instrux + 5489,
+    instrux + 5508,
+    instrux + 5509,
+    instrux + 5510,
+    instrux + 5511,
+    instrux + 5512,
+    instrux + 5513,
+    instrux + 5532,
+    instrux + 5533,
+    instrux + 5534,
+    instrux + 5535,
+    instrux + 5536,
+    instrux + 5537,
+    instrux + 5556,
+    instrux + 5557,
+    instrux + 5558,
+    instrux + 5559,
+    instrux + 5560,
+    instrux + 5561,
+    instrux + 5580,
+    instrux + 5581,
+    instrux + 5582,
+    instrux + 5583,
+    instrux + 5584,
+    instrux + 5585,
+    instrux + 5604,
+    instrux + 5605,
+    instrux + 5606,
+    instrux + 5607,
+    instrux + 5608,
+    instrux + 5609,
+    instrux + 5628,
+    instrux + 5629,
+    instrux + 5630,
+    instrux + 5631,
+    instrux + 5632,
+    instrux + 5633,
+    instrux + 5652,
+    instrux + 5653,
+    instrux + 5654,
+    instrux + 5655,
+    instrux + 5656,
+    instrux + 5657,
+};
+
+static const struct itemplate * const itable_evex03120[] = {
+    instrux + 5815,
+    instrux + 5816,
+    instrux + 5817,
+    instrux + 5818,
+};
+
+static const struct itemplate * const itable_evex03121[] = {
+    instrux + 5031,
+    instrux + 5032,
+};
+
+static const struct itemplate * const itable_evex03122[] = {
+    instrux + 5819,
+    instrux + 5820,
+    instrux + 5821,
+    instrux + 5822,
+};
+
+static const struct itemplate * const itable_evex03123[] = {
+    instrux + 6678,
+    instrux + 6679,
+    instrux + 6680,
+    instrux + 6681,
+    instrux + 6682,
+    instrux + 6683,
+    instrux + 6684,
+    instrux + 6685,
+};
+
+static const struct itemplate * const itable_evex03125[] = {
+    instrux + 6484,
+    instrux + 6485,
+    instrux + 6486,
+    instrux + 6487,
+    instrux + 6488,
+    instrux + 6489,
+};
+
+static const struct itemplate * const itable_evex03126[] = {
+    instrux + 4999,
+    instrux + 5000,
+    instrux + 5001,
+    instrux + 5002,
+    instrux + 5003,
+    instrux + 5004,
+};
+
+static const struct itemplate * const itable_evex03127[] = {
+    instrux + 5005,
+    instrux + 5006,
+};
+
+static const struct itemplate * const itable_evex03138[] = {
+    instrux + 5019,
+    instrux + 5020,
+    instrux + 5021,
+    instrux + 5022,
+    instrux + 5025,
+    instrux + 5026,
+    instrux + 5027,
+    instrux + 5028,
+};
+
+static const struct itemplate * const itable_evex03139[] = {
+    instrux + 4800,
+    instrux + 4801,
+    instrux + 4802,
+    instrux + 4803,
+    instrux + 4806,
+    instrux + 4807,
+    instrux + 4808,
+    instrux + 4809,
+};
+
+static const struct itemplate * const itable_evex0313A[] = {
+    instrux + 5023,
+    instrux + 5024,
+    instrux + 5029,
+    instrux + 5030,
+};
+
+static const struct itemplate * const itable_evex0313B[] = {
+    instrux + 4804,
+    instrux + 4805,
+    instrux + 4810,
+    instrux + 4811,
+};
+
+static const struct itemplate * const itable_evex0313E[] = {
+    instrux + 5442,
+    instrux + 5443,
+    instrux + 5444,
+    instrux + 5451,
+    instrux + 5452,
+    instrux + 5453,
+    instrux + 5466,
+    instrux + 5467,
+    instrux + 5468,
+    instrux + 5475,
+    instrux + 5476,
+    instrux + 5477,
+    instrux + 5490,
+    instrux + 5491,
+    instrux + 5492,
+    instrux + 5499,
+    instrux + 5500,
+    instrux + 5501,
+    instrux + 5514,
+    instrux + 5515,
+    instrux + 5516,
+    instrux + 5523,
+    instrux + 5524,
+    instrux + 5525,
+    instrux + 5538,
+    instrux + 5539,
+    instrux + 5540,
+    instrux + 5547,
+    instrux + 5548,
+    instrux + 5549,
+    instrux + 5562,
+    instrux + 5563,
+    instrux + 5564,
+    instrux + 5571,
+    instrux + 5572,
+    instrux + 5573,
+    instrux + 5586,
+    instrux + 5587,
+    instrux + 5588,
+    instrux + 5595,
+    instrux + 5596,
+    instrux + 5597,
+    instrux + 5610,
+    instrux + 5611,
+    instrux + 5612,
+    instrux + 5619,
+    instrux + 5620,
+    instrux + 5621,
+    instrux + 5634,
+    instrux + 5635,
+    instrux + 5636,
+    instrux + 5643,
+    instrux + 5644,
+    instrux + 5645,
+    instrux + 5658,
+    instrux + 5659,
+    instrux + 5660,
+    instrux + 5667,
+    instrux + 5668,
+    instrux + 5669,
+};
+
+static const struct itemplate * const itable_evex0313F[] = {
+    instrux + 5433,
+    instrux + 5434,
+    instrux + 5435,
+    instrux + 5454,
+    instrux + 5455,
+    instrux + 5456,
+    instrux + 5457,
+    instrux + 5458,
+    instrux + 5459,
+    instrux + 5478,
+    instrux + 5479,
+    instrux + 5480,
+    instrux + 5481,
+    instrux + 5482,
+    instrux + 5483,
+    instrux + 5502,
+    instrux + 5503,
+    instrux + 5504,
+    instrux + 5505,
+    instrux + 5506,
+    instrux + 5507,
+    instrux + 5526,
+    instrux + 5527,
+    instrux + 5528,
+    instrux + 5529,
+    instrux + 5530,
+    instrux + 5531,
+    instrux + 5550,
+    instrux + 5551,
+    instrux + 5552,
+    instrux + 5553,
+    instrux + 5554,
+    instrux + 5555,
+    instrux + 5574,
+    instrux + 5575,
+    instrux + 5576,
+    instrux + 5577,
+    instrux + 5578,
+    instrux + 5579,
+    instrux + 5598,
+    instrux + 5599,
+    instrux + 5600,
+    instrux + 5601,
+    instrux + 5602,
+    instrux + 5603,
+    instrux + 5622,
+    instrux + 5623,
+    instrux + 5624,
+    instrux + 5625,
+    instrux + 5626,
+    instrux + 5627,
+    instrux + 5646,
+    instrux + 5647,
+    instrux + 5648,
+    instrux + 5649,
+    instrux + 5650,
+    instrux + 5651,
+    instrux + 5670,
+    instrux + 5671,
+    instrux + 5672,
+};
+
+static const struct itemplate * const itable_evex03142[] = {
+    instrux + 4752,
+    instrux + 4753,
+    instrux + 4754,
+    instrux + 4755,
+    instrux + 4756,
+    instrux + 4757,
+};
+
+static const struct itemplate * const itable_evex03143[] = {
+    instrux + 6686,
+    instrux + 6687,
+    instrux + 6688,
+    instrux + 6689,
+    instrux + 6690,
+    instrux + 6691,
+    instrux + 6692,
+    instrux + 6693,
+};
+
+static const struct itemplate * const itable_evex03144[] = {
+    instrux + 3136,
+    instrux + 3137,
+    instrux + 3138,
+    instrux + 3139,
+    instrux + 3140,
+    instrux + 3141,
+    instrux + 3142,
+    instrux + 3143,
+    instrux + 3144,
+    instrux + 3145,
+    instrux + 3146,
+    instrux + 3147,
+    instrux + 3148,
+    instrux + 3149,
+    instrux + 3150,
+    instrux + 3151,
+    instrux + 3152,
+    instrux + 3153,
+    instrux + 3154,
+    instrux + 3155,
+    instrux + 3156,
+    instrux + 3157,
+    instrux + 3158,
+    instrux + 3159,
+    instrux + 3160,
+    instrux + 3161,
+    instrux + 3162,
+    instrux + 3163,
+    instrux + 3164,
+    instrux + 3165,
+};
+
+static const struct itemplate * const itable_evex03150[] = {
+    instrux + 6574,
+    instrux + 6575,
+    instrux + 6576,
+    instrux + 6577,
+    instrux + 6578,
+    instrux + 6579,
+    instrux + 6580,
+    instrux + 6581,
+    instrux + 6582,
+    instrux + 6583,
+    instrux + 6584,
+    instrux + 6585,
+};
+
+static const struct itemplate * const itable_evex03151[] = {
+    instrux + 6586,
+    instrux + 6587,
+    instrux + 6588,
+    instrux + 6589,
+};
+
+static const struct itemplate * const itable_evex03154[] = {
+    instrux + 4815,
+    instrux + 4816,
+    instrux + 4817,
+    instrux + 4818,
+    instrux + 4819,
+    instrux + 4820,
+    instrux + 4821,
+    instrux + 4822,
+    instrux + 4823,
+    instrux + 4824,
+    instrux + 4825,
+    instrux + 4826,
+};
+
+static const struct itemplate * const itable_evex03155[] = {
+    instrux + 4827,
+    instrux + 4828,
+    instrux + 4829,
+    instrux + 4830,
+};
+
+static const struct itemplate * const itable_evex03156[] = {
+    instrux + 6606,
+    instrux + 6607,
+    instrux + 6608,
+    instrux + 6609,
+    instrux + 6610,
+    instrux + 6611,
+};
+
+static const struct itemplate * const itable_evex03157[] = {
+    instrux + 6612,
+    instrux + 6613,
+    instrux + 6614,
+    instrux + 6615,
+};
+
+static const struct itemplate * const itable_evex03166[] = {
+    instrux + 4963,
+    instrux + 4964,
+    instrux + 4965,
+    instrux + 4966,
+    instrux + 4967,
+    instrux + 4968,
+};
+
+static const struct itemplate * const itable_evex03167[] = {
+    instrux + 4969,
+    instrux + 4970,
+};
+
+static const struct itemplate * const itable_evex03170[] = {
+    instrux + 6845,
+    instrux + 6846,
+    instrux + 6847,
+    instrux + 6848,
+    instrux + 6849,
+    instrux + 6850,
+};
+
+static const struct itemplate * const itable_evex03171[] = {
+    instrux + 6851,
+    instrux + 6852,
+    instrux + 6853,
+    instrux + 6854,
+    instrux + 6855,
+    instrux + 6856,
+    instrux + 6857,
+    instrux + 6858,
+    instrux + 6859,
+    instrux + 6860,
+    instrux + 6861,
+    instrux + 6862,
+};
+
+static const struct itemplate * const itable_evex03172[] = {
+    instrux + 6881,
+    instrux + 6882,
+    instrux + 6883,
+    instrux + 6884,
+    instrux + 6885,
+    instrux + 6886,
+};
+
+static const struct itemplate * const itable_evex03173[] = {
+    instrux + 6887,
+    instrux + 6888,
+    instrux + 6889,
+    instrux + 6890,
+    instrux + 6891,
+    instrux + 6892,
+    instrux + 6893,
+    instrux + 6894,
+    instrux + 6895,
+    instrux + 6896,
+    instrux + 6897,
+    instrux + 6898,
+};
+
+static const struct itemplate * const itable_evex031CE[] = {
+    instrux + 6810,
+    instrux + 6811,
+    instrux + 6812,
+    instrux + 6813,
+    instrux + 6814,
+    instrux + 6815,
+};
+
+static const struct itemplate * const itable_evex031CF[] = {
+    instrux + 6799,
+    instrux + 6800,
+    instrux + 6801,
+    instrux + 6802,
+    instrux + 6803,
+    instrux + 6804,
+};
+
+static const struct itemplate * const itable_evex032C2[] = {
+    instrux + 7037,
+    instrux + 7038,
+};
+
+static const struct itemplate * const itable_evex0501D[] = {
+    instrux + 7103,
+    instrux + 7104,
+};
+
+static const struct itemplate * const itable_evex0502E[] = {
+    instrux + 7393,
+};
+
+static const struct itemplate * const itable_evex0502F[] = {
+    instrux + 7039,
+};
+
+static const struct itemplate * const itable_evex05051[] = {
+    instrux + 7380,
+    instrux + 7381,
+    instrux + 7382,
+};
+
+static const struct itemplate * const itable_evex05058[] = {
+    instrux + 7023,
+    instrux + 7024,
+    instrux + 7025,
+    instrux + 7026,
+    instrux + 7027,
+    instrux + 7028,
+};
+
+static const struct itemplate * const itable_evex05059[] = {
+    instrux + 7341,
+    instrux + 7342,
+    instrux + 7343,
+    instrux + 7344,
+    instrux + 7345,
+    instrux + 7346,
+};
+
+static const struct itemplate * const itable_evex0505A[] = {
+    instrux + 7049,
+    instrux + 7050,
+    instrux + 7051,
+};
+
+static const struct itemplate * const itable_evex0505B[] = {
+    instrux + 7040,
+    instrux + 7041,
+    instrux + 7042,
+    instrux + 7086,
+    instrux + 7087,
+    instrux + 7088,
+};
+
+static const struct itemplate * const itable_evex0505C[] = {
+    instrux + 7385,
+    instrux + 7386,
+    instrux + 7387,
+    instrux + 7388,
+    instrux + 7389,
+    instrux + 7390,
+};
+
+static const struct itemplate * const itable_evex0505D[] = {
+    instrux + 7329,
+    instrux + 7330,
+    instrux + 7331,
+};
+
+static const struct itemplate * const itable_evex0505E[] = {
+    instrux + 7141,
+    instrux + 7142,
+    instrux + 7143,
+    instrux + 7144,
+    instrux + 7145,
+    instrux + 7146,
+};
+
+static const struct itemplate * const itable_evex0505F[] = {
+    instrux + 7325,
+    instrux + 7326,
+    instrux + 7327,
+};
+
+static const struct itemplate * const itable_evex05078[] = {
+    instrux + 7111,
+    instrux + 7112,
+    instrux + 7113,
+};
+
+static const struct itemplate * const itable_evex05079[] = {
+    instrux + 7063,
+    instrux + 7064,
+    instrux + 7065,
+};
+
+static const struct itemplate * const itable_evex0507C[] = {
+    instrux + 7117,
+    instrux + 7118,
+    instrux + 7119,
+};
+
+static const struct itemplate * const itable_evex0507D[] = {
+    instrux + 7069,
+    instrux + 7070,
+    instrux + 7071,
+};
+
+static const struct itemplate * const itable_evex0511D[] = {
+    instrux + 7083,
+    instrux + 7084,
+    instrux + 7085,
+};
+
+static const struct itemplate * const itable_evex0515A[] = {
+    instrux + 7043,
+    instrux + 7044,
+    instrux + 7045,
+};
+
+static const struct itemplate * const itable_evex0515B[] = {
+    instrux + 7046,
+    instrux + 7047,
+    instrux + 7048,
+};
+
+static const struct itemplate * const itable_evex0516E[] = {
+    instrux + 7339,
+};
+
+static const struct itemplate * const itable_evex05178[] = {
+    instrux + 7114,
+    instrux + 7115,
+    instrux + 7116,
+};
+
+static const struct itemplate * const itable_evex05179[] = {
+    instrux + 7066,
+    instrux + 7067,
+    instrux + 7068,
+};
+
+static const struct itemplate * const itable_evex0517A[] = {
+    instrux + 7108,
+    instrux + 7109,
+    instrux + 7110,
+};
+
+static const struct itemplate * const itable_evex0517B[] = {
+    instrux + 7060,
+    instrux + 7061,
+    instrux + 7062,
+};
+
+static const struct itemplate * const itable_evex0517C[] = {
+    instrux + 7120,
+    instrux + 7121,
+    instrux + 7122,
+};
+
+static const struct itemplate * const itable_evex0517D[] = {
+    instrux + 7072,
+    instrux + 7073,
+    instrux + 7074,
+};
+
+static const struct itemplate * const itable_evex0517E[] = {
+    instrux + 7340,
+};
+
+static const struct itemplate * const itable_evex05210[] = {
+    instrux + 7333,
+    instrux + 7335,
+    instrux + 7336,
+};
+
+static const struct itemplate * const itable_evex05211[] = {
+    instrux + 7334,
+    instrux + 7337,
+    instrux + 7338,
+};
+
+static const struct itemplate * const itable_evex0522A[] = {
+    instrux + 7099,
+    instrux + 7100,
+    instrux + 7101,
+    instrux + 7102,
+};
+
+static const struct itemplate * const itable_evex0522C[] = {
+    instrux + 7123,
+    instrux + 7124,
+};
+
+static const struct itemplate * const itable_evex0522D[] = {
+    instrux + 7093,
+    instrux + 7094,
+};
+
+static const struct itemplate * const itable_evex05251[] = {
+    instrux + 7383,
+    instrux + 7384,
+};
+
+static const struct itemplate * const itable_evex05258[] = {
+    instrux + 7029,
+    instrux + 7030,
+};
+
+static const struct itemplate * const itable_evex05259[] = {
+    instrux + 7347,
+    instrux + 7348,
+};
+
+static const struct itemplate * const itable_evex0525A[] = {
+    instrux + 7091,
+    instrux + 7092,
+};
+
+static const struct itemplate * const itable_evex0525B[] = {
+    instrux + 7105,
+    instrux + 7106,
+    instrux + 7107,
+};
+
+static const struct itemplate * const itable_evex0525C[] = {
+    instrux + 7391,
+    instrux + 7392,
+};
+
+static const struct itemplate * const itable_evex0525D[] = {
+    instrux + 7332,
+};
+
+static const struct itemplate * const itable_evex0525E[] = {
+    instrux + 7147,
+    instrux + 7148,
+};
+
+static const struct itemplate * const itable_evex0525F[] = {
+    instrux + 7328,
+};
+
+static const struct itemplate * const itable_evex05278[] = {
+    instrux + 7125,
+    instrux + 7126,
+};
+
+static const struct itemplate * const itable_evex05279[] = {
+    instrux + 7097,
+    instrux + 7098,
+};
+
+static const struct itemplate * const itable_evex0527B[] = {
+    instrux + 7133,
+    instrux + 7134,
+};
+
+static const struct itemplate * const itable_evex0527D[] = {
+    instrux + 7138,
+    instrux + 7139,
+    instrux + 7140,
+};
+
+static const struct itemplate * const itable_evex0535A[] = {
+    instrux + 7089,
+    instrux + 7090,
+};
+
+static const struct itemplate * const itable_evex0537A[] = {
+    instrux + 7127,
+    instrux + 7128,
+    instrux + 7129,
+    instrux + 7130,
+    instrux + 7131,
+    instrux + 7132,
+};
+
+static const struct itemplate * const itable_evex0537D[] = {
+    instrux + 7135,
+    instrux + 7136,
+    instrux + 7137,
+};
+
+static const struct itemplate * const itable_evex06013[] = {
+    instrux + 7095,
+    instrux + 7096,
+};
+
+static const struct itemplate * const itable_evex06113[] = {
+    instrux + 7057,
+    instrux + 7058,
+    instrux + 7059,
+};
+
+static const struct itemplate * const itable_evex0612C[] = {
+    instrux + 7372,
+    instrux + 7373,
+    instrux + 7374,
+    instrux + 7375,
+    instrux + 7376,
+    instrux + 7377,
+};
+
+static const struct itemplate * const itable_evex0612D[] = {
+    instrux + 7378,
+    instrux + 7379,
+};
+
+static const struct itemplate * const itable_evex06142[] = {
+    instrux + 7317,
+    instrux + 7318,
+    instrux + 7319,
+};
+
+static const struct itemplate * const itable_evex06143[] = {
+    instrux + 7320,
+};
+
+static const struct itemplate * const itable_evex0614C[] = {
+    instrux + 7349,
+    instrux + 7350,
+    instrux + 7351,
+    instrux + 7352,
+    instrux + 7353,
+    instrux + 7354,
+};
+
+static const struct itemplate * const itable_evex0614D[] = {
+    instrux + 7355,
+    instrux + 7356,
+};
+
+static const struct itemplate * const itable_evex0614E[] = {
+    instrux + 7367,
+    instrux + 7368,
+    instrux + 7369,
+};
+
+static const struct itemplate * const itable_evex0614F[] = {
+    instrux + 7370,
+    instrux + 7371,
+};
+
+static const struct itemplate * const itable_evex06196[] = {
+    instrux + 7181,
+    instrux + 7182,
+    instrux + 7183,
+    instrux + 7184,
+    instrux + 7185,
+    instrux + 7186,
+};
+
+static const struct itemplate * const itable_evex06197[] = {
+    instrux + 7199,
+    instrux + 7200,
+    instrux + 7201,
+    instrux + 7202,
+    instrux + 7203,
+    instrux + 7204,
+};
+
+static const struct itemplate * const itable_evex06198[] = {
+    instrux + 7217,
+    instrux + 7218,
+    instrux + 7219,
+    instrux + 7220,
+    instrux + 7221,
+    instrux + 7222,
+};
+
+static const struct itemplate * const itable_evex06199[] = {
+    instrux + 7253,
+    instrux + 7254,
+};
+
+static const struct itemplate * const itable_evex0619A[] = {
+    instrux + 7265,
+    instrux + 7266,
+    instrux + 7267,
+    instrux + 7268,
+    instrux + 7269,
+    instrux + 7270,
+};
+
+static const struct itemplate * const itable_evex0619B[] = {
+    instrux + 7301,
+    instrux + 7302,
+};
+
+static const struct itemplate * const itable_evex0619C[] = {
+    instrux + 7235,
+    instrux + 7236,
+    instrux + 7237,
+    instrux + 7238,
+    instrux + 7239,
+    instrux + 7240,
+};
+
+static const struct itemplate * const itable_evex0619D[] = {
+    instrux + 7259,
+    instrux + 7260,
+};
+
+static const struct itemplate * const itable_evex0619E[] = {
+    instrux + 7283,
+    instrux + 7284,
+    instrux + 7285,
+    instrux + 7286,
+    instrux + 7287,
+    instrux + 7288,
+};
+
+static const struct itemplate * const itable_evex0619F[] = {
+    instrux + 7307,
+    instrux + 7308,
+};
+
+static const struct itemplate * const itable_evex061A6[] = {
+    instrux + 7187,
+    instrux + 7188,
+    instrux + 7189,
+    instrux + 7190,
+    instrux + 7191,
+    instrux + 7192,
+};
+
+static const struct itemplate * const itable_evex061A7[] = {
+    instrux + 7205,
+    instrux + 7206,
+    instrux + 7207,
+    instrux + 7208,
+    instrux + 7209,
+    instrux + 7210,
+};
+
+static const struct itemplate * const itable_evex061A8[] = {
+    instrux + 7223,
+    instrux + 7224,
+    instrux + 7225,
+    instrux + 7226,
+    instrux + 7227,
+    instrux + 7228,
+};
+
+static const struct itemplate * const itable_evex061A9[] = {
+    instrux + 7255,
+    instrux + 7256,
+};
+
+static const struct itemplate * const itable_evex061AA[] = {
+    instrux + 7271,
+    instrux + 7272,
+    instrux + 7273,
+    instrux + 7274,
+    instrux + 7275,
+    instrux + 7276,
+};
+
+static const struct itemplate * const itable_evex061AB[] = {
+    instrux + 7303,
+    instrux + 7304,
+};
+
+static const struct itemplate * const itable_evex061AC[] = {
+    instrux + 7241,
+    instrux + 7242,
+    instrux + 7243,
+    instrux + 7244,
+    instrux + 7245,
+    instrux + 7246,
+};
+
+static const struct itemplate * const itable_evex061AD[] = {
+    instrux + 7261,
+    instrux + 7262,
+};
+
+static const struct itemplate * const itable_evex061AE[] = {
+    instrux + 7289,
+    instrux + 7290,
+    instrux + 7291,
+    instrux + 7292,
+    instrux + 7293,
+    instrux + 7294,
+};
+
+static const struct itemplate * const itable_evex061AF[] = {
+    instrux + 7309,
+    instrux + 7310,
+};
+
+static const struct itemplate * const itable_evex061B6[] = {
+    instrux + 7193,
+    instrux + 7194,
+    instrux + 7195,
+    instrux + 7196,
+    instrux + 7197,
+    instrux + 7198,
+};
+
+static const struct itemplate * const itable_evex061B7[] = {
+    instrux + 7211,
+    instrux + 7212,
+    instrux + 7213,
+    instrux + 7214,
+    instrux + 7215,
+    instrux + 7216,
+};
+
+static const struct itemplate * const itable_evex061B8[] = {
+    instrux + 7229,
+    instrux + 7230,
+    instrux + 7231,
+    instrux + 7232,
+    instrux + 7233,
+    instrux + 7234,
+};
+
+static const struct itemplate * const itable_evex061B9[] = {
+    instrux + 7257,
+    instrux + 7258,
+};
+
+static const struct itemplate * const itable_evex061BA[] = {
+    instrux + 7277,
+    instrux + 7278,
+    instrux + 7279,
+    instrux + 7280,
+    instrux + 7281,
+    instrux + 7282,
+};
+
+static const struct itemplate * const itable_evex061BB[] = {
+    instrux + 7305,
+    instrux + 7306,
+};
+
+static const struct itemplate * const itable_evex061BC[] = {
+    instrux + 7247,
+    instrux + 7248,
+    instrux + 7249,
+    instrux + 7250,
+    instrux + 7251,
+    instrux + 7252,
+};
+
+static const struct itemplate * const itable_evex061BD[] = {
+    instrux + 7263,
+    instrux + 7264,
+};
+
+static const struct itemplate * const itable_evex061BE[] = {
+    instrux + 7295,
+    instrux + 7296,
+    instrux + 7297,
+    instrux + 7298,
+    instrux + 7299,
+    instrux + 7300,
+};
+
+static const struct itemplate * const itable_evex061BF[] = {
+    instrux + 7311,
+    instrux + 7312,
+};
+
+static const struct itemplate * const itable_evex06256[] = {
+    instrux + 7155,
+    instrux + 7156,
+    instrux + 7157,
+    instrux + 7158,
+    instrux + 7159,
+    instrux + 7160,
+};
+
+static const struct itemplate * const itable_evex06257[] = {
+    instrux + 7163,
+    instrux + 7164,
+};
+
+static const struct itemplate * const itable_evex062D6[] = {
+    instrux + 7171,
+    instrux + 7172,
+    instrux + 7173,
+    instrux + 7174,
+    instrux + 7175,
+    instrux + 7176,
+};
+
+static const struct itemplate * const itable_evex062D7[] = {
+    instrux + 7179,
+    instrux + 7180,
+};
+
+static const struct itemplate * const itable_evex06356[] = {
+    instrux + 7149,
+    instrux + 7150,
+    instrux + 7151,
+    instrux + 7152,
+    instrux + 7153,
+    instrux + 7154,
+};
+
+static const struct itemplate * const itable_evex06357[] = {
+    instrux + 7161,
+    instrux + 7162,
+};
+
+static const struct itemplate * const itable_evex063D6[] = {
+    instrux + 7165,
+    instrux + 7166,
+    instrux + 7167,
+    instrux + 7168,
+    instrux + 7169,
+    instrux + 7170,
+};
+
+static const struct itemplate * const itable_evex063D7[] = {
+    instrux + 7177,
+    instrux + 7178,
+};
+
+static const struct itemplate * const itable_vex01010[] = {
+    instrux + 2746,
+    instrux + 2748,
+};
+
+static const struct itemplate * const itable_vex01011[] = {
+    instrux + 2747,
+    instrux + 2749,
+};
+
+static const struct itemplate * const itable_vex01012[] = {
+    instrux + 2694,
+    instrux + 2695,
+    instrux + 2707,
+    instrux + 2708,
+};
+
+static const struct itemplate * const itable_vex01013[] = {
+    instrux + 2709,
+};
+
+static const struct itemplate * const itable_vex01014[] = {
+    instrux + 3097,
+    instrux + 3098,
+    instrux + 3099,
+    instrux + 3100,
+};
+
+static const struct itemplate * const itable_vex01015[] = {
+    instrux + 3089,
+    instrux + 3090,
+    instrux + 3091,
+    instrux + 3092,
+};
+
+static const struct itemplate * const itable_vex01016[] = {
+    instrux + 2699,
+    instrux + 2700,
+    instrux + 2702,
+    instrux + 2703,
+};
+
+static const struct itemplate * const itable_vex01017[] = {
+    instrux + 2701,
+};
+
+static const struct itemplate * const itable_vex01028[] = {
+    instrux + 2670,
+    instrux + 2672,
+};
+
+static const struct itemplate * const itable_vex01029[] = {
+    instrux + 2671,
+    instrux + 2673,
+};
+
+static const struct itemplate * const itable_vex0102B[] = {
+    instrux + 2724,
+    instrux + 2725,
+};
+
+static const struct itemplate * const itable_vex0102E[] = {
+    instrux + 3084,
+};
+
+static const struct itemplate * const itable_vex0102F[] = {
+    instrux + 2546,
+};
+
+static const struct itemplate * const itable_vex01041[] = {
+    instrux + 4111,
+    instrux + 4112,
+};
+
+static const struct itemplate * const itable_vex01042[] = {
+    instrux + 4109,
+    instrux + 4110,
+};
+
+static const struct itemplate * const itable_vex01044[] = {
+    instrux + 4131,
+    instrux + 4132,
+};
+
+static const struct itemplate * const itable_vex01045[] = {
+    instrux + 4135,
+    instrux + 4136,
+};
+
+static const struct itemplate * const itable_vex01046[] = {
+    instrux + 4158,
+    instrux + 4159,
+};
+
+static const struct itemplate * const itable_vex01047[] = {
+    instrux + 4162,
+    instrux + 4163,
+};
+
+static const struct itemplate * const itable_vex0104A[] = {
+    instrux + 4103,
+    instrux + 4104,
+};
+
+static const struct itemplate * const itable_vex0104B[] = {
+    instrux + 4154,
+    instrux + 4155,
+};
+
+static const struct itemplate * const itable_vex01050[] = {
+    instrux + 2714,
+    instrux + 2715,
+    instrux + 2716,
+    instrux + 2717,
+};
+
+static const struct itemplate * const itable_vex01051[] = {
+    instrux + 3060,
+    instrux + 3061,
+};
+
+static const struct itemplate * const itable_vex01052[] = {
+    instrux + 3038,
+    instrux + 3039,
+};
+
+static const struct itemplate * const itable_vex01053[] = {
+    instrux + 3034,
+    instrux + 3035,
+};
+
+static const struct itemplate * const itable_vex01054[] = {
+    instrux + 1949,
+    instrux + 1950,
+    instrux + 1951,
+    instrux + 1952,
+};
+
+static const struct itemplate * const itable_vex01055[] = {
+    instrux + 1957,
+    instrux + 1958,
+    instrux + 1959,
+    instrux + 1960,
+};
+
+static const struct itemplate * const itable_vex01056[] = {
+    instrux + 2768,
+    instrux + 2769,
+    instrux + 2770,
+    instrux + 2771,
+};
+
+static const struct itemplate * const itable_vex01057[] = {
+    instrux + 3105,
+    instrux + 3106,
+    instrux + 3107,
+    instrux + 3108,
+};
+
+static const struct itemplate * const itable_vex01058[] = {
+    instrux + 1929,
+    instrux + 1930,
+    instrux + 1931,
+    instrux + 1932,
+};
+
+static const struct itemplate * const itable_vex01059[] = {
+    instrux + 2756,
+    instrux + 2757,
+    instrux + 2758,
+    instrux + 2759,
+};
+
+static const struct itemplate * const itable_vex0105A[] = {
+    instrux + 2561,
+    instrux + 2562,
+};
+
+static const struct itemplate * const itable_vex0105B[] = {
+    instrux + 2549,
+    instrux + 2550,
+};
+
+static const struct itemplate * const itable_vex0105C[] = {
+    instrux + 3071,
+    instrux + 3072,
+    instrux + 3073,
+    instrux + 3074,
+};
+
+static const struct itemplate * const itable_vex0105D[] = {
+    instrux + 2658,
+    instrux + 2659,
+    instrux + 2660,
+    instrux + 2661,
+};
+
+static const struct itemplate * const itable_vex0105E[] = {
+    instrux + 2593,
+    instrux + 2594,
+    instrux + 2595,
+    instrux + 2596,
+};
+
+static const struct itemplate * const itable_vex0105F[] = {
+    instrux + 2646,
+    instrux + 2647,
+    instrux + 2648,
+    instrux + 2649,
+};
+
+static const struct itemplate * const itable_vex01077[] = {
+    instrux + 3109,
+    instrux + 3110,
+};
+
+static const struct itemplate * const itable_vex01090[] = {
+    instrux + 4121,
+    instrux + 4125,
+};
+
+static const struct itemplate * const itable_vex01091[] = {
+    instrux + 4122,
+    instrux + 4126,
+};
+
+static const struct itemplate * const itable_vex01092[] = {
+    instrux + 4127,
+};
+
+static const struct itemplate * const itable_vex01093[] = {
+    instrux + 4128,
+};
+
+static const struct itemplate * const itable_vex01098[] = {
+    instrux + 4139,
+    instrux + 4140,
+};
+
+static const struct itemplate * const itable_vex01099[] = {
+    instrux + 4151,
+    instrux + 4152,
+};
+
+static const struct itemplate * const itable_vex010AE[] = {
+    instrux + 2632,
+    instrux + 3066,
+};
+
+static const struct itemplate * const itable_vex010C2[] = {
+    instrux + 2169,
+    instrux + 2170,
+    instrux + 2171,
+    instrux + 2172,
+    instrux + 2173,
+    instrux + 2174,
+    instrux + 2175,
+    instrux + 2176,
+    instrux + 2177,
+    instrux + 2178,
+    instrux + 2179,
+    instrux + 2180,
+    instrux + 2181,
+    instrux + 2182,
+    instrux + 2183,
+    instrux + 2184,
+    instrux + 2185,
+    instrux + 2186,
+    instrux + 2187,
+    instrux + 2188,
+    instrux + 2189,
+    instrux + 2190,
+    instrux + 2191,
+    instrux + 2192,
+    instrux + 2193,
+    instrux + 2194,
+    instrux + 2195,
+    instrux + 2196,
+    instrux + 2197,
+    instrux + 2198,
+    instrux + 2199,
+    instrux + 2200,
+    instrux + 2201,
+    instrux + 2202,
+    instrux + 2203,
+    instrux + 2204,
+    instrux + 2205,
+    instrux + 2206,
+    instrux + 2207,
+    instrux + 2208,
+    instrux + 2209,
+    instrux + 2210,
+    instrux + 2211,
+    instrux + 2212,
+    instrux + 2213,
+    instrux + 2214,
+    instrux + 2215,
+    instrux + 2216,
+    instrux + 2217,
+    instrux + 2218,
+    instrux + 2219,
+    instrux + 2220,
+    instrux + 2221,
+    instrux + 2222,
+    instrux + 2223,
+    instrux + 2224,
+    instrux + 2225,
+    instrux + 2226,
+    instrux + 2227,
+    instrux + 2228,
+    instrux + 2229,
+    instrux + 2230,
+    instrux + 2231,
+    instrux + 2232,
+    instrux + 2233,
+    instrux + 2234,
+    instrux + 2235,
+    instrux + 2236,
+    instrux + 2237,
+    instrux + 2238,
+    instrux + 2239,
+    instrux + 2240,
+    instrux + 2241,
+    instrux + 2242,
+    instrux + 2243,
+    instrux + 2244,
+    instrux + 2245,
+    instrux + 2246,
+    instrux + 2247,
+    instrux + 2248,
+    instrux + 2249,
+    instrux + 2250,
+    instrux + 2251,
+    instrux + 2252,
+    instrux + 2253,
+    instrux + 2254,
+    instrux + 2255,
+    instrux + 2256,
+    instrux + 2257,
+    instrux + 2258,
+    instrux + 2259,
+    instrux + 2260,
+    instrux + 2261,
+    instrux + 2262,
+    instrux + 2263,
+    instrux + 2264,
+    instrux + 2265,
+    instrux + 2266,
+    instrux + 2267,
+    instrux + 2268,
+    instrux + 2269,
+    instrux + 2270,
+    instrux + 2271,
+    instrux + 2272,
+    instrux + 2273,
+    instrux + 2274,
+    instrux + 2275,
+    instrux + 2276,
+    instrux + 2277,
+    instrux + 2278,
+    instrux + 2279,
+    instrux + 2280,
+    instrux + 2281,
+    instrux + 2282,
+    instrux + 2283,
+    instrux + 2284,
+    instrux + 2285,
+    instrux + 2286,
+    instrux + 2287,
+    instrux + 2288,
+    instrux + 2289,
+    instrux + 2290,
+    instrux + 2291,
+    instrux + 2292,
+    instrux + 2293,
+    instrux + 2294,
+    instrux + 2295,
+    instrux + 2296,
+    instrux + 2297,
+    instrux + 2298,
+    instrux + 2299,
+    instrux + 2300,
+    instrux + 2301,
+    instrux + 2302,
+    instrux + 2303,
+    instrux + 2304,
+    instrux + 2305,
+    instrux + 2306,
+    instrux + 2307,
+    instrux + 2308,
+    instrux + 2309,
+    instrux + 2310,
+    instrux + 2311,
+    instrux + 2312,
+    instrux + 2313,
+    instrux + 2314,
+    instrux + 2315,
+    instrux + 2316,
+    instrux + 2317,
+    instrux + 2318,
+    instrux + 2319,
+    instrux + 2320,
+    instrux + 2321,
+    instrux + 2322,
+    instrux + 2323,
+    instrux + 2324,
+    instrux + 2325,
+    instrux + 2326,
+    instrux + 2327,
+    instrux + 2328,
+    instrux + 2329,
+    instrux + 2330,
+    instrux + 2331,
+    instrux + 2332,
+    instrux + 2333,
+    instrux + 2334,
+    instrux + 2335,
+    instrux + 2336,
+    instrux + 2337,
+    instrux + 2338,
+    instrux + 2339,
+    instrux + 2340,
+    instrux + 2341,
+    instrux + 2342,
+    instrux + 2343,
+    instrux + 2344,
+    instrux + 2345,
+    instrux + 2346,
+    instrux + 2347,
+    instrux + 2348,
+    instrux + 2349,
+    instrux + 2350,
+    instrux + 2351,
+    instrux + 2352,
+    instrux + 2353,
+    instrux + 2354,
+    instrux + 2355,
+    instrux + 2356,
+};
+
+static const struct itemplate * const itable_vex010C6[] = {
+    instrux + 3054,
+    instrux + 3055,
+    instrux + 3056,
+    instrux + 3057,
+};
+
+static const struct itemplate * const itable_vex01110[] = {
+    instrux + 2742,
+    instrux + 2744,
+};
+
+static const struct itemplate * const itable_vex01111[] = {
+    instrux + 2743,
+    instrux + 2745,
+};
+
+static const struct itemplate * const itable_vex01112[] = {
+    instrux + 2704,
+    instrux + 2705,
+};
+
+static const struct itemplate * const itable_vex01113[] = {
+    instrux + 2706,
+};
+
+static const struct itemplate * const itable_vex01114[] = {
+    instrux + 3093,
+    instrux + 3094,
+    instrux + 3095,
+    instrux + 3096,
+};
+
+static const struct itemplate * const itable_vex01115[] = {
+    instrux + 3085,
+    instrux + 3086,
+    instrux + 3087,
+    instrux + 3088,
+};
+
+static const struct itemplate * const itable_vex01116[] = {
+    instrux + 2696,
+    instrux + 2697,
+};
+
+static const struct itemplate * const itable_vex01117[] = {
+    instrux + 2698,
+};
+
+static const struct itemplate * const itable_vex01128[] = {
+    instrux + 2666,
+    instrux + 2668,
+};
+
+static const struct itemplate * const itable_vex01129[] = {
+    instrux + 2667,
+    instrux + 2669,
+};
+
+static const struct itemplate * const itable_vex0112B[] = {
+    instrux + 2722,
+    instrux + 2723,
+};
+
+static const struct itemplate * const itable_vex0112E[] = {
+    instrux + 3083,
+};
+
+static const struct itemplate * const itable_vex0112F[] = {
+    instrux + 2545,
+};
+
+static const struct itemplate * const itable_vex01141[] = {
+    instrux + 4105,
+    instrux + 4106,
+};
+
+static const struct itemplate * const itable_vex01142[] = {
+    instrux + 4107,
+    instrux + 4108,
+};
+
+static const struct itemplate * const itable_vex01144[] = {
+    instrux + 4129,
+    instrux + 4130,
+};
+
+static const struct itemplate * const itable_vex01145[] = {
+    instrux + 4133,
+    instrux + 4134,
+};
+
+static const struct itemplate * const itable_vex01146[] = {
+    instrux + 4156,
+    instrux + 4157,
+};
+
+static const struct itemplate * const itable_vex01147[] = {
+    instrux + 4160,
+    instrux + 4161,
+};
+
+static const struct itemplate * const itable_vex0114A[] = {
+    instrux + 4101,
+    instrux + 4102,
+};
+
+static const struct itemplate * const itable_vex0114B[] = {
+    instrux + 4153,
+};
+
+static const struct itemplate * const itable_vex01150[] = {
+    instrux + 2710,
+    instrux + 2711,
+    instrux + 2712,
+    instrux + 2713,
+};
+
+static const struct itemplate * const itable_vex01151[] = {
+    instrux + 3058,
+    instrux + 3059,
+};
+
+static const struct itemplate * const itable_vex01154[] = {
+    instrux + 1945,
+    instrux + 1946,
+    instrux + 1947,
+    instrux + 1948,
+};
+
+static const struct itemplate * const itable_vex01155[] = {
+    instrux + 1953,
+    instrux + 1954,
+    instrux + 1955,
+    instrux + 1956,
+};
+
+static const struct itemplate * const itable_vex01156[] = {
+    instrux + 2764,
+    instrux + 2765,
+    instrux + 2766,
+    instrux + 2767,
+};
+
+static const struct itemplate * const itable_vex01157[] = {
+    instrux + 3101,
+    instrux + 3102,
+    instrux + 3103,
+    instrux + 3104,
+};
+
+static const struct itemplate * const itable_vex01158[] = {
+    instrux + 1925,
+    instrux + 1926,
+    instrux + 1927,
+    instrux + 1928,
+};
+
+static const struct itemplate * const itable_vex01159[] = {
+    instrux + 2752,
+    instrux + 2753,
+    instrux + 2754,
+    instrux + 2755,
+};
+
+static const struct itemplate * const itable_vex0115A[] = {
+    instrux + 2555,
+    instrux + 2556,
+    instrux + 2557,
+    instrux + 2558,
+};
+
+static const struct itemplate * const itable_vex0115B[] = {
+    instrux + 2559,
+    instrux + 2560,
+};
+
+static const struct itemplate * const itable_vex0115C[] = {
+    instrux + 3067,
+    instrux + 3068,
+    instrux + 3069,
+    instrux + 3070,
+};
+
+static const struct itemplate * const itable_vex0115D[] = {
+    instrux + 2654,
+    instrux + 2655,
+    instrux + 2656,
+    instrux + 2657,
+};
+
+static const struct itemplate * const itable_vex0115E[] = {
+    instrux + 2589,
+    instrux + 2590,
+    instrux + 2591,
+    instrux + 2592,
+};
+
+static const struct itemplate * const itable_vex0115F[] = {
+    instrux + 2642,
+    instrux + 2643,
+    instrux + 2644,
+    instrux + 2645,
+};
+
+static const struct itemplate * const itable_vex01160[] = {
+    instrux + 3024,
+    instrux + 3025,
+    instrux + 3885,
+    instrux + 3886,
+};
+
+static const struct itemplate * const itable_vex01161[] = {
+    instrux + 3026,
+    instrux + 3027,
+    instrux + 3887,
+    instrux + 3888,
+};
+
+static const struct itemplate * const itable_vex01162[] = {
+    instrux + 3028,
+    instrux + 3029,
+    instrux + 3889,
+    instrux + 3890,
+};
+
+static const struct itemplate * const itable_vex01163[] = {
+    instrux + 2775,
+    instrux + 2776,
+    instrux + 3682,
+    instrux + 3683,
+};
+
+static const struct itemplate * const itable_vex01164[] = {
+    instrux + 2825,
+    instrux + 2826,
+    instrux + 3728,
+    instrux + 3729,
+};
+
+static const struct itemplate * const itable_vex01165[] = {
+    instrux + 2827,
+    instrux + 2828,
+    instrux + 3730,
+    instrux + 3731,
+};
+
+static const struct itemplate * const itable_vex01166[] = {
+    instrux + 2829,
+    instrux + 2830,
+    instrux + 3732,
+    instrux + 3733,
+};
+
+static const struct itemplate * const itable_vex01167[] = {
+    instrux + 2779,
+    instrux + 2780,
+    instrux + 3688,
+    instrux + 3689,
+};
+
+static const struct itemplate * const itable_vex01168[] = {
+    instrux + 3016,
+    instrux + 3017,
+    instrux + 3877,
+    instrux + 3878,
+};
+
+static const struct itemplate * const itable_vex01169[] = {
+    instrux + 3018,
+    instrux + 3019,
+    instrux + 3879,
+    instrux + 3880,
+};
+
+static const struct itemplate * const itable_vex0116A[] = {
+    instrux + 3020,
+    instrux + 3021,
+    instrux + 3881,
+    instrux + 3882,
+};
+
+static const struct itemplate * const itable_vex0116B[] = {
+    instrux + 2777,
+    instrux + 2778,
+    instrux + 3684,
+    instrux + 3685,
+};
+
+static const struct itemplate * const itable_vex0116C[] = {
+    instrux + 3030,
+    instrux + 3031,
+    instrux + 3891,
+    instrux + 3892,
+};
+
+static const struct itemplate * const itable_vex0116D[] = {
+    instrux + 3022,
+    instrux + 3023,
+    instrux + 3883,
+    instrux + 3884,
+};
+
+static const struct itemplate * const itable_vex0116E[] = {
+    instrux + 2674,
+    instrux + 2678,
+};
+
+static const struct itemplate * const itable_vex0116F[] = {
+    instrux + 2682,
+    instrux + 2684,
+    instrux + 2686,
+};
+
+static const struct itemplate * const itable_vex01170[] = {
+    instrux + 2953,
+    instrux + 3816,
+};
+
+static const struct itemplate * const itable_vex01171[] = {
+    instrux + 2968,
+    instrux + 2969,
+    instrux + 2980,
+    instrux + 2981,
+    instrux + 2988,
+    instrux + 2989,
+    instrux + 3829,
+    instrux + 3830,
+    instrux + 3841,
+    instrux + 3842,
+    instrux + 3851,
+    instrux + 3852,
+};
+
+static const struct itemplate * const itable_vex01172[] = {
+    instrux + 2972,
+    instrux + 2973,
+    instrux + 2984,
+    instrux + 2985,
+    instrux + 2992,
+    instrux + 2993,
+    instrux + 3833,
+    instrux + 3834,
+    instrux + 3845,
+    instrux + 3846,
+    instrux + 3855,
+    instrux + 3856,
+};
+
+static const struct itemplate * const itable_vex01173[] = {
+    instrux + 2962,
+    instrux + 2963,
+    instrux + 2964,
+    instrux + 2965,
+    instrux + 2976,
+    instrux + 2977,
+    instrux + 2996,
+    instrux + 2997,
+    instrux + 3825,
+    instrux + 3826,
+    instrux + 3837,
+    instrux + 3838,
+    instrux + 3847,
+    instrux + 3848,
+    instrux + 3859,
+    instrux + 3860,
+};
+
+static const struct itemplate * const itable_vex01174[] = {
+    instrux + 2817,
+    instrux + 2818,
+    instrux + 3720,
+    instrux + 3721,
+};
+
+static const struct itemplate * const itable_vex01175[] = {
+    instrux + 2819,
+    instrux + 2820,
+    instrux + 3722,
+    instrux + 3723,
+};
+
+static const struct itemplate * const itable_vex01176[] = {
+    instrux + 2821,
+    instrux + 2822,
+    instrux + 3724,
+    instrux + 3725,
+};
+
+static const struct itemplate * const itable_vex0117C[] = {
+    instrux + 2609,
+    instrux + 2610,
+    instrux + 2611,
+    instrux + 2612,
+};
+
+static const struct itemplate * const itable_vex0117D[] = {
+    instrux + 2617,
+    instrux + 2618,
+    instrux + 2619,
+    instrux + 2620,
+};
+
+static const struct itemplate * const itable_vex0117E[] = {
+    instrux + 2675,
+    instrux + 2679,
+};
+
+static const struct itemplate * const itable_vex0117F[] = {
+    instrux + 2683,
+    instrux + 2685,
+    instrux + 2687,
+};
+
+static const struct itemplate * const itable_vex01190[] = {
+    instrux + 4113,
+    instrux + 4117,
+};
+
+static const struct itemplate * const itable_vex01191[] = {
+    instrux + 4114,
+    instrux + 4118,
+};
+
+static const struct itemplate * const itable_vex01192[] = {
+    instrux + 4115,
+};
+
+static const struct itemplate * const itable_vex01193[] = {
+    instrux + 4116,
+};
+
+static const struct itemplate * const itable_vex01198[] = {
+    instrux + 4137,
+    instrux + 4138,
+};
+
+static const struct itemplate * const itable_vex01199[] = {
+    instrux + 4149,
+    instrux + 4150,
+};
+
+static const struct itemplate * const itable_vex011C2[] = {
+    instrux + 1981,
+    instrux + 1982,
+    instrux + 1983,
+    instrux + 1984,
+    instrux + 1985,
+    instrux + 1986,
+    instrux + 1987,
+    instrux + 1988,
+    instrux + 1989,
+    instrux + 1990,
+    instrux + 1991,
+    instrux + 1992,
+    instrux + 1993,
+    instrux + 1994,
+    instrux + 1995,
+    instrux + 1996,
+    instrux + 1997,
+    instrux + 1998,
+    instrux + 1999,
+    instrux + 2000,
+    instrux + 2001,
+    instrux + 2002,
+    instrux + 2003,
+    instrux + 2004,
+    instrux + 2005,
+    instrux + 2006,
+    instrux + 2007,
+    instrux + 2008,
+    instrux + 2009,
+    instrux + 2010,
+    instrux + 2011,
+    instrux + 2012,
+    instrux + 2013,
+    instrux + 2014,
+    instrux + 2015,
+    instrux + 2016,
+    instrux + 2017,
+    instrux + 2018,
+    instrux + 2019,
+    instrux + 2020,
+    instrux + 2021,
+    instrux + 2022,
+    instrux + 2023,
+    instrux + 2024,
+    instrux + 2025,
+    instrux + 2026,
+    instrux + 2027,
+    instrux + 2028,
+    instrux + 2029,
+    instrux + 2030,
+    instrux + 2031,
+    instrux + 2032,
+    instrux + 2033,
+    instrux + 2034,
+    instrux + 2035,
+    instrux + 2036,
+    instrux + 2037,
+    instrux + 2038,
+    instrux + 2039,
+    instrux + 2040,
+    instrux + 2041,
+    instrux + 2042,
+    instrux + 2043,
+    instrux + 2044,
+    instrux + 2045,
+    instrux + 2046,
+    instrux + 2047,
+    instrux + 2048,
+    instrux + 2049,
+    instrux + 2050,
+    instrux + 2051,
+    instrux + 2052,
+    instrux + 2053,
+    instrux + 2054,
+    instrux + 2055,
+    instrux + 2056,
+    instrux + 2057,
+    instrux + 2058,
+    instrux + 2059,
+    instrux + 2060,
+    instrux + 2061,
+    instrux + 2062,
+    instrux + 2063,
+    instrux + 2064,
+    instrux + 2065,
+    instrux + 2066,
+    instrux + 2067,
+    instrux + 2068,
+    instrux + 2069,
+    instrux + 2070,
+    instrux + 2071,
+    instrux + 2072,
+    instrux + 2073,
+    instrux + 2074,
+    instrux + 2075,
+    instrux + 2076,
+    instrux + 2077,
+    instrux + 2078,
+    instrux + 2079,
+    instrux + 2080,
+    instrux + 2081,
+    instrux + 2082,
+    instrux + 2083,
+    instrux + 2084,
+    instrux + 2085,
+    instrux + 2086,
+    instrux + 2087,
+    instrux + 2088,
+    instrux + 2089,
+    instrux + 2090,
+    instrux + 2091,
+    instrux + 2092,
+    instrux + 2093,
+    instrux + 2094,
+    instrux + 2095,
+    instrux + 2096,
+    instrux + 2097,
+    instrux + 2098,
+    instrux + 2099,
+    instrux + 2100,
+    instrux + 2101,
+    instrux + 2102,
+    instrux + 2103,
+    instrux + 2104,
+    instrux + 2105,
+    instrux + 2106,
+    instrux + 2107,
+    instrux + 2108,
+    instrux + 2109,
+    instrux + 2110,
+    instrux + 2111,
+    instrux + 2112,
+    instrux + 2113,
+    instrux + 2114,
+    instrux + 2115,
+    instrux + 2116,
+    instrux + 2117,
+    instrux + 2118,
+    instrux + 2119,
+    instrux + 2120,
+    instrux + 2121,
+    instrux + 2122,
+    instrux + 2123,
+    instrux + 2124,
+    instrux + 2125,
+    instrux + 2126,
+    instrux + 2127,
+    instrux + 2128,
+    instrux + 2129,
+    instrux + 2130,
+    instrux + 2131,
+    instrux + 2132,
+    instrux + 2133,
+    instrux + 2134,
+    instrux + 2135,
+    instrux + 2136,
+    instrux + 2137,
+    instrux + 2138,
+    instrux + 2139,
+    instrux + 2140,
+    instrux + 2141,
+    instrux + 2142,
+    instrux + 2143,
+    instrux + 2144,
+    instrux + 2145,
+    instrux + 2146,
+    instrux + 2147,
+    instrux + 2148,
+    instrux + 2149,
+    instrux + 2150,
+    instrux + 2151,
+    instrux + 2152,
+    instrux + 2153,
+    instrux + 2154,
+    instrux + 2155,
+    instrux + 2156,
+    instrux + 2157,
+    instrux + 2158,
+    instrux + 2159,
+    instrux + 2160,
+    instrux + 2161,
+    instrux + 2162,
+    instrux + 2163,
+    instrux + 2164,
+    instrux + 2165,
+    instrux + 2166,
+    instrux + 2167,
+    instrux + 2168,
+};
+
+static const struct itemplate * const itable_vex011C4[] = {
+    instrux + 2877,
+    instrux + 2878,
+    instrux + 2879,
+    instrux + 2880,
+    instrux + 2881,
+    instrux + 2882,
+};
+
+static const struct itemplate * const itable_vex011C5[] = {
+    instrux + 2850,
+    instrux + 2851,
+};
+
+static const struct itemplate * const itable_vex011C6[] = {
+    instrux + 3050,
+    instrux + 3051,
+    instrux + 3052,
+    instrux + 3053,
+};
+
+static const struct itemplate * const itable_vex011D0[] = {
+    instrux + 1937,
+    instrux + 1938,
+    instrux + 1939,
+    instrux + 1940,
+};
+
+static const struct itemplate * const itable_vex011D1[] = {
+    instrux + 2986,
+    instrux + 2987,
+    instrux + 3849,
+    instrux + 3850,
+};
+
+static const struct itemplate * const itable_vex011D2[] = {
+    instrux + 2990,
+    instrux + 2991,
+    instrux + 3853,
+    instrux + 3854,
+};
+
+static const struct itemplate * const itable_vex011D3[] = {
+    instrux + 2994,
+    instrux + 2995,
+    instrux + 3857,
+    instrux + 3858,
+};
+
+static const struct itemplate * const itable_vex011D4[] = {
+    instrux + 2789,
+    instrux + 2790,
+    instrux + 3696,
+    instrux + 3697,
+};
+
+static const struct itemplate * const itable_vex011D5[] = {
+    instrux + 2939,
+    instrux + 2940,
+    instrux + 3804,
+    instrux + 3805,
+};
+
+static const struct itemplate * const itable_vex011D6[] = {
+    instrux + 2677,
+};
+
+static const struct itemplate * const itable_vex011D7[] = {
+    instrux + 2919,
+    instrux + 2920,
+    instrux + 3776,
+    instrux + 3777,
+};
+
+static const struct itemplate * const itable_vex011D8[] = {
+    instrux + 3012,
+    instrux + 3013,
+    instrux + 3873,
+    instrux + 3874,
+};
+
+static const struct itemplate * const itable_vex011D9[] = {
+    instrux + 3014,
+    instrux + 3015,
+    instrux + 3875,
+    instrux + 3876,
+};
+
+static const struct itemplate * const itable_vex011DA[] = {
+    instrux + 2913,
+    instrux + 2914,
+    instrux + 3770,
+    instrux + 3771,
+};
+
+static const struct itemplate * const itable_vex011DB[] = {
+    instrux + 2801,
+    instrux + 2802,
+    instrux + 3708,
+    instrux + 3709,
+};
+
+static const struct itemplate * const itable_vex011DC[] = {
+    instrux + 2795,
+    instrux + 2796,
+    instrux + 3702,
+    instrux + 3703,
+};
+
+static const struct itemplate * const itable_vex011DD[] = {
+    instrux + 2797,
+    instrux + 2798,
+    instrux + 3704,
+    instrux + 3705,
+};
+
+static const struct itemplate * const itable_vex011DE[] = {
+    instrux + 2901,
+    instrux + 2902,
+    instrux + 3758,
+    instrux + 3759,
+};
+
+static const struct itemplate * const itable_vex011DF[] = {
+    instrux + 2803,
+    instrux + 2804,
+    instrux + 3710,
+    instrux + 3711,
+};
+
+static const struct itemplate * const itable_vex011E0[] = {
+    instrux + 2805,
+    instrux + 2806,
+    instrux + 3712,
+    instrux + 3713,
+};
+
+static const struct itemplate * const itable_vex011E1[] = {
+    instrux + 2978,
+    instrux + 2979,
+    instrux + 3839,
+    instrux + 3840,
+};
+
+static const struct itemplate * const itable_vex011E2[] = {
+    instrux + 2982,
+    instrux + 2983,
+    instrux + 3843,
+    instrux + 3844,
+};
+
+static const struct itemplate * const itable_vex011E3[] = {
+    instrux + 2807,
+    instrux + 2808,
+    instrux + 3714,
+    instrux + 3715,
+};
+
+static const struct itemplate * const itable_vex011E4[] = {
+    instrux + 2933,
+    instrux + 2934,
+    instrux + 3800,
+    instrux + 3801,
+};
+
+static const struct itemplate * const itable_vex011E5[] = {
+    instrux + 2937,
+    instrux + 2938,
+    instrux + 3802,
+    instrux + 3803,
+};
+
+static const struct itemplate * const itable_vex011E6[] = {
+    instrux + 2579,
+    instrux + 2580,
+    instrux + 2581,
+    instrux + 2582,
+};
+
+static const struct itemplate * const itable_vex011E7[] = {
+    instrux + 2718,
+    instrux + 2719,
+    instrux + 2720,
+};
+
+static const struct itemplate * const itable_vex011E8[] = {
+    instrux + 3008,
+    instrux + 3009,
+    instrux + 3869,
+    instrux + 3870,
+};
+
+static const struct itemplate * const itable_vex011E9[] = {
+    instrux + 3010,
+    instrux + 3011,
+    instrux + 3871,
+    instrux + 3872,
+};
+
+static const struct itemplate * const itable_vex011EA[] = {
+    instrux + 2909,
+    instrux + 2910,
+    instrux + 3766,
+    instrux + 3767,
+};
+
+static const struct itemplate * const itable_vex011EB[] = {
+    instrux + 2947,
+    instrux + 2948,
+    instrux + 3810,
+    instrux + 3811,
+};
+
+static const struct itemplate * const itable_vex011EC[] = {
+    instrux + 2791,
+    instrux + 2792,
+    instrux + 3698,
+    instrux + 3699,
+};
+
+static const struct itemplate * const itable_vex011ED[] = {
+    instrux + 2793,
+    instrux + 2794,
+    instrux + 3700,
+    instrux + 3701,
+};
+
+static const struct itemplate * const itable_vex011EE[] = {
+    instrux + 2897,
+    instrux + 2898,
+    instrux + 3754,
+    instrux + 3755,
+};
+
+static const struct itemplate * const itable_vex011EF[] = {
+    instrux + 3032,
+    instrux + 3033,
+    instrux + 3893,
+    instrux + 3894,
+};
+
+static const struct itemplate * const itable_vex011F1[] = {
+    instrux + 2966,
+    instrux + 2967,
+    instrux + 3827,
+    instrux + 3828,
+};
+
+static const struct itemplate * const itable_vex011F2[] = {
+    instrux + 2970,
+    instrux + 2971,
+    instrux + 3831,
+    instrux + 3832,
+};
+
+static const struct itemplate * const itable_vex011F3[] = {
+    instrux + 2974,
+    instrux + 2975,
+    instrux + 3835,
+    instrux + 3836,
+};
+
+static const struct itemplate * const itable_vex011F4[] = {
+    instrux + 2943,
+    instrux + 2944,
+    instrux + 3808,
+    instrux + 3809,
+};
+
+static const struct itemplate * const itable_vex011F5[] = {
+    instrux + 2891,
+    instrux + 2892,
+    instrux + 3750,
+    instrux + 3751,
+};
+
+static const struct itemplate * const itable_vex011F6[] = {
+    instrux + 2949,
+    instrux + 2950,
+    instrux + 3812,
+    instrux + 3813,
+};
+
+static const struct itemplate * const itable_vex011F7[] = {
+    instrux + 2633,
+};
+
+static const struct itemplate * const itable_vex011F8[] = {
+    instrux + 3000,
+    instrux + 3001,
+    instrux + 3861,
+    instrux + 3862,
+};
+
+static const struct itemplate * const itable_vex011F9[] = {
+    instrux + 3002,
+    instrux + 3003,
+    instrux + 3863,
+    instrux + 3864,
+};
+
+static const struct itemplate * const itable_vex011FA[] = {
+    instrux + 3004,
+    instrux + 3005,
+    instrux + 3865,
+    instrux + 3866,
+};
+
+static const struct itemplate * const itable_vex011FB[] = {
+    instrux + 3006,
+    instrux + 3007,
+    instrux + 3867,
+    instrux + 3868,
+};
+
+static const struct itemplate * const itable_vex011FC[] = {
+    instrux + 2783,
+    instrux + 2784,
+    instrux + 3690,
+    instrux + 3691,
+};
+
+static const struct itemplate * const itable_vex011FD[] = {
+    instrux + 2785,
+    instrux + 2786,
+    instrux + 3692,
+    instrux + 3693,
+};
+
+static const struct itemplate * const itable_vex011FE[] = {
+    instrux + 2787,
+    instrux + 2788,
+    instrux + 3694,
+    instrux + 3695,
+};
+
+static const struct itemplate * const itable_vex01210[] = {
+    instrux + 2736,
+    instrux + 2737,
+    instrux + 2738,
+};
+
+static const struct itemplate * const itable_vex01211[] = {
+    instrux + 2739,
+    instrux + 2740,
+    instrux + 2741,
+};
+
+static const struct itemplate * const itable_vex01212[] = {
+    instrux + 2734,
+    instrux + 2735,
+};
+
+static const struct itemplate * const itable_vex01216[] = {
+    instrux + 2732,
+    instrux + 2733,
+};
+
+static const struct itemplate * const itable_vex0122A[] = {
+    instrux + 2571,
+    instrux + 2572,
+    instrux + 2573,
+    instrux + 2574,
+};
+
+static const struct itemplate * const itable_vex0122C[] = {
+    instrux + 2587,
+    instrux + 2588,
+};
+
+static const struct itemplate * const itable_vex0122D[] = {
+    instrux + 2577,
+    instrux + 2578,
+};
+
+static const struct itemplate * const itable_vex01251[] = {
+    instrux + 3064,
+    instrux + 3065,
+};
+
+static const struct itemplate * const itable_vex01252[] = {
+    instrux + 3040,
+    instrux + 3041,
+};
+
+static const struct itemplate * const itable_vex01253[] = {
+    instrux + 3036,
+    instrux + 3037,
+};
+
+static const struct itemplate * const itable_vex01258[] = {
+    instrux + 1935,
+    instrux + 1936,
+};
+
+static const struct itemplate * const itable_vex01259[] = {
+    instrux + 2762,
+    instrux + 2763,
+};
+
+static const struct itemplate * const itable_vex0125A[] = {
+    instrux + 2575,
+    instrux + 2576,
+};
+
+static const struct itemplate * const itable_vex0125B[] = {
+    instrux + 2583,
+    instrux + 2584,
+};
+
+static const struct itemplate * const itable_vex0125C[] = {
+    instrux + 3077,
+    instrux + 3078,
+};
+
+static const struct itemplate * const itable_vex0125D[] = {
+    instrux + 2664,
+    instrux + 2665,
+};
+
+static const struct itemplate * const itable_vex0125E[] = {
+    instrux + 2599,
+    instrux + 2600,
+};
+
+static const struct itemplate * const itable_vex0125F[] = {
+    instrux + 2652,
+    instrux + 2653,
+};
+
+static const struct itemplate * const itable_vex0126F[] = {
+    instrux + 2688,
+    instrux + 2690,
+    instrux + 2692,
+};
+
+static const struct itemplate * const itable_vex01270[] = {
+    instrux + 2954,
+    instrux + 3817,
+};
+
+static const struct itemplate * const itable_vex0127E[] = {
+    instrux + 2676,
+};
+
+static const struct itemplate * const itable_vex0127F[] = {
+    instrux + 2689,
+    instrux + 2691,
+    instrux + 2693,
+};
+
+static const struct itemplate * const itable_vex012C2[] = {
+    instrux + 2451,
+    instrux + 2452,
+    instrux + 2453,
+    instrux + 2454,
+    instrux + 2455,
+    instrux + 2456,
+    instrux + 2457,
+    instrux + 2458,
+    instrux + 2459,
+    instrux + 2460,
+    instrux + 2461,
+    instrux + 2462,
+    instrux + 2463,
+    instrux + 2464,
+    instrux + 2465,
+    instrux + 2466,
+    instrux + 2467,
+    instrux + 2468,
+    instrux + 2469,
+    instrux + 2470,
+    instrux + 2471,
+    instrux + 2472,
+    instrux + 2473,
+    instrux + 2474,
+    instrux + 2475,
+    instrux + 2476,
+    instrux + 2477,
+    instrux + 2478,
+    instrux + 2479,
+    instrux + 2480,
+    instrux + 2481,
+    instrux + 2482,
+    instrux + 2483,
+    instrux + 2484,
+    instrux + 2485,
+    instrux + 2486,
+    instrux + 2487,
+    instrux + 2488,
+    instrux + 2489,
+    instrux + 2490,
+    instrux + 2491,
+    instrux + 2492,
+    instrux + 2493,
+    instrux + 2494,
+    instrux + 2495,
+    instrux + 2496,
+    instrux + 2497,
+    instrux + 2498,
+    instrux + 2499,
+    instrux + 2500,
+    instrux + 2501,
+    instrux + 2502,
+    instrux + 2503,
+    instrux + 2504,
+    instrux + 2505,
+    instrux + 2506,
+    instrux + 2507,
+    instrux + 2508,
+    instrux + 2509,
+    instrux + 2510,
+    instrux + 2511,
+    instrux + 2512,
+    instrux + 2513,
+    instrux + 2514,
+    instrux + 2515,
+    instrux + 2516,
+    instrux + 2517,
+    instrux + 2518,
+    instrux + 2519,
+    instrux + 2520,
+    instrux + 2521,
+    instrux + 2522,
+    instrux + 2523,
+    instrux + 2524,
+    instrux + 2525,
+    instrux + 2526,
+    instrux + 2527,
+    instrux + 2528,
+    instrux + 2529,
+    instrux + 2530,
+    instrux + 2531,
+    instrux + 2532,
+    instrux + 2533,
+    instrux + 2534,
+    instrux + 2535,
+    instrux + 2536,
+    instrux + 2537,
+    instrux + 2538,
+    instrux + 2539,
+    instrux + 2540,
+    instrux + 2541,
+    instrux + 2542,
+    instrux + 2543,
+    instrux + 2544,
+};
+
+static const struct itemplate * const itable_vex012E6[] = {
+    instrux + 2547,
+    instrux + 2548,
+};
+
+static const struct itemplate * const itable_vex01310[] = {
+    instrux + 2726,
+    instrux + 2727,
+    instrux + 2728,
+};
+
+static const struct itemplate * const itable_vex01311[] = {
+    instrux + 2729,
+    instrux + 2730,
+    instrux + 2731,
+};
+
+static const struct itemplate * const itable_vex01312[] = {
+    instrux + 2680,
+    instrux + 2681,
+};
+
+static const struct itemplate * const itable_vex0132A[] = {
+    instrux + 2567,
+    instrux + 2568,
+    instrux + 2569,
+    instrux + 2570,
+};
+
+static const struct itemplate * const itable_vex0132C[] = {
+    instrux + 2585,
+    instrux + 2586,
+};
+
+static const struct itemplate * const itable_vex0132D[] = {
+    instrux + 2563,
+    instrux + 2564,
+};
+
+static const struct itemplate * const itable_vex01351[] = {
+    instrux + 3062,
+    instrux + 3063,
+};
+
+static const struct itemplate * const itable_vex01358[] = {
+    instrux + 1933,
+    instrux + 1934,
+};
+
+static const struct itemplate * const itable_vex01359[] = {
+    instrux + 2760,
+    instrux + 2761,
+};
+
+static const struct itemplate * const itable_vex0135A[] = {
+    instrux + 2565,
+    instrux + 2566,
+};
+
+static const struct itemplate * const itable_vex0135C[] = {
+    instrux + 3075,
+    instrux + 3076,
+};
+
+static const struct itemplate * const itable_vex0135D[] = {
+    instrux + 2662,
+    instrux + 2663,
+};
+
+static const struct itemplate * const itable_vex0135E[] = {
+    instrux + 2597,
+    instrux + 2598,
+};
+
+static const struct itemplate * const itable_vex0135F[] = {
+    instrux + 2650,
+    instrux + 2651,
+};
+
+static const struct itemplate * const itable_vex01370[] = {
+    instrux + 2955,
+    instrux + 3818,
+};
+
+static const struct itemplate * const itable_vex0137C[] = {
+    instrux + 2613,
+    instrux + 2614,
+    instrux + 2615,
+    instrux + 2616,
+};
+
+static const struct itemplate * const itable_vex0137D[] = {
+    instrux + 2621,
+    instrux + 2622,
+    instrux + 2623,
+    instrux + 2624,
+};
+
+static const struct itemplate * const itable_vex01392[] = {
+    instrux + 4119,
+    instrux + 4123,
+};
+
+static const struct itemplate * const itable_vex01393[] = {
+    instrux + 4120,
+    instrux + 4124,
+};
+
+static const struct itemplate * const itable_vex013C2[] = {
+    instrux + 2357,
+    instrux + 2358,
+    instrux + 2359,
+    instrux + 2360,
+    instrux + 2361,
+    instrux + 2362,
+    instrux + 2363,
+    instrux + 2364,
+    instrux + 2365,
+    instrux + 2366,
+    instrux + 2367,
+    instrux + 2368,
+    instrux + 2369,
+    instrux + 2370,
+    instrux + 2371,
+    instrux + 2372,
+    instrux + 2373,
+    instrux + 2374,
+    instrux + 2375,
+    instrux + 2376,
+    instrux + 2377,
+    instrux + 2378,
+    instrux + 2379,
+    instrux + 2380,
+    instrux + 2381,
+    instrux + 2382,
+    instrux + 2383,
+    instrux + 2384,
+    instrux + 2385,
+    instrux + 2386,
+    instrux + 2387,
+    instrux + 2388,
+    instrux + 2389,
+    instrux + 2390,
+    instrux + 2391,
+    instrux + 2392,
+    instrux + 2393,
+    instrux + 2394,
+    instrux + 2395,
+    instrux + 2396,
+    instrux + 2397,
+    instrux + 2398,
+    instrux + 2399,
+    instrux + 2400,
+    instrux + 2401,
+    instrux + 2402,
+    instrux + 2403,
+    instrux + 2404,
+    instrux + 2405,
+    instrux + 2406,
+    instrux + 2407,
+    instrux + 2408,
+    instrux + 2409,
+    instrux + 2410,
+    instrux + 2411,
+    instrux + 2412,
+    instrux + 2413,
+    instrux + 2414,
+    instrux + 2415,
+    instrux + 2416,
+    instrux + 2417,
+    instrux + 2418,
+    instrux + 2419,
+    instrux + 2420,
+    instrux + 2421,
+    instrux + 2422,
+    instrux + 2423,
+    instrux + 2424,
+    instrux + 2425,
+    instrux + 2426,
+    instrux + 2427,
+    instrux + 2428,
+    instrux + 2429,
+    instrux + 2430,
+    instrux + 2431,
+    instrux + 2432,
+    instrux + 2433,
+    instrux + 2434,
+    instrux + 2435,
+    instrux + 2436,
+    instrux + 2437,
+    instrux + 2438,
+    instrux + 2439,
+    instrux + 2440,
+    instrux + 2441,
+    instrux + 2442,
+    instrux + 2443,
+    instrux + 2444,
+    instrux + 2445,
+    instrux + 2446,
+    instrux + 2447,
+    instrux + 2448,
+    instrux + 2449,
+    instrux + 2450,
+};
+
+static const struct itemplate * const itable_vex013D0[] = {
+    instrux + 1941,
+    instrux + 1942,
+    instrux + 1943,
+    instrux + 1944,
+};
+
+static const struct itemplate * const itable_vex013E6[] = {
+    instrux + 2551,
+    instrux + 2552,
+    instrux + 2553,
+    instrux + 2554,
+};
+
+static const struct itemplate * const itable_vex013F0[] = {
+    instrux + 2629,
+    instrux + 2630,
+    instrux + 2631,
+};
+
+static const struct itemplate * const itable_vex02049[] = {
+    instrux + 7011,
+    instrux + 7020,
+};
+
+static const struct itemplate * const itable_vex02050[] = {
+    instrux + 4093,
+    instrux + 4094,
+};
+
+static const struct itemplate * const itable_vex02051[] = {
+    instrux + 4095,
+    instrux + 4096,
+};
+
+static const struct itemplate * const itable_vex0205E[] = {
+    instrux + 7017,
+};
+
+static const struct itemplate * const itable_vex020B0[] = {
+    instrux + 4081,
+    instrux + 4082,
+};
+
+static const struct itemplate * const itable_vex020F2[] = {
+    instrux + 3991,
+    instrux + 3992,
+};
+
+static const struct itemplate * const itable_vex020F3[] = {
+    instrux + 4001,
+    instrux + 4002,
+    instrux + 4011,
+    instrux + 4012,
+    instrux + 4013,
+    instrux + 4014,
+};
+
+static const struct itemplate * const itable_vex020F5[] = {
+    instrux + 4017,
+    instrux + 4018,
+};
+
+static const struct itemplate * const itable_vex020F7[] = {
+    instrux + 3993,
+    instrux + 3994,
+};
+
+static const struct itemplate * const itable_vex02100[] = {
+    instrux + 2951,
+    instrux + 2952,
+    instrux + 3814,
+    instrux + 3815,
+};
+
+static const struct itemplate * const itable_vex02101[] = {
+    instrux + 2858,
+    instrux + 2859,
+    instrux + 3736,
+    instrux + 3737,
+};
+
+static const struct itemplate * const itable_vex02102[] = {
+    instrux + 2860,
+    instrux + 2861,
+    instrux + 3738,
+    instrux + 3739,
+};
+
+static const struct itemplate * const itable_vex02103[] = {
+    instrux + 2862,
+    instrux + 2863,
+    instrux + 3740,
+    instrux + 3741,
+};
+
+static const struct itemplate * const itable_vex02104[] = {
+    instrux + 2893,
+    instrux + 2894,
+    instrux + 3748,
+    instrux + 3749,
+};
+
+static const struct itemplate * const itable_vex02105[] = {
+    instrux + 2865,
+    instrux + 2866,
+    instrux + 3742,
+    instrux + 3743,
+};
+
+static const struct itemplate * const itable_vex02106[] = {
+    instrux + 2867,
+    instrux + 2868,
+    instrux + 3744,
+    instrux + 3745,
+};
+
+static const struct itemplate * const itable_vex02107[] = {
+    instrux + 2869,
+    instrux + 2870,
+    instrux + 3746,
+    instrux + 3747,
+};
+
+static const struct itemplate * const itable_vex02108[] = {
+    instrux + 2956,
+    instrux + 2957,
+    instrux + 3819,
+    instrux + 3820,
+};
+
+static const struct itemplate * const itable_vex02109[] = {
+    instrux + 2958,
+    instrux + 2959,
+    instrux + 3821,
+    instrux + 3822,
+};
+
+static const struct itemplate * const itable_vex0210A[] = {
+    instrux + 2960,
+    instrux + 2961,
+    instrux + 3823,
+    instrux + 3824,
+};
+
+static const struct itemplate * const itable_vex0210B[] = {
+    instrux + 2935,
+    instrux + 2936,
+    instrux + 3798,
+    instrux + 3799,
+};
+
+static const struct itemplate * const itable_vex0210C[] = {
+    instrux + 2839,
+    instrux + 2840,
+    instrux + 2841,
+    instrux + 2842,
+};
+
+static const struct itemplate * const itable_vex0210D[] = {
+    instrux + 2833,
+    instrux + 2834,
+    instrux + 2835,
+    instrux + 2836,
+};
+
+static const struct itemplate * const itable_vex0210E[] = {
+    instrux + 3079,
+    instrux + 3080,
+};
+
+static const struct itemplate * const itable_vex0210F[] = {
+    instrux + 3081,
+    instrux + 3082,
+};
+
+static const struct itemplate * const itable_vex02113[] = {
+    instrux + 3369,
+    instrux + 3370,
+    instrux + 7052,
+    instrux + 7053,
+};
+
+static const struct itemplate * const itable_vex02116[] = {
+    instrux + 3923,
+    instrux + 3924,
+};
+
+static const struct itemplate * const itable_vex02117[] = {
+    instrux + 2998,
+    instrux + 2999,
+};
+
+static const struct itemplate * const itable_vex02118[] = {
+    instrux + 1977,
+    instrux + 1978,
+    instrux + 3896,
+    instrux + 3897,
+};
+
+static const struct itemplate * const itable_vex02119[] = {
+    instrux + 1979,
+    instrux + 3898,
+};
+
+static const struct itemplate * const itable_vex0211A[] = {
+    instrux + 1980,
+};
+
+static const struct itemplate * const itable_vex0211C[] = {
+    instrux + 2772,
+    instrux + 3679,
+};
+
+static const struct itemplate * const itable_vex0211D[] = {
+    instrux + 2773,
+    instrux + 3680,
+};
+
+static const struct itemplate * const itable_vex0211E[] = {
+    instrux + 2774,
+    instrux + 3681,
+};
+
+static const struct itemplate * const itable_vex02120[] = {
+    instrux + 2921,
+    instrux + 3778,
+};
+
+static const struct itemplate * const itable_vex02121[] = {
+    instrux + 2922,
+    instrux + 3779,
+    instrux + 3780,
+};
+
+static const struct itemplate * const itable_vex02122[] = {
+    instrux + 2923,
+    instrux + 3781,
+    instrux + 3782,
+};
+
+static const struct itemplate * const itable_vex02123[] = {
+    instrux + 2924,
+    instrux + 3783,
+};
+
+static const struct itemplate * const itable_vex02124[] = {
+    instrux + 2925,
+    instrux + 3784,
+    instrux + 3785,
+};
+
+static const struct itemplate * const itable_vex02125[] = {
+    instrux + 2926,
+    instrux + 3786,
+};
+
+static const struct itemplate * const itable_vex02128[] = {
+    instrux + 2945,
+    instrux + 2946,
+    instrux + 3796,
+    instrux + 3797,
+};
+
+static const struct itemplate * const itable_vex02129[] = {
+    instrux + 2823,
+    instrux + 2824,
+    instrux + 3726,
+    instrux + 3727,
+};
+
+static const struct itemplate * const itable_vex0212A[] = {
+    instrux + 2721,
+    instrux + 3895,
+};
+
+static const struct itemplate * const itable_vex0212B[] = {
+    instrux + 2781,
+    instrux + 2782,
+    instrux + 3686,
+    instrux + 3687,
+};
+
+static const struct itemplate * const itable_vex0212C[] = {
+    instrux + 2634,
+    instrux + 2635,
+};
+
+static const struct itemplate * const itable_vex0212D[] = {
+    instrux + 2638,
+    instrux + 2639,
+};
+
+static const struct itemplate * const itable_vex0212E[] = {
+    instrux + 2636,
+    instrux + 2637,
+};
+
+static const struct itemplate * const itable_vex0212F[] = {
+    instrux + 2640,
+    instrux + 2641,
+};
+
+static const struct itemplate * const itable_vex02130[] = {
+    instrux + 2927,
+    instrux + 3787,
+};
+
+static const struct itemplate * const itable_vex02131[] = {
+    instrux + 2928,
+    instrux + 3788,
+    instrux + 3789,
+};
+
+static const struct itemplate * const itable_vex02132[] = {
+    instrux + 2929,
+    instrux + 3790,
+    instrux + 3791,
+};
+
+static const struct itemplate * const itable_vex02133[] = {
+    instrux + 2930,
+    instrux + 3792,
+};
+
+static const struct itemplate * const itable_vex02134[] = {
+    instrux + 2931,
+    instrux + 3793,
+    instrux + 3794,
+};
+
+static const struct itemplate * const itable_vex02135[] = {
+    instrux + 2932,
+    instrux + 3795,
+};
+
+static const struct itemplate * const itable_vex02136[] = {
+    instrux + 3920,
+    instrux + 3921,
+};
+
+static const struct itemplate * const itable_vex02137[] = {
+    instrux + 2831,
+    instrux + 2832,
+    instrux + 3734,
+    instrux + 3735,
+};
+
+static const struct itemplate * const itable_vex02138[] = {
+    instrux + 2907,
+    instrux + 2908,
+    instrux + 3764,
+    instrux + 3765,
+};
+
+static const struct itemplate * const itable_vex02139[] = {
+    instrux + 2911,
+    instrux + 2912,
+    instrux + 3768,
+    instrux + 3769,
+};
+
+static const struct itemplate * const itable_vex0213A[] = {
+    instrux + 2915,
+    instrux + 2916,
+    instrux + 3772,
+    instrux + 3773,
+};
+
+static const struct itemplate * const itable_vex0213B[] = {
+    instrux + 2917,
+    instrux + 2918,
+    instrux + 3774,
+    instrux + 3775,
+};
+
+static const struct itemplate * const itable_vex0213C[] = {
+    instrux + 2895,
+    instrux + 2896,
+    instrux + 3752,
+    instrux + 3753,
+};
+
+static const struct itemplate * const itable_vex0213D[] = {
+    instrux + 2899,
+    instrux + 2900,
+    instrux + 3756,
+    instrux + 3757,
+};
+
+static const struct itemplate * const itable_vex0213E[] = {
+    instrux + 2903,
+    instrux + 2904,
+    instrux + 3760,
+    instrux + 3761,
+};
+
+static const struct itemplate * const itable_vex0213F[] = {
+    instrux + 2905,
+    instrux + 2906,
+    instrux + 3762,
+    instrux + 3763,
+};
+
+static const struct itemplate * const itable_vex02140[] = {
+    instrux + 2941,
+    instrux + 2942,
+    instrux + 3806,
+    instrux + 3807,
+};
+
+static const struct itemplate * const itable_vex02141[] = {
+    instrux + 2864,
+};
+
+static const struct itemplate * const itable_vex02145[] = {
+    instrux + 3959,
+    instrux + 3960,
+    instrux + 3961,
+    instrux + 3962,
+    instrux + 3963,
+    instrux + 3964,
+    instrux + 3965,
+    instrux + 3966,
+};
+
+static const struct itemplate * const itable_vex02146[] = {
+    instrux + 3955,
+    instrux + 3956,
+    instrux + 3957,
+    instrux + 3958,
+};
+
+static const struct itemplate * const itable_vex02147[] = {
+    instrux + 3947,
+    instrux + 3948,
+    instrux + 3949,
+    instrux + 3950,
+    instrux + 3951,
+    instrux + 3952,
+    instrux + 3953,
+    instrux + 3954,
+};
+
+static const struct itemplate * const itable_vex02149[] = {
+    instrux + 7012,
+};
+
+static const struct itemplate * const itable_vex0214B[] = {
+    instrux + 7019,
+};
+
+static const struct itemplate * const itable_vex02158[] = {
+    instrux + 3912,
+    instrux + 3913,
+    instrux + 3914,
+    instrux + 3915,
+};
+
+static const struct itemplate * const itable_vex02159[] = {
+    instrux + 3916,
+    instrux + 3917,
+    instrux + 3918,
+    instrux + 3919,
+};
+
+static const struct itemplate * const itable_vex0215A[] = {
+    instrux + 3899,
+};
+
+static const struct itemplate * const itable_vex0215E[] = {
+    instrux + 7016,
+};
+
+static const struct itemplate * const itable_vex02178[] = {
+    instrux + 3904,
+    instrux + 3905,
+    instrux + 3906,
+    instrux + 3907,
+};
+
+static const struct itemplate * const itable_vex02179[] = {
+    instrux + 3908,
+    instrux + 3909,
+    instrux + 3910,
+    instrux + 3911,
+};
+
+static const struct itemplate * const itable_vex0218C[] = {
+    instrux + 3931,
+    instrux + 3932,
+    instrux + 3933,
+    instrux + 3934,
+    instrux + 3935,
+    instrux + 3936,
+    instrux + 3937,
+    instrux + 3938,
+};
+
+static const struct itemplate * const itable_vex0218E[] = {
+    instrux + 3939,
+    instrux + 3940,
+    instrux + 3941,
+    instrux + 3942,
+    instrux + 3943,
+    instrux + 3944,
+    instrux + 3945,
+    instrux + 3946,
+};
+
+static const struct itemplate * const itable_vex02190[] = {
+    instrux + 3975,
+    instrux + 3977,
+    instrux + 3979,
+    instrux + 3981,
+};
+
+static const struct itemplate * const itable_vex02191[] = {
+    instrux + 3976,
+    instrux + 3978,
+    instrux + 3980,
+    instrux + 3982,
+};
+
+static const struct itemplate * const itable_vex02192[] = {
+    instrux + 3967,
+    instrux + 3969,
+    instrux + 3971,
+    instrux + 3973,
+};
+
+static const struct itemplate * const itable_vex02193[] = {
+    instrux + 3968,
+    instrux + 3970,
+    instrux + 3972,
+    instrux + 3974,
+};
+
+static const struct itemplate * const itable_vex02196[] = {
+    instrux + 3190,
+    instrux + 3191,
+    instrux + 3192,
+    instrux + 3193,
+    instrux + 3194,
+    instrux + 3195,
+    instrux + 3196,
+    instrux + 3197,
+};
+
+static const struct itemplate * const itable_vex02197[] = {
+    instrux + 3238,
+    instrux + 3239,
+    instrux + 3240,
+    instrux + 3241,
+    instrux + 3242,
+    instrux + 3243,
+    instrux + 3244,
+    instrux + 3245,
+};
+
+static const struct itemplate * const itable_vex02198[] = {
+    instrux + 3166,
+    instrux + 3167,
+    instrux + 3168,
+    instrux + 3169,
+    instrux + 3170,
+    instrux + 3171,
+    instrux + 3172,
+    instrux + 3173,
+};
+
+static const struct itemplate * const itable_vex02199[] = {
+    instrux + 3310,
+    instrux + 3311,
+    instrux + 3312,
+    instrux + 3313,
+};
+
+static const struct itemplate * const itable_vex0219A[] = {
+    instrux + 3214,
+    instrux + 3215,
+    instrux + 3216,
+    instrux + 3217,
+    instrux + 3218,
+    instrux + 3219,
+    instrux + 3220,
+    instrux + 3221,
+};
+
+static const struct itemplate * const itable_vex0219B[] = {
+    instrux + 3322,
+    instrux + 3323,
+    instrux + 3324,
+    instrux + 3325,
+};
+
+static const struct itemplate * const itable_vex0219C[] = {
+    instrux + 3262,
+    instrux + 3263,
+    instrux + 3264,
+    instrux + 3265,
+    instrux + 3266,
+    instrux + 3267,
+    instrux + 3268,
+    instrux + 3269,
+};
+
+static const struct itemplate * const itable_vex0219D[] = {
+    instrux + 3334,
+    instrux + 3335,
+    instrux + 3336,
+    instrux + 3337,
+};
+
+static const struct itemplate * const itable_vex0219E[] = {
+    instrux + 3286,
+    instrux + 3287,
+    instrux + 3288,
+    instrux + 3289,
+    instrux + 3290,
+    instrux + 3291,
+    instrux + 3292,
+    instrux + 3293,
+};
+
+static const struct itemplate * const itable_vex0219F[] = {
+    instrux + 3346,
+    instrux + 3347,
+    instrux + 3348,
+    instrux + 3349,
+};
+
+static const struct itemplate * const itable_vex021A6[] = {
+    instrux + 3198,
+    instrux + 3199,
+    instrux + 3200,
+    instrux + 3201,
+    instrux + 3202,
+    instrux + 3203,
+    instrux + 3204,
+    instrux + 3205,
+};
+
+static const struct itemplate * const itable_vex021A7[] = {
+    instrux + 3246,
+    instrux + 3247,
+    instrux + 3248,
+    instrux + 3249,
+    instrux + 3250,
+    instrux + 3251,
+    instrux + 3252,
+    instrux + 3253,
+};
+
+static const struct itemplate * const itable_vex021A8[] = {
+    instrux + 3174,
+    instrux + 3175,
+    instrux + 3176,
+    instrux + 3177,
+    instrux + 3178,
+    instrux + 3179,
+    instrux + 3180,
+    instrux + 3181,
+};
+
+static const struct itemplate * const itable_vex021A9[] = {
+    instrux + 3314,
+    instrux + 3315,
+    instrux + 3316,
+    instrux + 3317,
+};
+
+static const struct itemplate * const itable_vex021AA[] = {
+    instrux + 3222,
+    instrux + 3223,
+    instrux + 3224,
+    instrux + 3225,
+    instrux + 3226,
+    instrux + 3227,
+    instrux + 3228,
+    instrux + 3229,
+};
+
+static const struct itemplate * const itable_vex021AB[] = {
+    instrux + 3326,
+    instrux + 3327,
+    instrux + 3328,
+    instrux + 3329,
+};
+
+static const struct itemplate * const itable_vex021AC[] = {
+    instrux + 3270,
+    instrux + 3271,
+    instrux + 3272,
+    instrux + 3273,
+    instrux + 3274,
+    instrux + 3275,
+    instrux + 3276,
+    instrux + 3277,
+};
+
+static const struct itemplate * const itable_vex021AD[] = {
+    instrux + 3338,
+    instrux + 3339,
+    instrux + 3340,
+    instrux + 3341,
+};
+
+static const struct itemplate * const itable_vex021AE[] = {
+    instrux + 3294,
+    instrux + 3295,
+    instrux + 3296,
+    instrux + 3297,
+    instrux + 3298,
+    instrux + 3299,
+    instrux + 3300,
+    instrux + 3301,
+};
+
+static const struct itemplate * const itable_vex021AF[] = {
+    instrux + 3350,
+    instrux + 3351,
+    instrux + 3352,
+    instrux + 3353,
+};
+
+static const struct itemplate * const itable_vex021B0[] = {
+    instrux + 4077,
+    instrux + 4078,
+};
+
+static const struct itemplate * const itable_vex021B1[] = {
+    instrux + 4073,
+    instrux + 4074,
+};
+
+static const struct itemplate * const itable_vex021B4[] = {
+    instrux + 4099,
+    instrux + 4100,
+};
+
+static const struct itemplate * const itable_vex021B5[] = {
+    instrux + 4097,
+    instrux + 4098,
+};
+
+static const struct itemplate * const itable_vex021B6[] = {
+    instrux + 3206,
+    instrux + 3207,
+    instrux + 3208,
+    instrux + 3209,
+    instrux + 3210,
+    instrux + 3211,
+    instrux + 3212,
+    instrux + 3213,
+};
+
+static const struct itemplate * const itable_vex021B7[] = {
+    instrux + 3254,
+    instrux + 3255,
+    instrux + 3256,
+    instrux + 3257,
+    instrux + 3258,
+    instrux + 3259,
+    instrux + 3260,
+    instrux + 3261,
+};
+
+static const struct itemplate * const itable_vex021B8[] = {
+    instrux + 3182,
+    instrux + 3183,
+    instrux + 3184,
+    instrux + 3185,
+    instrux + 3186,
+    instrux + 3187,
+    instrux + 3188,
+    instrux + 3189,
+};
+
+static const struct itemplate * const itable_vex021B9[] = {
+    instrux + 3318,
+    instrux + 3319,
+    instrux + 3320,
+    instrux + 3321,
+};
+
+static const struct itemplate * const itable_vex021BA[] = {
+    instrux + 3230,
+    instrux + 3231,
+    instrux + 3232,
+    instrux + 3233,
+    instrux + 3234,
+    instrux + 3235,
+    instrux + 3236,
+    instrux + 3237,
+};
+
+static const struct itemplate * const itable_vex021BB[] = {
+    instrux + 3330,
+    instrux + 3331,
+    instrux + 3332,
+    instrux + 3333,
+};
+
+static const struct itemplate * const itable_vex021BC[] = {
+    instrux + 3278,
+    instrux + 3279,
+    instrux + 3280,
+    instrux + 3281,
+    instrux + 3282,
+    instrux + 3283,
+    instrux + 3284,
+    instrux + 3285,
+};
+
+static const struct itemplate * const itable_vex021BD[] = {
+    instrux + 3342,
+    instrux + 3343,
+    instrux + 3344,
+    instrux + 3345,
+};
+
+static const struct itemplate * const itable_vex021BE[] = {
+    instrux + 3302,
+    instrux + 3303,
+    instrux + 3304,
+    instrux + 3305,
+    instrux + 3306,
+    instrux + 3307,
+    instrux + 3308,
+    instrux + 3309,
+};
+
+static const struct itemplate * const itable_vex021BF[] = {
+    instrux + 3354,
+    instrux + 3355,
+    instrux + 3356,
+    instrux + 3357,
+};
+
+static const struct itemplate * const itable_vex021CF[] = {
+    instrux + 6817,
+    instrux + 6818,
+    instrux + 6819,
+    instrux + 6820,
+};
+
+static const struct itemplate * const itable_vex021DB[] = {
+    instrux + 1891,
+};
+
+static const struct itemplate * const itable_vex021DC[] = {
+    instrux + 1883,
+    instrux + 1884,
+    instrux + 1893,
+    instrux + 1894,
+};
+
+static const struct itemplate * const itable_vex021DD[] = {
+    instrux + 1885,
+    instrux + 1886,
+    instrux + 1895,
+    instrux + 1896,
+};
+
+static const struct itemplate * const itable_vex021DE[] = {
+    instrux + 1887,
+    instrux + 1888,
+    instrux + 1897,
+    instrux + 1898,
+};
+
+static const struct itemplate * const itable_vex021DF[] = {
+    instrux + 1889,
+    instrux + 1890,
+    instrux + 1899,
+    instrux + 1900,
+};
+
+static const struct itemplate * const itable_vex021E0[] = {
+    instrux + 7416,
+    instrux + 7432,
+};
+
+static const struct itemplate * const itable_vex021E1[] = {
+    instrux + 7413,
+    instrux + 7429,
+};
+
+static const struct itemplate * const itable_vex021E2[] = {
+    instrux + 7406,
+    instrux + 7422,
+};
+
+static const struct itemplate * const itable_vex021E3[] = {
+    instrux + 7410,
+    instrux + 7426,
+};
+
+static const struct itemplate * const itable_vex021E4[] = {
+    instrux + 7420,
+    instrux + 7436,
+};
+
+static const struct itemplate * const itable_vex021E5[] = {
+    instrux + 7415,
+    instrux + 7431,
+};
+
+static const struct itemplate * const itable_vex021E6[] = {
+    instrux + 7409,
+    instrux + 7425,
+};
+
+static const struct itemplate * const itable_vex021E7[] = {
+    instrux + 7405,
+    instrux + 7421,
+};
+
+static const struct itemplate * const itable_vex021E8[] = {
+    instrux + 7419,
+    instrux + 7435,
+};
+
+static const struct itemplate * const itable_vex021E9[] = {
+    instrux + 7414,
+    instrux + 7430,
+};
+
+static const struct itemplate * const itable_vex021EA[] = {
+    instrux + 7417,
+    instrux + 7433,
+};
+
+static const struct itemplate * const itable_vex021EB[] = {
+    instrux + 7418,
+    instrux + 7434,
+};
+
+static const struct itemplate * const itable_vex021EC[] = {
+    instrux + 7408,
+    instrux + 7424,
+};
+
+static const struct itemplate * const itable_vex021ED[] = {
+    instrux + 7412,
+    instrux + 7428,
+};
+
+static const struct itemplate * const itable_vex021EE[] = {
+    instrux + 7411,
+    instrux + 7427,
+};
+
+static const struct itemplate * const itable_vex021EF[] = {
+    instrux + 7407,
+    instrux + 7423,
+};
+
+static const struct itemplate * const itable_vex021F7[] = {
+    instrux + 4029,
+    instrux + 4030,
+};
+
+static const struct itemplate * const itable_vex0224B[] = {
+    instrux + 7021,
+};
+
+static const struct itemplate * const itable_vex02250[] = {
+    instrux + 4089,
+    instrux + 4090,
+};
+
+static const struct itemplate * const itable_vex02251[] = {
+    instrux + 4091,
+    instrux + 4092,
+};
+
+static const struct itemplate * const itable_vex0225C[] = {
+    instrux + 7013,
+};
+
+static const struct itemplate * const itable_vex0225E[] = {
+    instrux + 7015,
+};
+
+static const struct itemplate * const itable_vex02272[] = {
+    instrux + 4083,
+    instrux + 4084,
+};
+
+static const struct itemplate * const itable_vex022B0[] = {
+    instrux + 4075,
+    instrux + 4076,
+};
+
+static const struct itemplate * const itable_vex022B1[] = {
+    instrux + 4071,
+    instrux + 4072,
+};
+
+static const struct itemplate * const itable_vex022F5[] = {
+    instrux + 4023,
+    instrux + 4024,
+};
+
+static const struct itemplate * const itable_vex022F7[] = {
+    instrux + 4027,
+    instrux + 4028,
+};
+
+static const struct itemplate * const itable_vex02349[] = {
+    instrux + 7022,
+};
+
+static const struct itemplate * const itable_vex0234B[] = {
+    instrux + 7018,
+};
+
+static const struct itemplate * const itable_vex02350[] = {
+    instrux + 4085,
+    instrux + 4086,
+};
+
+static const struct itemplate * const itable_vex02351[] = {
+    instrux + 4087,
+    instrux + 4088,
+};
+
+static const struct itemplate * const itable_vex0235E[] = {
+    instrux + 7014,
+};
+
+static const struct itemplate * const itable_vex023B0[] = {
+    instrux + 4079,
+    instrux + 4080,
+};
+
+static const struct itemplate * const itable_vex023F5[] = {
+    instrux + 4021,
+    instrux + 4022,
+};
+
+static const struct itemplate * const itable_vex023F6[] = {
+    instrux + 4019,
+    instrux + 4020,
+};
+
+static const struct itemplate * const itable_vex023F7[] = {
+    instrux + 4031,
+    instrux + 4032,
+};
+
+static const struct itemplate * const itable_vex03100[] = {
+    instrux + 3925,
+};
+
+static const struct itemplate * const itable_vex03101[] = {
+    instrux + 3922,
+};
+
+static const struct itemplate * const itable_vex03102[] = {
+    instrux + 3900,
+    instrux + 3901,
+    instrux + 3902,
+    instrux + 3903,
+};
+
+static const struct itemplate * const itable_vex03104[] = {
+    instrux + 2843,
+    instrux + 2844,
+};
+
+static const struct itemplate * const itable_vex03105[] = {
+    instrux + 2837,
+    instrux + 2838,
+};
+
+static const struct itemplate * const itable_vex03106[] = {
+    instrux + 2845,
+    instrux + 2846,
+};
+
+static const struct itemplate * const itable_vex03108[] = {
+    instrux + 3044,
+    instrux + 3045,
+};
+
+static const struct itemplate * const itable_vex03109[] = {
+    instrux + 3042,
+    instrux + 3043,
+};
+
+static const struct itemplate * const itable_vex0310A[] = {
+    instrux + 3048,
+    instrux + 3049,
+};
+
+static const struct itemplate * const itable_vex0310B[] = {
+    instrux + 3046,
+    instrux + 3047,
+};
+
+static const struct itemplate * const itable_vex0310C[] = {
+    instrux + 1965,
+    instrux + 1966,
+    instrux + 1967,
+    instrux + 1968,
+};
+
+static const struct itemplate * const itable_vex0310D[] = {
+    instrux + 1961,
+    instrux + 1962,
+    instrux + 1963,
+    instrux + 1964,
+};
+
+static const struct itemplate * const itable_vex0310E[] = {
+    instrux + 2811,
+    instrux + 2812,
+    instrux + 3718,
+    instrux + 3719,
+};
+
+static const struct itemplate * const itable_vex0310F[] = {
+    instrux + 2799,
+    instrux + 2800,
+    instrux + 3706,
+    instrux + 3707,
+};
+
+static const struct itemplate * const itable_vex03114[] = {
+    instrux + 2847,
+    instrux + 2848,
+    instrux + 2849,
+};
+
+static const struct itemplate * const itable_vex03115[] = {
+    instrux + 2852,
+    instrux + 2853,
+    instrux + 2854,
+};
+
+static const struct itemplate * const itable_vex03116[] = {
+    instrux + 2855,
+    instrux + 2856,
+    instrux + 2857,
+};
+
+static const struct itemplate * const itable_vex03117[] = {
+    instrux + 2608,
+};
+
+static const struct itemplate * const itable_vex03118[] = {
+    instrux + 2625,
+    instrux + 2626,
+};
+
+static const struct itemplate * const itable_vex03119[] = {
+    instrux + 2607,
+};
+
+static const struct itemplate * const itable_vex0311D[] = {
+    instrux + 3371,
+    instrux + 3372,
+    instrux + 7075,
+    instrux + 7076,
+};
+
+static const struct itemplate * const itable_vex03120[] = {
+    instrux + 2871,
+    instrux + 2872,
+    instrux + 2873,
+    instrux + 2874,
+    instrux + 2875,
+    instrux + 2876,
+};
+
+static const struct itemplate * const itable_vex03121[] = {
+    instrux + 2627,
+    instrux + 2628,
+};
+
+static const struct itemplate * const itable_vex03122[] = {
+    instrux + 2883,
+    instrux + 2884,
+    instrux + 2885,
+    instrux + 2886,
+    instrux + 2887,
+    instrux + 2888,
+    instrux + 2889,
+    instrux + 2890,
+};
+
+static const struct itemplate * const itable_vex03130[] = {
+    instrux + 4145,
+    instrux + 4148,
+};
+
+static const struct itemplate * const itable_vex03131[] = {
+    instrux + 4146,
+    instrux + 4147,
+};
+
+static const struct itemplate * const itable_vex03132[] = {
+    instrux + 4141,
+    instrux + 4144,
+};
+
+static const struct itemplate * const itable_vex03133[] = {
+    instrux + 4142,
+    instrux + 4143,
+};
+
+static const struct itemplate * const itable_vex03138[] = {
+    instrux + 3929,
+    instrux + 3930,
+};
+
+static const struct itemplate * const itable_vex03139[] = {
+    instrux + 3928,
+};
+
+static const struct itemplate * const itable_vex03140[] = {
+    instrux + 2603,
+    instrux + 2604,
+    instrux + 2605,
+    instrux + 2606,
+};
+
+static const struct itemplate * const itable_vex03141[] = {
+    instrux + 2601,
+    instrux + 2602,
+};
+
+static const struct itemplate * const itable_vex03142[] = {
+    instrux + 2750,
+    instrux + 2751,
+    instrux + 3677,
+    instrux + 3678,
+};
+
+static const struct itemplate * const itable_vex03144[] = {
+    instrux + 3116,
+    instrux + 3117,
+    instrux + 3118,
+    instrux + 3119,
+    instrux + 3120,
+    instrux + 3121,
+    instrux + 3122,
+    instrux + 3123,
+    instrux + 3124,
+    instrux + 3125,
+    instrux + 3126,
+    instrux + 3127,
+    instrux + 3128,
+    instrux + 3129,
+    instrux + 3130,
+    instrux + 3131,
+    instrux + 3132,
+    instrux + 3133,
+    instrux + 3134,
+    instrux + 3135,
+};
+
+static const struct itemplate * const itable_vex03146[] = {
+    instrux + 3926,
+    instrux + 3927,
+};
+
+static const struct itemplate * const itable_vex0314A[] = {
+    instrux + 1973,
+    instrux + 1974,
+    instrux + 1975,
+    instrux + 1976,
+};
+
+static const struct itemplate * const itable_vex0314B[] = {
+    instrux + 1969,
+    instrux + 1970,
+    instrux + 1971,
+    instrux + 1972,
+};
+
+static const struct itemplate * const itable_vex0314C[] = {
+    instrux + 2809,
+    instrux + 2810,
+    instrux + 3716,
+    instrux + 3717,
+};
+
+static const struct itemplate * const itable_vex0315C[] = {
+    instrux + 3431,
+    instrux + 3432,
+    instrux + 3433,
+    instrux + 3434,
+    instrux + 3435,
+    instrux + 3436,
+    instrux + 3437,
+    instrux + 3438,
+};
+
+static const struct itemplate * const itable_vex0315D[] = {
+    instrux + 3423,
+    instrux + 3424,
+    instrux + 3425,
+    instrux + 3426,
+    instrux + 3427,
+    instrux + 3428,
+    instrux + 3429,
+    instrux + 3430,
+};
+
+static const struct itemplate * const itable_vex0315E[] = {
+    instrux + 3447,
+    instrux + 3448,
+    instrux + 3449,
+    instrux + 3450,
+    instrux + 3451,
+    instrux + 3452,
+    instrux + 3453,
+    instrux + 3454,
+};
+
+static const struct itemplate * const itable_vex0315F[] = {
+    instrux + 3439,
+    instrux + 3440,
+    instrux + 3441,
+    instrux + 3442,
+    instrux + 3443,
+    instrux + 3444,
+    instrux + 3445,
+    instrux + 3446,
+};
+
+static const struct itemplate * const itable_vex03160[] = {
+    instrux + 2814,
+};
+
+static const struct itemplate * const itable_vex03161[] = {
+    instrux + 2813,
+};
+
+static const struct itemplate * const itable_vex03162[] = {
+    instrux + 2816,
+};
+
+static const struct itemplate * const itable_vex03163[] = {
+    instrux + 2815,
+};
+
+static const struct itemplate * const itable_vex03168[] = {
+    instrux + 3407,
+    instrux + 3408,
+    instrux + 3409,
+    instrux + 3410,
+    instrux + 3411,
+    instrux + 3412,
+    instrux + 3413,
+    instrux + 3414,
+};
+
+static const struct itemplate * const itable_vex03169[] = {
+    instrux + 3399,
+    instrux + 3400,
+    instrux + 3401,
+    instrux + 3402,
+    instrux + 3403,
+    instrux + 3404,
+    instrux + 3405,
+    instrux + 3406,
+};
+
+static const struct itemplate * const itable_vex0316A[] = {
+    instrux + 3419,
+    instrux + 3420,
+    instrux + 3421,
+    instrux + 3422,
+};
+
+static const struct itemplate * const itable_vex0316B[] = {
+    instrux + 3415,
+    instrux + 3416,
+    instrux + 3417,
+    instrux + 3418,
+};
+
+static const struct itemplate * const itable_vex0316C[] = {
+    instrux + 3463,
+    instrux + 3464,
+    instrux + 3465,
+    instrux + 3466,
+    instrux + 3467,
+    instrux + 3468,
+    instrux + 3469,
+    instrux + 3470,
+};
+
+static const struct itemplate * const itable_vex0316D[] = {
+    instrux + 3455,
+    instrux + 3456,
+    instrux + 3457,
+    instrux + 3458,
+    instrux + 3459,
+    instrux + 3460,
+    instrux + 3461,
+    instrux + 3462,
+};
+
+static const struct itemplate * const itable_vex0316E[] = {
+    instrux + 3475,
+    instrux + 3476,
+    instrux + 3477,
+    instrux + 3478,
+};
+
+static const struct itemplate * const itable_vex0316F[] = {
+    instrux + 3471,
+    instrux + 3472,
+    instrux + 3473,
+    instrux + 3474,
+};
+
+static const struct itemplate * const itable_vex03178[] = {
+    instrux + 3487,
+    instrux + 3488,
+    instrux + 3489,
+    instrux + 3490,
+    instrux + 3491,
+    instrux + 3492,
+    instrux + 3493,
+    instrux + 3494,
+};
+
+static const struct itemplate * const itable_vex03179[] = {
+    instrux + 3479,
+    instrux + 3480,
+    instrux + 3481,
+    instrux + 3482,
+    instrux + 3483,
+    instrux + 3484,
+    instrux + 3485,
+    instrux + 3486,
+};
+
+static const struct itemplate * const itable_vex0317A[] = {
+    instrux + 3499,
+    instrux + 3500,
+    instrux + 3501,
+    instrux + 3502,
+};
+
+static const struct itemplate * const itable_vex0317B[] = {
+    instrux + 3495,
+    instrux + 3496,
+    instrux + 3497,
+    instrux + 3498,
+};
+
+static const struct itemplate * const itable_vex0317C[] = {
+    instrux + 3511,
+    instrux + 3512,
+    instrux + 3513,
+    instrux + 3514,
+    instrux + 3515,
+    instrux + 3516,
+    instrux + 3517,
+    instrux + 3518,
+};
+
+static const struct itemplate * const itable_vex0317D[] = {
+    instrux + 3503,
+    instrux + 3504,
+    instrux + 3505,
+    instrux + 3506,
+    instrux + 3507,
+    instrux + 3508,
+    instrux + 3509,
+    instrux + 3510,
+};
+
+static const struct itemplate * const itable_vex0317E[] = {
+    instrux + 3523,
+    instrux + 3524,
+    instrux + 3525,
+    instrux + 3526,
+};
+
+static const struct itemplate * const itable_vex0317F[] = {
+    instrux + 3519,
+    instrux + 3520,
+    instrux + 3521,
+    instrux + 3522,
+};
+
+static const struct itemplate * const itable_vex031CE[] = {
+    instrux + 6806,
+    instrux + 6807,
+    instrux + 6808,
+    instrux + 6809,
+};
+
+static const struct itemplate * const itable_vex031CF[] = {
+    instrux + 6795,
+    instrux + 6796,
+    instrux + 6797,
+    instrux + 6798,
+};
+
+static const struct itemplate * const itable_vex031DF[] = {
+    instrux + 1892,
+};
+
+static const struct itemplate * const itable_vex033F0[] = {
+    instrux + 4025,
+    instrux + 4026,
+};
+
+static const struct itemplate * const itable_xop08085[] = {
+    instrux + 3607,
+    instrux + 3608,
+};
+
+static const struct itemplate * const itable_xop08086[] = {
+    instrux + 3605,
+    instrux + 3606,
+};
+
+static const struct itemplate * const itable_xop08087[] = {
+    instrux + 3603,
+    instrux + 3604,
+};
+
+static const struct itemplate * const itable_xop0808E[] = {
+    instrux + 3599,
+    instrux + 3600,
+};
+
+static const struct itemplate * const itable_xop0808F[] = {
+    instrux + 3601,
+    instrux + 3602,
+};
+
+static const struct itemplate * const itable_xop08095[] = {
+    instrux + 3611,
+    instrux + 3612,
+};
+
+static const struct itemplate * const itable_xop08096[] = {
+    instrux + 3609,
+    instrux + 3610,
+};
+
+static const struct itemplate * const itable_xop08097[] = {
+    instrux + 3597,
+    instrux + 3598,
+};
+
+static const struct itemplate * const itable_xop0809E[] = {
+    instrux + 3593,
+    instrux + 3594,
+};
+
+static const struct itemplate * const itable_xop0809F[] = {
+    instrux + 3595,
+    instrux + 3596,
+};
+
+static const struct itemplate * const itable_xop080A2[] = {
+    instrux + 3539,
+    instrux + 3540,
+    instrux + 3541,
+    instrux + 3542,
+    instrux + 3543,
+    instrux + 3544,
+    instrux + 3545,
+    instrux + 3546,
+};
+
+static const struct itemplate * const itable_xop080A3[] = {
+    instrux + 3617,
+    instrux + 3618,
+    instrux + 3619,
+    instrux + 3620,
+};
+
+static const struct itemplate * const itable_xop080A6[] = {
+    instrux + 3613,
+    instrux + 3614,
+};
+
+static const struct itemplate * const itable_xop080B6[] = {
+    instrux + 3615,
+    instrux + 3616,
+};
+
+static const struct itemplate * const itable_xop080C0[] = {
+    instrux + 3625,
+    instrux + 3626,
+};
+
+static const struct itemplate * const itable_xop080C1[] = {
+    instrux + 3643,
+    instrux + 3644,
+};
+
+static const struct itemplate * const itable_xop080C2[] = {
+    instrux + 3631,
+    instrux + 3632,
+};
+
+static const struct itemplate * const itable_xop080C3[] = {
+    instrux + 3637,
+    instrux + 3638,
+};
+
+static const struct itemplate * const itable_xop080CC[] = {
+    instrux + 3547,
+    instrux + 3548,
+};
+
+static const struct itemplate * const itable_xop080CD[] = {
+    instrux + 3561,
+    instrux + 3562,
+};
+
+static const struct itemplate * const itable_xop080CE[] = {
+    instrux + 3549,
+    instrux + 3550,
+};
+
+static const struct itemplate * const itable_xop080CF[] = {
+    instrux + 3551,
+    instrux + 3552,
+};
+
+static const struct itemplate * const itable_xop080EC[] = {
+    instrux + 3553,
+    instrux + 3554,
+};
+
+static const struct itemplate * const itable_xop080ED[] = {
+    instrux + 3559,
+    instrux + 3560,
+};
+
+static const struct itemplate * const itable_xop080EE[] = {
+    instrux + 3555,
+    instrux + 3556,
+};
+
+static const struct itemplate * const itable_xop080EF[] = {
+    instrux + 3557,
+    instrux + 3558,
+};
+
+static const struct itemplate * const itable_xop09001[] = {
+    instrux + 3999,
+    instrux + 4000,
+    instrux + 4003,
+    instrux + 4004,
+    instrux + 4005,
+    instrux + 4006,
+    instrux + 4007,
+    instrux + 4008,
+    instrux + 4015,
+    instrux + 4016,
+    instrux + 4036,
+    instrux + 4037,
+    instrux + 4038,
+    instrux + 4039,
+};
+
+static const struct itemplate * const itable_xop09002[] = {
+    instrux + 3997,
+    instrux + 3998,
+    instrux + 4009,
+    instrux + 4010,
+};
+
+static const struct itemplate * const itable_xop09012[] = {
+    instrux + 3391,
+    instrux + 3392,
+    instrux + 3393,
+    instrux + 3394,
+};
+
+static const struct itemplate * const itable_xop09080[] = {
+    instrux + 3531,
+    instrux + 3532,
+    instrux + 3533,
+    instrux + 3534,
+};
+
+static const struct itemplate * const itable_xop09081[] = {
+    instrux + 3527,
+    instrux + 3528,
+    instrux + 3529,
+    instrux + 3530,
+};
+
+static const struct itemplate * const itable_xop09082[] = {
+    instrux + 3537,
+    instrux + 3538,
+};
+
+static const struct itemplate * const itable_xop09083[] = {
+    instrux + 3535,
+    instrux + 3536,
+};
+
+static const struct itemplate * const itable_xop09090[] = {
+    instrux + 3621,
+    instrux + 3622,
+    instrux + 3623,
+    instrux + 3624,
+};
+
+static const struct itemplate * const itable_xop09091[] = {
+    instrux + 3639,
+    instrux + 3640,
+    instrux + 3641,
+    instrux + 3642,
+};
+
+static const struct itemplate * const itable_xop09092[] = {
+    instrux + 3627,
+    instrux + 3628,
+    instrux + 3629,
+    instrux + 3630,
+};
+
+static const struct itemplate * const itable_xop09093[] = {
+    instrux + 3633,
+    instrux + 3634,
+    instrux + 3635,
+    instrux + 3636,
+};
+
+static const struct itemplate * const itable_xop09094[] = {
+    instrux + 3661,
+    instrux + 3662,
+    instrux + 3663,
+    instrux + 3664,
+};
+
+static const struct itemplate * const itable_xop09095[] = {
+    instrux + 3673,
+    instrux + 3674,
+    instrux + 3675,
+    instrux + 3676,
+};
+
+static const struct itemplate * const itable_xop09096[] = {
+    instrux + 3665,
+    instrux + 3666,
+    instrux + 3667,
+    instrux + 3668,
+};
+
+static const struct itemplate * const itable_xop09097[] = {
+    instrux + 3669,
+    instrux + 3670,
+    instrux + 3671,
+    instrux + 3672,
+};
+
+static const struct itemplate * const itable_xop09098[] = {
+    instrux + 3645,
+    instrux + 3646,
+    instrux + 3647,
+    instrux + 3648,
+};
+
+static const struct itemplate * const itable_xop09099[] = {
+    instrux + 3657,
+    instrux + 3658,
+    instrux + 3659,
+    instrux + 3660,
+};
+
+static const struct itemplate * const itable_xop0909A[] = {
+    instrux + 3649,
+    instrux + 3650,
+    instrux + 3651,
+    instrux + 3652,
+};
+
+static const struct itemplate * const itable_xop0909B[] = {
+    instrux + 3653,
+    instrux + 3654,
+    instrux + 3655,
+    instrux + 3656,
+};
+
+static const struct itemplate * const itable_xop090C1[] = {
+    instrux + 3567,
+    instrux + 3568,
+};
+
+static const struct itemplate * const itable_xop090C2[] = {
+    instrux + 3563,
+    instrux + 3564,
+};
+
+static const struct itemplate * const itable_xop090C3[] = {
+    instrux + 3565,
+    instrux + 3566,
+};
+
+static const struct itemplate * const itable_xop090C6[] = {
+    instrux + 3583,
+    instrux + 3584,
+};
+
+static const struct itemplate * const itable_xop090C7[] = {
+    instrux + 3585,
+    instrux + 3586,
+};
+
+static const struct itemplate * const itable_xop090CB[] = {
+    instrux + 3569,
+    instrux + 3570,
+};
+
+static const struct itemplate * const itable_xop090D1[] = {
+    instrux + 3575,
+    instrux + 3576,
+};
+
+static const struct itemplate * const itable_xop090D2[] = {
+    instrux + 3571,
+    instrux + 3572,
+};
+
+static const struct itemplate * const itable_xop090D3[] = {
+    instrux + 3573,
+    instrux + 3574,
+};
+
+static const struct itemplate * const itable_xop090D6[] = {
+    instrux + 3579,
+    instrux + 3580,
+};
+
+static const struct itemplate * const itable_xop090D7[] = {
+    instrux + 3581,
+    instrux + 3582,
+};
+
+static const struct itemplate * const itable_xop090DB[] = {
+    instrux + 3577,
+    instrux + 3578,
+};
+
+static const struct itemplate * const itable_xop090E1[] = {
+    instrux + 3587,
+    instrux + 3588,
+};
+
+static const struct itemplate * const itable_xop090E2[] = {
+    instrux + 3591,
+    instrux + 3592,
+};
+
+static const struct itemplate * const itable_xop090E3[] = {
+    instrux + 3589,
+    instrux + 3590,
+};
+
+static const struct itemplate * const itable_xop0A010[] = {
+    instrux + 3995,
+    instrux + 3996,
+};
+
+static const struct itemplate * const itable_xop0A012[] = {
+    instrux + 3395,
+    instrux + 3396,
+    instrux + 3397,
+    instrux + 3398,
+};
+
+static const struct disasm_index itable_vex010[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_vex01010, 2 },
+    /* 0x11 */ { itable_vex01011, 2 },
+    /* 0x12 */ { itable_vex01012, 4 },
+    /* 0x13 */ { itable_vex01013, 1 },
+    /* 0x14 */ { itable_vex01014, 4 },
+    /* 0x15 */ { itable_vex01015, 4 },
+    /* 0x16 */ { itable_vex01016, 4 },
+    /* 0x17 */ { itable_vex01017, 1 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_vex01028, 2 },
+    /* 0x29 */ { itable_vex01029, 2 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { itable_vex0102B, 2 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { itable_vex0102E, 1 },
+    /* 0x2f */ { itable_vex0102F, 1 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { itable_vex01041, 2 },
+    /* 0x42 */ { itable_vex01042, 2 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { itable_vex01044, 2 },
+    /* 0x45 */ { itable_vex01045, 2 },
+    /* 0x46 */ { itable_vex01046, 2 },
+    /* 0x47 */ { itable_vex01047, 2 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { itable_vex0104A, 2 },
+    /* 0x4b */ { itable_vex0104B, 2 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { itable_vex01050, 4 },
+    /* 0x51 */ { itable_vex01051, 2 },
+    /* 0x52 */ { itable_vex01052, 2 },
+    /* 0x53 */ { itable_vex01053, 2 },
+    /* 0x54 */ { itable_vex01054, 4 },
+    /* 0x55 */ { itable_vex01055, 4 },
+    /* 0x56 */ { itable_vex01056, 4 },
+    /* 0x57 */ { itable_vex01057, 4 },
+    /* 0x58 */ { itable_vex01058, 4 },
+    /* 0x59 */ { itable_vex01059, 4 },
+    /* 0x5a */ { itable_vex0105A, 2 },
+    /* 0x5b */ { itable_vex0105B, 2 },
+    /* 0x5c */ { itable_vex0105C, 4 },
+    /* 0x5d */ { itable_vex0105D, 4 },
+    /* 0x5e */ { itable_vex0105E, 4 },
+    /* 0x5f */ { itable_vex0105F, 4 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { itable_vex01077, 2 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { itable_vex01090, 2 },
+    /* 0x91 */ { itable_vex01091, 2 },
+    /* 0x92 */ { itable_vex01092, 1 },
+    /* 0x93 */ { itable_vex01093, 1 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { itable_vex01098, 2 },
+    /* 0x99 */ { itable_vex01099, 2 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { itable_vex010AE, 2 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_vex010C2, 188 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { itable_vex010C6, 4 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex011[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_vex01110, 2 },
+    /* 0x11 */ { itable_vex01111, 2 },
+    /* 0x12 */ { itable_vex01112, 2 },
+    /* 0x13 */ { itable_vex01113, 1 },
+    /* 0x14 */ { itable_vex01114, 4 },
+    /* 0x15 */ { itable_vex01115, 4 },
+    /* 0x16 */ { itable_vex01116, 2 },
+    /* 0x17 */ { itable_vex01117, 1 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_vex01128, 2 },
+    /* 0x29 */ { itable_vex01129, 2 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { itable_vex0112B, 2 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { itable_vex0112E, 1 },
+    /* 0x2f */ { itable_vex0112F, 1 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { itable_vex01141, 2 },
+    /* 0x42 */ { itable_vex01142, 2 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { itable_vex01144, 2 },
+    /* 0x45 */ { itable_vex01145, 2 },
+    /* 0x46 */ { itable_vex01146, 2 },
+    /* 0x47 */ { itable_vex01147, 2 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { itable_vex0114A, 2 },
+    /* 0x4b */ { itable_vex0114B, 1 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { itable_vex01150, 4 },
+    /* 0x51 */ { itable_vex01151, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { itable_vex01154, 4 },
+    /* 0x55 */ { itable_vex01155, 4 },
+    /* 0x56 */ { itable_vex01156, 4 },
+    /* 0x57 */ { itable_vex01157, 4 },
+    /* 0x58 */ { itable_vex01158, 4 },
+    /* 0x59 */ { itable_vex01159, 4 },
+    /* 0x5a */ { itable_vex0115A, 4 },
+    /* 0x5b */ { itable_vex0115B, 2 },
+    /* 0x5c */ { itable_vex0115C, 4 },
+    /* 0x5d */ { itable_vex0115D, 4 },
+    /* 0x5e */ { itable_vex0115E, 4 },
+    /* 0x5f */ { itable_vex0115F, 4 },
+    /* 0x60 */ { itable_vex01160, 4 },
+    /* 0x61 */ { itable_vex01161, 4 },
+    /* 0x62 */ { itable_vex01162, 4 },
+    /* 0x63 */ { itable_vex01163, 4 },
+    /* 0x64 */ { itable_vex01164, 4 },
+    /* 0x65 */ { itable_vex01165, 4 },
+    /* 0x66 */ { itable_vex01166, 4 },
+    /* 0x67 */ { itable_vex01167, 4 },
+    /* 0x68 */ { itable_vex01168, 4 },
+    /* 0x69 */ { itable_vex01169, 4 },
+    /* 0x6a */ { itable_vex0116A, 4 },
+    /* 0x6b */ { itable_vex0116B, 4 },
+    /* 0x6c */ { itable_vex0116C, 4 },
+    /* 0x6d */ { itable_vex0116D, 4 },
+    /* 0x6e */ { itable_vex0116E, 2 },
+    /* 0x6f */ { itable_vex0116F, 3 },
+    /* 0x70 */ { itable_vex01170, 2 },
+    /* 0x71 */ { itable_vex01171, 12 },
+    /* 0x72 */ { itable_vex01172, 12 },
+    /* 0x73 */ { itable_vex01173, 16 },
+    /* 0x74 */ { itable_vex01174, 4 },
+    /* 0x75 */ { itable_vex01175, 4 },
+    /* 0x76 */ { itable_vex01176, 4 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { itable_vex0117C, 4 },
+    /* 0x7d */ { itable_vex0117D, 4 },
+    /* 0x7e */ { itable_vex0117E, 2 },
+    /* 0x7f */ { itable_vex0117F, 3 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { itable_vex01190, 2 },
+    /* 0x91 */ { itable_vex01191, 2 },
+    /* 0x92 */ { itable_vex01192, 1 },
+    /* 0x93 */ { itable_vex01193, 1 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { itable_vex01198, 2 },
+    /* 0x99 */ { itable_vex01199, 2 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_vex011C2, 188 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { itable_vex011C4, 6 },
+    /* 0xc5 */ { itable_vex011C5, 2 },
+    /* 0xc6 */ { itable_vex011C6, 4 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { itable_vex011D0, 4 },
+    /* 0xd1 */ { itable_vex011D1, 4 },
+    /* 0xd2 */ { itable_vex011D2, 4 },
+    /* 0xd3 */ { itable_vex011D3, 4 },
+    /* 0xd4 */ { itable_vex011D4, 4 },
+    /* 0xd5 */ { itable_vex011D5, 4 },
+    /* 0xd6 */ { itable_vex011D6, 1 },
+    /* 0xd7 */ { itable_vex011D7, 4 },
+    /* 0xd8 */ { itable_vex011D8, 4 },
+    /* 0xd9 */ { itable_vex011D9, 4 },
+    /* 0xda */ { itable_vex011DA, 4 },
+    /* 0xdb */ { itable_vex011DB, 4 },
+    /* 0xdc */ { itable_vex011DC, 4 },
+    /* 0xdd */ { itable_vex011DD, 4 },
+    /* 0xde */ { itable_vex011DE, 4 },
+    /* 0xdf */ { itable_vex011DF, 4 },
+    /* 0xe0 */ { itable_vex011E0, 4 },
+    /* 0xe1 */ { itable_vex011E1, 4 },
+    /* 0xe2 */ { itable_vex011E2, 4 },
+    /* 0xe3 */ { itable_vex011E3, 4 },
+    /* 0xe4 */ { itable_vex011E4, 4 },
+    /* 0xe5 */ { itable_vex011E5, 4 },
+    /* 0xe6 */ { itable_vex011E6, 4 },
+    /* 0xe7 */ { itable_vex011E7, 3 },
+    /* 0xe8 */ { itable_vex011E8, 4 },
+    /* 0xe9 */ { itable_vex011E9, 4 },
+    /* 0xea */ { itable_vex011EA, 4 },
+    /* 0xeb */ { itable_vex011EB, 4 },
+    /* 0xec */ { itable_vex011EC, 4 },
+    /* 0xed */ { itable_vex011ED, 4 },
+    /* 0xee */ { itable_vex011EE, 4 },
+    /* 0xef */ { itable_vex011EF, 4 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { itable_vex011F1, 4 },
+    /* 0xf2 */ { itable_vex011F2, 4 },
+    /* 0xf3 */ { itable_vex011F3, 4 },
+    /* 0xf4 */ { itable_vex011F4, 4 },
+    /* 0xf5 */ { itable_vex011F5, 4 },
+    /* 0xf6 */ { itable_vex011F6, 4 },
+    /* 0xf7 */ { itable_vex011F7, 1 },
+    /* 0xf8 */ { itable_vex011F8, 4 },
+    /* 0xf9 */ { itable_vex011F9, 4 },
+    /* 0xfa */ { itable_vex011FA, 4 },
+    /* 0xfb */ { itable_vex011FB, 4 },
+    /* 0xfc */ { itable_vex011FC, 4 },
+    /* 0xfd */ { itable_vex011FD, 4 },
+    /* 0xfe */ { itable_vex011FE, 4 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex012[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_vex01210, 3 },
+    /* 0x11 */ { itable_vex01211, 3 },
+    /* 0x12 */ { itable_vex01212, 2 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { itable_vex01216, 2 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { itable_vex0122A, 4 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { itable_vex0122C, 2 },
+    /* 0x2d */ { itable_vex0122D, 2 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_vex01251, 2 },
+    /* 0x52 */ { itable_vex01252, 2 },
+    /* 0x53 */ { itable_vex01253, 2 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_vex01258, 2 },
+    /* 0x59 */ { itable_vex01259, 2 },
+    /* 0x5a */ { itable_vex0125A, 2 },
+    /* 0x5b */ { itable_vex0125B, 2 },
+    /* 0x5c */ { itable_vex0125C, 2 },
+    /* 0x5d */ { itable_vex0125D, 2 },
+    /* 0x5e */ { itable_vex0125E, 2 },
+    /* 0x5f */ { itable_vex0125F, 2 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { itable_vex0126F, 3 },
+    /* 0x70 */ { itable_vex01270, 2 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { itable_vex0127E, 1 },
+    /* 0x7f */ { itable_vex0127F, 3 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_vex012C2, 94 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { itable_vex012E6, 2 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex013[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_vex01310, 3 },
+    /* 0x11 */ { itable_vex01311, 3 },
+    /* 0x12 */ { itable_vex01312, 2 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { itable_vex0132A, 4 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { itable_vex0132C, 2 },
+    /* 0x2d */ { itable_vex0132D, 2 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_vex01351, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_vex01358, 2 },
+    /* 0x59 */ { itable_vex01359, 2 },
+    /* 0x5a */ { itable_vex0135A, 2 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { itable_vex0135C, 2 },
+    /* 0x5d */ { itable_vex0135D, 2 },
+    /* 0x5e */ { itable_vex0135E, 2 },
+    /* 0x5f */ { itable_vex0135F, 2 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { itable_vex01370, 2 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { itable_vex0137C, 4 },
+    /* 0x7d */ { itable_vex0137D, 4 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { itable_vex01392, 2 },
+    /* 0x93 */ { itable_vex01393, 2 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_vex013C2, 94 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { itable_vex013D0, 4 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { itable_vex013E6, 4 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { itable_vex013F0, 3 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex020[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { itable_vex02049, 2 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { itable_vex02050, 2 },
+    /* 0x51 */ { itable_vex02051, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { itable_vex0205E, 1 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { itable_vex020B0, 2 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { itable_vex020F2, 2 },
+    /* 0xf3 */ { itable_vex020F3, 6 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { itable_vex020F5, 2 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { itable_vex020F7, 2 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex021[256] = {
+    /* 0x00 */ { itable_vex02100, 4 },
+    /* 0x01 */ { itable_vex02101, 4 },
+    /* 0x02 */ { itable_vex02102, 4 },
+    /* 0x03 */ { itable_vex02103, 4 },
+    /* 0x04 */ { itable_vex02104, 4 },
+    /* 0x05 */ { itable_vex02105, 4 },
+    /* 0x06 */ { itable_vex02106, 4 },
+    /* 0x07 */ { itable_vex02107, 4 },
+    /* 0x08 */ { itable_vex02108, 4 },
+    /* 0x09 */ { itable_vex02109, 4 },
+    /* 0x0a */ { itable_vex0210A, 4 },
+    /* 0x0b */ { itable_vex0210B, 4 },
+    /* 0x0c */ { itable_vex0210C, 4 },
+    /* 0x0d */ { itable_vex0210D, 4 },
+    /* 0x0e */ { itable_vex0210E, 2 },
+    /* 0x0f */ { itable_vex0210F, 2 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { itable_vex02113, 4 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { itable_vex02116, 2 },
+    /* 0x17 */ { itable_vex02117, 2 },
+    /* 0x18 */ { itable_vex02118, 4 },
+    /* 0x19 */ { itable_vex02119, 2 },
+    /* 0x1a */ { itable_vex0211A, 1 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { itable_vex0211C, 2 },
+    /* 0x1d */ { itable_vex0211D, 2 },
+    /* 0x1e */ { itable_vex0211E, 2 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { itable_vex02120, 2 },
+    /* 0x21 */ { itable_vex02121, 3 },
+    /* 0x22 */ { itable_vex02122, 3 },
+    /* 0x23 */ { itable_vex02123, 2 },
+    /* 0x24 */ { itable_vex02124, 3 },
+    /* 0x25 */ { itable_vex02125, 2 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_vex02128, 4 },
+    /* 0x29 */ { itable_vex02129, 4 },
+    /* 0x2a */ { itable_vex0212A, 2 },
+    /* 0x2b */ { itable_vex0212B, 4 },
+    /* 0x2c */ { itable_vex0212C, 2 },
+    /* 0x2d */ { itable_vex0212D, 2 },
+    /* 0x2e */ { itable_vex0212E, 2 },
+    /* 0x2f */ { itable_vex0212F, 2 },
+    /* 0x30 */ { itable_vex02130, 2 },
+    /* 0x31 */ { itable_vex02131, 3 },
+    /* 0x32 */ { itable_vex02132, 3 },
+    /* 0x33 */ { itable_vex02133, 2 },
+    /* 0x34 */ { itable_vex02134, 3 },
+    /* 0x35 */ { itable_vex02135, 2 },
+    /* 0x36 */ { itable_vex02136, 2 },
+    /* 0x37 */ { itable_vex02137, 4 },
+    /* 0x38 */ { itable_vex02138, 4 },
+    /* 0x39 */ { itable_vex02139, 4 },
+    /* 0x3a */ { itable_vex0213A, 4 },
+    /* 0x3b */ { itable_vex0213B, 4 },
+    /* 0x3c */ { itable_vex0213C, 4 },
+    /* 0x3d */ { itable_vex0213D, 4 },
+    /* 0x3e */ { itable_vex0213E, 4 },
+    /* 0x3f */ { itable_vex0213F, 4 },
+    /* 0x40 */ { itable_vex02140, 4 },
+    /* 0x41 */ { itable_vex02141, 1 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { itable_vex02145, 8 },
+    /* 0x46 */ { itable_vex02146, 4 },
+    /* 0x47 */ { itable_vex02147, 8 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { itable_vex02149, 1 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { itable_vex0214B, 1 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_vex02158, 4 },
+    /* 0x59 */ { itable_vex02159, 4 },
+    /* 0x5a */ { itable_vex0215A, 1 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { itable_vex0215E, 1 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_vex02178, 4 },
+    /* 0x79 */ { itable_vex02179, 4 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { itable_vex0218C, 8 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { itable_vex0218E, 8 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { itable_vex02190, 4 },
+    /* 0x91 */ { itable_vex02191, 4 },
+    /* 0x92 */ { itable_vex02192, 4 },
+    /* 0x93 */ { itable_vex02193, 4 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { itable_vex02196, 8 },
+    /* 0x97 */ { itable_vex02197, 8 },
+    /* 0x98 */ { itable_vex02198, 8 },
+    /* 0x99 */ { itable_vex02199, 4 },
+    /* 0x9a */ { itable_vex0219A, 8 },
+    /* 0x9b */ { itable_vex0219B, 4 },
+    /* 0x9c */ { itable_vex0219C, 8 },
+    /* 0x9d */ { itable_vex0219D, 4 },
+    /* 0x9e */ { itable_vex0219E, 8 },
+    /* 0x9f */ { itable_vex0219F, 4 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { itable_vex021A6, 8 },
+    /* 0xa7 */ { itable_vex021A7, 8 },
+    /* 0xa8 */ { itable_vex021A8, 8 },
+    /* 0xa9 */ { itable_vex021A9, 4 },
+    /* 0xaa */ { itable_vex021AA, 8 },
+    /* 0xab */ { itable_vex021AB, 4 },
+    /* 0xac */ { itable_vex021AC, 8 },
+    /* 0xad */ { itable_vex021AD, 4 },
+    /* 0xae */ { itable_vex021AE, 8 },
+    /* 0xaf */ { itable_vex021AF, 4 },
+    /* 0xb0 */ { itable_vex021B0, 2 },
+    /* 0xb1 */ { itable_vex021B1, 2 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { itable_vex021B4, 2 },
+    /* 0xb5 */ { itable_vex021B5, 2 },
+    /* 0xb6 */ { itable_vex021B6, 8 },
+    /* 0xb7 */ { itable_vex021B7, 8 },
+    /* 0xb8 */ { itable_vex021B8, 8 },
+    /* 0xb9 */ { itable_vex021B9, 4 },
+    /* 0xba */ { itable_vex021BA, 8 },
+    /* 0xbb */ { itable_vex021BB, 4 },
+    /* 0xbc */ { itable_vex021BC, 8 },
+    /* 0xbd */ { itable_vex021BD, 4 },
+    /* 0xbe */ { itable_vex021BE, 8 },
+    /* 0xbf */ { itable_vex021BF, 4 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { itable_vex021CF, 4 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { itable_vex021DB, 1 },
+    /* 0xdc */ { itable_vex021DC, 4 },
+    /* 0xdd */ { itable_vex021DD, 4 },
+    /* 0xde */ { itable_vex021DE, 4 },
+    /* 0xdf */ { itable_vex021DF, 4 },
+    /* 0xe0 */ { itable_vex021E0, 2 },
+    /* 0xe1 */ { itable_vex021E1, 2 },
+    /* 0xe2 */ { itable_vex021E2, 2 },
+    /* 0xe3 */ { itable_vex021E3, 2 },
+    /* 0xe4 */ { itable_vex021E4, 2 },
+    /* 0xe5 */ { itable_vex021E5, 2 },
+    /* 0xe6 */ { itable_vex021E6, 2 },
+    /* 0xe7 */ { itable_vex021E7, 2 },
+    /* 0xe8 */ { itable_vex021E8, 2 },
+    /* 0xe9 */ { itable_vex021E9, 2 },
+    /* 0xea */ { itable_vex021EA, 2 },
+    /* 0xeb */ { itable_vex021EB, 2 },
+    /* 0xec */ { itable_vex021EC, 2 },
+    /* 0xed */ { itable_vex021ED, 2 },
+    /* 0xee */ { itable_vex021EE, 2 },
+    /* 0xef */ { itable_vex021EF, 2 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { itable_vex021F7, 2 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex022[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { itable_vex0224B, 1 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { itable_vex02250, 2 },
+    /* 0x51 */ { itable_vex02251, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { itable_vex0225C, 1 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { itable_vex0225E, 1 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { itable_vex02272, 2 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { itable_vex022B0, 2 },
+    /* 0xb1 */ { itable_vex022B1, 2 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { itable_vex022F5, 2 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { itable_vex022F7, 2 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex023[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { itable_vex02349, 1 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { itable_vex0234B, 1 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { itable_vex02350, 2 },
+    /* 0x51 */ { itable_vex02351, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { itable_vex0235E, 1 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { itable_vex023B0, 2 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { itable_vex023F5, 2 },
+    /* 0xf6 */ { itable_vex023F6, 2 },
+    /* 0xf7 */ { itable_vex023F7, 2 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex031[256] = {
+    /* 0x00 */ { itable_vex03100, 1 },
+    /* 0x01 */ { itable_vex03101, 1 },
+    /* 0x02 */ { itable_vex03102, 4 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { itable_vex03104, 2 },
+    /* 0x05 */ { itable_vex03105, 2 },
+    /* 0x06 */ { itable_vex03106, 2 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { itable_vex03108, 2 },
+    /* 0x09 */ { itable_vex03109, 2 },
+    /* 0x0a */ { itable_vex0310A, 2 },
+    /* 0x0b */ { itable_vex0310B, 2 },
+    /* 0x0c */ { itable_vex0310C, 4 },
+    /* 0x0d */ { itable_vex0310D, 4 },
+    /* 0x0e */ { itable_vex0310E, 4 },
+    /* 0x0f */ { itable_vex0310F, 4 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { itable_vex03114, 3 },
+    /* 0x15 */ { itable_vex03115, 3 },
+    /* 0x16 */ { itable_vex03116, 3 },
+    /* 0x17 */ { itable_vex03117, 1 },
+    /* 0x18 */ { itable_vex03118, 2 },
+    /* 0x19 */ { itable_vex03119, 1 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { itable_vex0311D, 4 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { itable_vex03120, 6 },
+    /* 0x21 */ { itable_vex03121, 2 },
+    /* 0x22 */ { itable_vex03122, 8 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { itable_vex03130, 2 },
+    /* 0x31 */ { itable_vex03131, 2 },
+    /* 0x32 */ { itable_vex03132, 2 },
+    /* 0x33 */ { itable_vex03133, 2 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { itable_vex03138, 2 },
+    /* 0x39 */ { itable_vex03139, 1 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { itable_vex03140, 4 },
+    /* 0x41 */ { itable_vex03141, 2 },
+    /* 0x42 */ { itable_vex03142, 4 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { itable_vex03144, 20 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { itable_vex03146, 2 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { itable_vex0314A, 4 },
+    /* 0x4b */ { itable_vex0314B, 4 },
+    /* 0x4c */ { itable_vex0314C, 4 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { itable_vex0315C, 8 },
+    /* 0x5d */ { itable_vex0315D, 8 },
+    /* 0x5e */ { itable_vex0315E, 8 },
+    /* 0x5f */ { itable_vex0315F, 8 },
+    /* 0x60 */ { itable_vex03160, 1 },
+    /* 0x61 */ { itable_vex03161, 1 },
+    /* 0x62 */ { itable_vex03162, 1 },
+    /* 0x63 */ { itable_vex03163, 1 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { itable_vex03168, 8 },
+    /* 0x69 */ { itable_vex03169, 8 },
+    /* 0x6a */ { itable_vex0316A, 4 },
+    /* 0x6b */ { itable_vex0316B, 4 },
+    /* 0x6c */ { itable_vex0316C, 8 },
+    /* 0x6d */ { itable_vex0316D, 8 },
+    /* 0x6e */ { itable_vex0316E, 4 },
+    /* 0x6f */ { itable_vex0316F, 4 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_vex03178, 8 },
+    /* 0x79 */ { itable_vex03179, 8 },
+    /* 0x7a */ { itable_vex0317A, 4 },
+    /* 0x7b */ { itable_vex0317B, 4 },
+    /* 0x7c */ { itable_vex0317C, 8 },
+    /* 0x7d */ { itable_vex0317D, 8 },
+    /* 0x7e */ { itable_vex0317E, 4 },
+    /* 0x7f */ { itable_vex0317F, 4 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { itable_vex031CE, 4 },
+    /* 0xcf */ { itable_vex031CF, 4 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { itable_vex031DF, 1 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_vex033[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { itable_vex033F0, 2 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_xop080[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { itable_xop08085, 2 },
+    /* 0x86 */ { itable_xop08086, 2 },
+    /* 0x87 */ { itable_xop08087, 2 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { itable_xop0808E, 2 },
+    /* 0x8f */ { itable_xop0808F, 2 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { itable_xop08095, 2 },
+    /* 0x96 */ { itable_xop08096, 2 },
+    /* 0x97 */ { itable_xop08097, 2 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { itable_xop0809E, 2 },
+    /* 0x9f */ { itable_xop0809F, 2 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { itable_xop080A2, 8 },
+    /* 0xa3 */ { itable_xop080A3, 4 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { itable_xop080A6, 2 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { itable_xop080B6, 2 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { itable_xop080C0, 2 },
+    /* 0xc1 */ { itable_xop080C1, 2 },
+    /* 0xc2 */ { itable_xop080C2, 2 },
+    /* 0xc3 */ { itable_xop080C3, 2 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { itable_xop080CC, 2 },
+    /* 0xcd */ { itable_xop080CD, 2 },
+    /* 0xce */ { itable_xop080CE, 2 },
+    /* 0xcf */ { itable_xop080CF, 2 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { itable_xop080EC, 2 },
+    /* 0xed */ { itable_xop080ED, 2 },
+    /* 0xee */ { itable_xop080EE, 2 },
+    /* 0xef */ { itable_xop080EF, 2 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_xop090[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { itable_xop09001, 14 },
+    /* 0x02 */ { itable_xop09002, 4 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { itable_xop09012, 4 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { itable_xop09080, 4 },
+    /* 0x81 */ { itable_xop09081, 4 },
+    /* 0x82 */ { itable_xop09082, 2 },
+    /* 0x83 */ { itable_xop09083, 2 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { itable_xop09090, 4 },
+    /* 0x91 */ { itable_xop09091, 4 },
+    /* 0x92 */ { itable_xop09092, 4 },
+    /* 0x93 */ { itable_xop09093, 4 },
+    /* 0x94 */ { itable_xop09094, 4 },
+    /* 0x95 */ { itable_xop09095, 4 },
+    /* 0x96 */ { itable_xop09096, 4 },
+    /* 0x97 */ { itable_xop09097, 4 },
+    /* 0x98 */ { itable_xop09098, 4 },
+    /* 0x99 */ { itable_xop09099, 4 },
+    /* 0x9a */ { itable_xop0909A, 4 },
+    /* 0x9b */ { itable_xop0909B, 4 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { itable_xop090C1, 2 },
+    /* 0xc2 */ { itable_xop090C2, 2 },
+    /* 0xc3 */ { itable_xop090C3, 2 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { itable_xop090C6, 2 },
+    /* 0xc7 */ { itable_xop090C7, 2 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { itable_xop090CB, 2 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { itable_xop090D1, 2 },
+    /* 0xd2 */ { itable_xop090D2, 2 },
+    /* 0xd3 */ { itable_xop090D3, 2 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { itable_xop090D6, 2 },
+    /* 0xd7 */ { itable_xop090D7, 2 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { itable_xop090DB, 2 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { itable_xop090E1, 2 },
+    /* 0xe2 */ { itable_xop090E2, 2 },
+    /* 0xe3 */ { itable_xop090E3, 2 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_xop0A0[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_xop0A010, 2 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { itable_xop0A012, 4 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex010[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex01010, 3 },
+    /* 0x11 */ { itable_evex01011, 6 },
+    /* 0x12 */ { itable_evex01012, 4 },
+    /* 0x13 */ { itable_evex01013, 1 },
+    /* 0x14 */ { itable_evex01014, 6 },
+    /* 0x15 */ { itable_evex01015, 6 },
+    /* 0x16 */ { itable_evex01016, 4 },
+    /* 0x17 */ { itable_evex01017, 1 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_evex01028, 3 },
+    /* 0x29 */ { itable_evex01029, 6 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { itable_evex0102B, 3 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { itable_evex0102E, 1 },
+    /* 0x2f */ { itable_evex0102F, 1 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_evex01051, 3 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { itable_evex01054, 6 },
+    /* 0x55 */ { itable_evex01055, 6 },
+    /* 0x56 */ { itable_evex01056, 6 },
+    /* 0x57 */ { itable_evex01057, 6 },
+    /* 0x58 */ { itable_evex01058, 6 },
+    /* 0x59 */ { itable_evex01059, 6 },
+    /* 0x5a */ { itable_evex0105A, 3 },
+    /* 0x5b */ { itable_evex0105B, 6 },
+    /* 0x5c */ { itable_evex0105C, 6 },
+    /* 0x5d */ { itable_evex0105D, 6 },
+    /* 0x5e */ { itable_evex0105E, 6 },
+    /* 0x5f */ { itable_evex0105F, 6 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex01078, 6 },
+    /* 0x79 */ { itable_evex01079, 6 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_evex010C2, 141 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { itable_evex010C6, 6 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex011[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex01110, 3 },
+    /* 0x11 */ { itable_evex01111, 6 },
+    /* 0x12 */ { itable_evex01112, 2 },
+    /* 0x13 */ { itable_evex01113, 1 },
+    /* 0x14 */ { itable_evex01114, 6 },
+    /* 0x15 */ { itable_evex01115, 6 },
+    /* 0x16 */ { itable_evex01116, 2 },
+    /* 0x17 */ { itable_evex01117, 1 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_evex01128, 3 },
+    /* 0x29 */ { itable_evex01129, 6 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { itable_evex0112B, 3 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { itable_evex0112E, 1 },
+    /* 0x2f */ { itable_evex0112F, 1 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_evex01151, 3 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { itable_evex01154, 6 },
+    /* 0x55 */ { itable_evex01155, 6 },
+    /* 0x56 */ { itable_evex01156, 6 },
+    /* 0x57 */ { itable_evex01157, 6 },
+    /* 0x58 */ { itable_evex01158, 6 },
+    /* 0x59 */ { itable_evex01159, 6 },
+    /* 0x5a */ { itable_evex0115A, 3 },
+    /* 0x5b */ { itable_evex0115B, 3 },
+    /* 0x5c */ { itable_evex0115C, 6 },
+    /* 0x5d */ { itable_evex0115D, 6 },
+    /* 0x5e */ { itable_evex0115E, 6 },
+    /* 0x5f */ { itable_evex0115F, 6 },
+    /* 0x60 */ { itable_evex01160, 6 },
+    /* 0x61 */ { itable_evex01161, 6 },
+    /* 0x62 */ { itable_evex01162, 6 },
+    /* 0x63 */ { itable_evex01163, 6 },
+    /* 0x64 */ { itable_evex01164, 3 },
+    /* 0x65 */ { itable_evex01165, 3 },
+    /* 0x66 */ { itable_evex01166, 3 },
+    /* 0x67 */ { itable_evex01167, 6 },
+    /* 0x68 */ { itable_evex01168, 6 },
+    /* 0x69 */ { itable_evex01169, 6 },
+    /* 0x6a */ { itable_evex0116A, 6 },
+    /* 0x6b */ { itable_evex0116B, 6 },
+    /* 0x6c */ { itable_evex0116C, 6 },
+    /* 0x6d */ { itable_evex0116D, 6 },
+    /* 0x6e */ { itable_evex0116E, 2 },
+    /* 0x6f */ { itable_evex0116F, 6 },
+    /* 0x70 */ { itable_evex01170, 3 },
+    /* 0x71 */ { itable_evex01171, 18 },
+    /* 0x72 */ { itable_evex01172, 48 },
+    /* 0x73 */ { itable_evex01173, 24 },
+    /* 0x74 */ { itable_evex01174, 3 },
+    /* 0x75 */ { itable_evex01175, 3 },
+    /* 0x76 */ { itable_evex01176, 3 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex01178, 6 },
+    /* 0x79 */ { itable_evex01179, 6 },
+    /* 0x7a */ { itable_evex0117A, 6 },
+    /* 0x7b */ { itable_evex0117B, 6 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { itable_evex0117E, 2 },
+    /* 0x7f */ { itable_evex0117F, 6 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_evex011C2, 141 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { itable_evex011C4, 4 },
+    /* 0xc5 */ { itable_evex011C5, 3 },
+    /* 0xc6 */ { itable_evex011C6, 6 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { itable_evex011D1, 6 },
+    /* 0xd2 */ { itable_evex011D2, 6 },
+    /* 0xd3 */ { itable_evex011D3, 6 },
+    /* 0xd4 */ { itable_evex011D4, 6 },
+    /* 0xd5 */ { itable_evex011D5, 6 },
+    /* 0xd6 */ { itable_evex011D6, 1 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { itable_evex011D8, 6 },
+    /* 0xd9 */ { itable_evex011D9, 6 },
+    /* 0xda */ { itable_evex011DA, 6 },
+    /* 0xdb */ { itable_evex011DB, 12 },
+    /* 0xdc */ { itable_evex011DC, 6 },
+    /* 0xdd */ { itable_evex011DD, 6 },
+    /* 0xde */ { itable_evex011DE, 6 },
+    /* 0xdf */ { itable_evex011DF, 12 },
+    /* 0xe0 */ { itable_evex011E0, 6 },
+    /* 0xe1 */ { itable_evex011E1, 6 },
+    /* 0xe2 */ { itable_evex011E2, 12 },
+    /* 0xe3 */ { itable_evex011E3, 6 },
+    /* 0xe4 */ { itable_evex011E4, 6 },
+    /* 0xe5 */ { itable_evex011E5, 6 },
+    /* 0xe6 */ { itable_evex011E6, 3 },
+    /* 0xe7 */ { itable_evex011E7, 3 },
+    /* 0xe8 */ { itable_evex011E8, 6 },
+    /* 0xe9 */ { itable_evex011E9, 6 },
+    /* 0xea */ { itable_evex011EA, 6 },
+    /* 0xeb */ { itable_evex011EB, 12 },
+    /* 0xec */ { itable_evex011EC, 6 },
+    /* 0xed */ { itable_evex011ED, 6 },
+    /* 0xee */ { itable_evex011EE, 6 },
+    /* 0xef */ { itable_evex011EF, 12 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { itable_evex011F1, 6 },
+    /* 0xf2 */ { itable_evex011F2, 6 },
+    /* 0xf3 */ { itable_evex011F3, 6 },
+    /* 0xf4 */ { itable_evex011F4, 6 },
+    /* 0xf5 */ { itable_evex011F5, 6 },
+    /* 0xf6 */ { itable_evex011F6, 6 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { itable_evex011F8, 6 },
+    /* 0xf9 */ { itable_evex011F9, 6 },
+    /* 0xfa */ { itable_evex011FA, 6 },
+    /* 0xfb */ { itable_evex011FB, 6 },
+    /* 0xfc */ { itable_evex011FC, 6 },
+    /* 0xfd */ { itable_evex011FD, 6 },
+    /* 0xfe */ { itable_evex011FE, 6 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex012[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex01210, 3 },
+    /* 0x11 */ { itable_evex01211, 3 },
+    /* 0x12 */ { itable_evex01212, 3 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { itable_evex01216, 3 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { itable_evex0122A, 2 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { itable_evex0122C, 2 },
+    /* 0x2d */ { itable_evex0122D, 2 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_evex01251, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_evex01258, 2 },
+    /* 0x59 */ { itable_evex01259, 2 },
+    /* 0x5a */ { itable_evex0125A, 1 },
+    /* 0x5b */ { itable_evex0125B, 3 },
+    /* 0x5c */ { itable_evex0125C, 2 },
+    /* 0x5d */ { itable_evex0125D, 2 },
+    /* 0x5e */ { itable_evex0125E, 2 },
+    /* 0x5f */ { itable_evex0125F, 2 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { itable_evex0126F, 6 },
+    /* 0x70 */ { itable_evex01270, 3 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex01278, 2 },
+    /* 0x79 */ { itable_evex01279, 2 },
+    /* 0x7a */ { itable_evex0127A, 6 },
+    /* 0x7b */ { itable_evex0127B, 2 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { itable_evex0127E, 1 },
+    /* 0x7f */ { itable_evex0127F, 6 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_evex012C2, 47 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { itable_evex012E6, 6 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex013[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex01310, 3 },
+    /* 0x11 */ { itable_evex01311, 3 },
+    /* 0x12 */ { itable_evex01312, 3 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { itable_evex0132A, 2 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { itable_evex0132C, 2 },
+    /* 0x2d */ { itable_evex0132D, 2 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_evex01351, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_evex01358, 2 },
+    /* 0x59 */ { itable_evex01359, 2 },
+    /* 0x5a */ { itable_evex0135A, 1 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { itable_evex0135C, 2 },
+    /* 0x5d */ { itable_evex0135D, 2 },
+    /* 0x5e */ { itable_evex0135E, 2 },
+    /* 0x5f */ { itable_evex0135F, 2 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { itable_evex0136F, 6 },
+    /* 0x70 */ { itable_evex01370, 3 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex01378, 2 },
+    /* 0x79 */ { itable_evex01379, 2 },
+    /* 0x7a */ { itable_evex0137A, 6 },
+    /* 0x7b */ { itable_evex0137B, 2 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { itable_evex0137F, 6 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_evex013C2, 47 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { itable_evex013E6, 3 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex021[256] = {
+    /* 0x00 */ { itable_evex02100, 6 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { itable_evex02104, 6 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { itable_evex0210B, 6 },
+    /* 0x0c */ { itable_evex0210C, 6 },
+    /* 0x0d */ { itable_evex0210D, 6 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex02110, 6 },
+    /* 0x11 */ { itable_evex02111, 6 },
+    /* 0x12 */ { itable_evex02112, 6 },
+    /* 0x13 */ { itable_evex02113, 6 },
+    /* 0x14 */ { itable_evex02114, 12 },
+    /* 0x15 */ { itable_evex02115, 12 },
+    /* 0x16 */ { itable_evex02116, 8 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { itable_evex02118, 6 },
+    /* 0x19 */ { itable_evex02119, 6 },
+    /* 0x1a */ { itable_evex0211A, 4 },
+    /* 0x1b */ { itable_evex0211B, 2 },
+    /* 0x1c */ { itable_evex0211C, 3 },
+    /* 0x1d */ { itable_evex0211D, 3 },
+    /* 0x1e */ { itable_evex0211E, 3 },
+    /* 0x1f */ { itable_evex0211F, 3 },
+    /* 0x20 */ { itable_evex02120, 3 },
+    /* 0x21 */ { itable_evex02121, 3 },
+    /* 0x22 */ { itable_evex02122, 3 },
+    /* 0x23 */ { itable_evex02123, 3 },
+    /* 0x24 */ { itable_evex02124, 3 },
+    /* 0x25 */ { itable_evex02125, 3 },
+    /* 0x26 */ { itable_evex02126, 6 },
+    /* 0x27 */ { itable_evex02127, 6 },
+    /* 0x28 */ { itable_evex02128, 6 },
+    /* 0x29 */ { itable_evex02129, 3 },
+    /* 0x2a */ { itable_evex0212A, 3 },
+    /* 0x2b */ { itable_evex0212B, 6 },
+    /* 0x2c */ { itable_evex0212C, 12 },
+    /* 0x2d */ { itable_evex0212D, 4 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { itable_evex02130, 3 },
+    /* 0x31 */ { itable_evex02131, 3 },
+    /* 0x32 */ { itable_evex02132, 3 },
+    /* 0x33 */ { itable_evex02133, 3 },
+    /* 0x34 */ { itable_evex02134, 3 },
+    /* 0x35 */ { itable_evex02135, 3 },
+    /* 0x36 */ { itable_evex02136, 8 },
+    /* 0x37 */ { itable_evex02137, 3 },
+    /* 0x38 */ { itable_evex02138, 6 },
+    /* 0x39 */ { itable_evex02139, 12 },
+    /* 0x3a */ { itable_evex0213A, 6 },
+    /* 0x3b */ { itable_evex0213B, 12 },
+    /* 0x3c */ { itable_evex0213C, 6 },
+    /* 0x3d */ { itable_evex0213D, 12 },
+    /* 0x3e */ { itable_evex0213E, 6 },
+    /* 0x3f */ { itable_evex0213F, 12 },
+    /* 0x40 */ { itable_evex02140, 12 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { itable_evex02142, 6 },
+    /* 0x43 */ { itable_evex02143, 2 },
+    /* 0x44 */ { itable_evex02144, 6 },
+    /* 0x45 */ { itable_evex02145, 12 },
+    /* 0x46 */ { itable_evex02146, 12 },
+    /* 0x47 */ { itable_evex02147, 12 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { itable_evex0214C, 6 },
+    /* 0x4d */ { itable_evex0214D, 4 },
+    /* 0x4e */ { itable_evex0214E, 6 },
+    /* 0x4f */ { itable_evex0214F, 4 },
+    /* 0x50 */ { itable_evex02150, 6 },
+    /* 0x51 */ { itable_evex02151, 6 },
+    /* 0x52 */ { itable_evex02152, 6 },
+    /* 0x53 */ { itable_evex02153, 6 },
+    /* 0x54 */ { itable_evex02154, 6 },
+    /* 0x55 */ { itable_evex02155, 6 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_evex02158, 6 },
+    /* 0x59 */ { itable_evex02159, 9 },
+    /* 0x5a */ { itable_evex0215A, 4 },
+    /* 0x5b */ { itable_evex0215B, 2 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { itable_evex02162, 6 },
+    /* 0x63 */ { itable_evex02163, 12 },
+    /* 0x64 */ { itable_evex02164, 6 },
+    /* 0x65 */ { itable_evex02165, 6 },
+    /* 0x66 */ { itable_evex02166, 6 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { itable_evex02170, 6 },
+    /* 0x71 */ { itable_evex02171, 12 },
+    /* 0x72 */ { itable_evex02172, 6 },
+    /* 0x73 */ { itable_evex02173, 12 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { itable_evex02175, 6 },
+    /* 0x76 */ { itable_evex02176, 6 },
+    /* 0x77 */ { itable_evex02177, 6 },
+    /* 0x78 */ { itable_evex02178, 3 },
+    /* 0x79 */ { itable_evex02179, 3 },
+    /* 0x7a */ { itable_evex0217A, 12 },
+    /* 0x7b */ { itable_evex0217B, 9 },
+    /* 0x7c */ { itable_evex0217C, 6 },
+    /* 0x7d */ { itable_evex0217D, 6 },
+    /* 0x7e */ { itable_evex0217E, 6 },
+    /* 0x7f */ { itable_evex0217F, 6 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { itable_evex02183, 6 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { itable_evex02188, 12 },
+    /* 0x89 */ { itable_evex02189, 12 },
+    /* 0x8a */ { itable_evex0218A, 12 },
+    /* 0x8b */ { itable_evex0218B, 12 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { itable_evex0218D, 12 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { itable_evex0218F, 3 },
+    /* 0x90 */ { itable_evex02190, 6 },
+    /* 0x91 */ { itable_evex02191, 6 },
+    /* 0x92 */ { itable_evex02192, 6 },
+    /* 0x93 */ { itable_evex02193, 6 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { itable_evex02196, 6 },
+    /* 0x97 */ { itable_evex02197, 6 },
+    /* 0x98 */ { itable_evex02198, 6 },
+    /* 0x99 */ { itable_evex02199, 2 },
+    /* 0x9a */ { itable_evex0219A, 6 },
+    /* 0x9b */ { itable_evex0219B, 2 },
+    /* 0x9c */ { itable_evex0219C, 6 },
+    /* 0x9d */ { itable_evex0219D, 2 },
+    /* 0x9e */ { itable_evex0219E, 6 },
+    /* 0x9f */ { itable_evex0219F, 2 },
+    /* 0xa0 */ { itable_evex021A0, 6 },
+    /* 0xa1 */ { itable_evex021A1, 6 },
+    /* 0xa2 */ { itable_evex021A2, 6 },
+    /* 0xa3 */ { itable_evex021A3, 6 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { itable_evex021A6, 6 },
+    /* 0xa7 */ { itable_evex021A7, 6 },
+    /* 0xa8 */ { itable_evex021A8, 6 },
+    /* 0xa9 */ { itable_evex021A9, 2 },
+    /* 0xaa */ { itable_evex021AA, 6 },
+    /* 0xab */ { itable_evex021AB, 2 },
+    /* 0xac */ { itable_evex021AC, 6 },
+    /* 0xad */ { itable_evex021AD, 2 },
+    /* 0xae */ { itable_evex021AE, 6 },
+    /* 0xaf */ { itable_evex021AF, 2 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { itable_evex021B4, 3 },
+    /* 0xb5 */ { itable_evex021B5, 3 },
+    /* 0xb6 */ { itable_evex021B6, 6 },
+    /* 0xb7 */ { itable_evex021B7, 6 },
+    /* 0xb8 */ { itable_evex021B8, 6 },
+    /* 0xb9 */ { itable_evex021B9, 2 },
+    /* 0xba */ { itable_evex021BA, 6 },
+    /* 0xbb */ { itable_evex021BB, 2 },
+    /* 0xbc */ { itable_evex021BC, 6 },
+    /* 0xbd */ { itable_evex021BD, 2 },
+    /* 0xbe */ { itable_evex021BE, 6 },
+    /* 0xbf */ { itable_evex021BF, 2 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { itable_evex021C4, 6 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { itable_evex021C6, 8 },
+    /* 0xc7 */ { itable_evex021C7, 8 },
+    /* 0xc8 */ { itable_evex021C8, 2 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { itable_evex021CA, 2 },
+    /* 0xcb */ { itable_evex021CB, 4 },
+    /* 0xcc */ { itable_evex021CC, 2 },
+    /* 0xcd */ { itable_evex021CD, 4 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { itable_evex021CF, 6 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { itable_evex021DC, 6 },
+    /* 0xdd */ { itable_evex021DD, 6 },
+    /* 0xde */ { itable_evex021DE, 6 },
+    /* 0xdf */ { itable_evex021DF, 6 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex022[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex02210, 6 },
+    /* 0x11 */ { itable_evex02211, 6 },
+    /* 0x12 */ { itable_evex02212, 6 },
+    /* 0x13 */ { itable_evex02213, 6 },
+    /* 0x14 */ { itable_evex02214, 6 },
+    /* 0x15 */ { itable_evex02215, 6 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { itable_evex02220, 6 },
+    /* 0x21 */ { itable_evex02221, 6 },
+    /* 0x22 */ { itable_evex02222, 6 },
+    /* 0x23 */ { itable_evex02223, 6 },
+    /* 0x24 */ { itable_evex02224, 6 },
+    /* 0x25 */ { itable_evex02225, 6 },
+    /* 0x26 */ { itable_evex02226, 6 },
+    /* 0x27 */ { itable_evex02227, 6 },
+    /* 0x28 */ { itable_evex02228, 6 },
+    /* 0x29 */ { itable_evex02229, 6 },
+    /* 0x2a */ { itable_evex0222A, 3 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { itable_evex02230, 6 },
+    /* 0x31 */ { itable_evex02231, 6 },
+    /* 0x32 */ { itable_evex02232, 6 },
+    /* 0x33 */ { itable_evex02233, 6 },
+    /* 0x34 */ { itable_evex02234, 6 },
+    /* 0x35 */ { itable_evex02235, 6 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { itable_evex02238, 6 },
+    /* 0x39 */ { itable_evex02239, 6 },
+    /* 0x3a */ { itable_evex0223A, 3 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { itable_evex02252, 6 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { itable_evex02272, 6 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex023[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { itable_evex02352, 1 },
+    /* 0x53 */ { itable_evex02353, 1 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { itable_evex02368, 3 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { itable_evex02372, 6 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { itable_evex0239A, 1 },
+    /* 0x9b */ { itable_evex0239B, 1 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { itable_evex023AA, 1 },
+    /* 0xab */ { itable_evex023AB, 1 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex030[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { itable_evex03008, 3 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { itable_evex0300A, 2 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { itable_evex03025, 3 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { itable_evex03027, 1 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { itable_evex03056, 3 },
+    /* 0x57 */ { itable_evex03057, 2 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { itable_evex03066, 3 },
+    /* 0x67 */ { itable_evex03067, 1 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_evex030C2, 6 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex031[256] = {
+    /* 0x00 */ { itable_evex03100, 2 },
+    /* 0x01 */ { itable_evex03101, 2 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { itable_evex03103, 12 },
+    /* 0x04 */ { itable_evex03104, 3 },
+    /* 0x05 */ { itable_evex03105, 3 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { itable_evex03108, 3 },
+    /* 0x09 */ { itable_evex03109, 3 },
+    /* 0x0a */ { itable_evex0310A, 2 },
+    /* 0x0b */ { itable_evex0310B, 2 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { itable_evex0310F, 6 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { itable_evex03114, 5 },
+    /* 0x15 */ { itable_evex03115, 4 },
+    /* 0x16 */ { itable_evex03116, 2 },
+    /* 0x17 */ { itable_evex03117, 3 },
+    /* 0x18 */ { itable_evex03118, 8 },
+    /* 0x19 */ { itable_evex03119, 8 },
+    /* 0x1a */ { itable_evex0311A, 4 },
+    /* 0x1b */ { itable_evex0311B, 4 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { itable_evex0311D, 12 },
+    /* 0x1e */ { itable_evex0311E, 60 },
+    /* 0x1f */ { itable_evex0311F, 60 },
+    /* 0x20 */ { itable_evex03120, 4 },
+    /* 0x21 */ { itable_evex03121, 2 },
+    /* 0x22 */ { itable_evex03122, 4 },
+    /* 0x23 */ { itable_evex03123, 8 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { itable_evex03125, 6 },
+    /* 0x26 */ { itable_evex03126, 6 },
+    /* 0x27 */ { itable_evex03127, 2 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { itable_evex03138, 8 },
+    /* 0x39 */ { itable_evex03139, 8 },
+    /* 0x3a */ { itable_evex0313A, 4 },
+    /* 0x3b */ { itable_evex0313B, 4 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { itable_evex0313E, 60 },
+    /* 0x3f */ { itable_evex0313F, 60 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { itable_evex03142, 6 },
+    /* 0x43 */ { itable_evex03143, 8 },
+    /* 0x44 */ { itable_evex03144, 30 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { itable_evex03150, 12 },
+    /* 0x51 */ { itable_evex03151, 4 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { itable_evex03154, 12 },
+    /* 0x55 */ { itable_evex03155, 4 },
+    /* 0x56 */ { itable_evex03156, 6 },
+    /* 0x57 */ { itable_evex03157, 4 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { itable_evex03166, 6 },
+    /* 0x67 */ { itable_evex03167, 2 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { itable_evex03170, 6 },
+    /* 0x71 */ { itable_evex03171, 12 },
+    /* 0x72 */ { itable_evex03172, 6 },
+    /* 0x73 */ { itable_evex03173, 12 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { itable_evex031CE, 6 },
+    /* 0xcf */ { itable_evex031CF, 6 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex032[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { itable_evex032C2, 2 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex050[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { itable_evex0501D, 2 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { itable_evex0502E, 1 },
+    /* 0x2f */ { itable_evex0502F, 1 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_evex05051, 3 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_evex05058, 6 },
+    /* 0x59 */ { itable_evex05059, 6 },
+    /* 0x5a */ { itable_evex0505A, 3 },
+    /* 0x5b */ { itable_evex0505B, 6 },
+    /* 0x5c */ { itable_evex0505C, 6 },
+    /* 0x5d */ { itable_evex0505D, 3 },
+    /* 0x5e */ { itable_evex0505E, 6 },
+    /* 0x5f */ { itable_evex0505F, 3 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex05078, 3 },
+    /* 0x79 */ { itable_evex05079, 3 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { itable_evex0507C, 3 },
+    /* 0x7d */ { itable_evex0507D, 3 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex051[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { itable_evex0511D, 3 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { itable_evex0515A, 3 },
+    /* 0x5b */ { itable_evex0515B, 3 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { itable_evex0516E, 1 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex05178, 3 },
+    /* 0x79 */ { itable_evex05179, 3 },
+    /* 0x7a */ { itable_evex0517A, 3 },
+    /* 0x7b */ { itable_evex0517B, 3 },
+    /* 0x7c */ { itable_evex0517C, 3 },
+    /* 0x7d */ { itable_evex0517D, 3 },
+    /* 0x7e */ { itable_evex0517E, 1 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex052[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_evex05210, 3 },
+    /* 0x11 */ { itable_evex05211, 3 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { itable_evex0522A, 4 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { itable_evex0522C, 2 },
+    /* 0x2d */ { itable_evex0522D, 2 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { itable_evex05251, 2 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { itable_evex05258, 2 },
+    /* 0x59 */ { itable_evex05259, 2 },
+    /* 0x5a */ { itable_evex0525A, 2 },
+    /* 0x5b */ { itable_evex0525B, 3 },
+    /* 0x5c */ { itable_evex0525C, 2 },
+    /* 0x5d */ { itable_evex0525D, 1 },
+    /* 0x5e */ { itable_evex0525E, 2 },
+    /* 0x5f */ { itable_evex0525F, 1 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { itable_evex05278, 2 },
+    /* 0x79 */ { itable_evex05279, 2 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { itable_evex0527B, 2 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { itable_evex0527D, 3 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex053[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { itable_evex0535A, 2 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { itable_evex0537A, 6 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { itable_evex0537D, 3 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex060[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { itable_evex06013, 2 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex061[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { itable_evex06113, 3 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { itable_evex0612C, 6 },
+    /* 0x2d */ { itable_evex0612D, 2 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { itable_evex06142, 3 },
+    /* 0x43 */ { itable_evex06143, 1 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { itable_evex0614C, 6 },
+    /* 0x4d */ { itable_evex0614D, 2 },
+    /* 0x4e */ { itable_evex0614E, 3 },
+    /* 0x4f */ { itable_evex0614F, 2 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { itable_evex06196, 6 },
+    /* 0x97 */ { itable_evex06197, 6 },
+    /* 0x98 */ { itable_evex06198, 6 },
+    /* 0x99 */ { itable_evex06199, 2 },
+    /* 0x9a */ { itable_evex0619A, 6 },
+    /* 0x9b */ { itable_evex0619B, 2 },
+    /* 0x9c */ { itable_evex0619C, 6 },
+    /* 0x9d */ { itable_evex0619D, 2 },
+    /* 0x9e */ { itable_evex0619E, 6 },
+    /* 0x9f */ { itable_evex0619F, 2 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { itable_evex061A6, 6 },
+    /* 0xa7 */ { itable_evex061A7, 6 },
+    /* 0xa8 */ { itable_evex061A8, 6 },
+    /* 0xa9 */ { itable_evex061A9, 2 },
+    /* 0xaa */ { itable_evex061AA, 6 },
+    /* 0xab */ { itable_evex061AB, 2 },
+    /* 0xac */ { itable_evex061AC, 6 },
+    /* 0xad */ { itable_evex061AD, 2 },
+    /* 0xae */ { itable_evex061AE, 6 },
+    /* 0xaf */ { itable_evex061AF, 2 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { itable_evex061B6, 6 },
+    /* 0xb7 */ { itable_evex061B7, 6 },
+    /* 0xb8 */ { itable_evex061B8, 6 },
+    /* 0xb9 */ { itable_evex061B9, 2 },
+    /* 0xba */ { itable_evex061BA, 6 },
+    /* 0xbb */ { itable_evex061BB, 2 },
+    /* 0xbc */ { itable_evex061BC, 6 },
+    /* 0xbd */ { itable_evex061BD, 2 },
+    /* 0xbe */ { itable_evex061BE, 6 },
+    /* 0xbf */ { itable_evex061BF, 2 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex062[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { itable_evex06256, 6 },
+    /* 0x57 */ { itable_evex06257, 2 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { itable_evex062D6, 6 },
+    /* 0xd7 */ { itable_evex062D7, 2 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_evex063[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { itable_evex06356, 6 },
+    /* 0x57 */ { itable_evex06357, 2 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { itable_evex063D6, 6 },
+    /* 0xd7 */ { itable_evex063D7, 2 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_0F38[256] = {
+    /* 0x00 */ { itable_0F3800, 2 },
+    /* 0x01 */ { itable_0F3801, 2 },
+    /* 0x02 */ { itable_0F3802, 2 },
+    /* 0x03 */ { itable_0F3803, 2 },
+    /* 0x04 */ { itable_0F3804, 2 },
+    /* 0x05 */ { itable_0F3805, 2 },
+    /* 0x06 */ { itable_0F3806, 2 },
+    /* 0x07 */ { itable_0F3807, 2 },
+    /* 0x08 */ { itable_0F3808, 2 },
+    /* 0x09 */ { itable_0F3809, 2 },
+    /* 0x0a */ { itable_0F380A, 2 },
+    /* 0x0b */ { itable_0F380B, 2 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { itable_0F3810, 2 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { itable_0F3814, 2 },
+    /* 0x15 */ { itable_0F3815, 2 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { itable_0F3817, 1 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { itable_0F381C, 2 },
+    /* 0x1d */ { itable_0F381D, 2 },
+    /* 0x1e */ { itable_0F381E, 2 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { itable_0F3820, 1 },
+    /* 0x21 */ { itable_0F3821, 1 },
+    /* 0x22 */ { itable_0F3822, 1 },
+    /* 0x23 */ { itable_0F3823, 1 },
+    /* 0x24 */ { itable_0F3824, 1 },
+    /* 0x25 */ { itable_0F3825, 1 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_0F3828, 1 },
+    /* 0x29 */ { itable_0F3829, 1 },
+    /* 0x2a */ { itable_0F382A, 1 },
+    /* 0x2b */ { itable_0F382B, 1 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { itable_0F3830, 1 },
+    /* 0x31 */ { itable_0F3831, 1 },
+    /* 0x32 */ { itable_0F3832, 1 },
+    /* 0x33 */ { itable_0F3833, 1 },
+    /* 0x34 */ { itable_0F3834, 1 },
+    /* 0x35 */ { itable_0F3835, 1 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { itable_0F3837, 1 },
+    /* 0x38 */ { itable_0F3838, 1 },
+    /* 0x39 */ { itable_0F3839, 1 },
+    /* 0x3a */ { itable_0F383A, 1 },
+    /* 0x3b */ { itable_0F383B, 1 },
+    /* 0x3c */ { itable_0F383C, 1 },
+    /* 0x3d */ { itable_0F383D, 1 },
+    /* 0x3e */ { itable_0F383E, 1 },
+    /* 0x3f */ { itable_0F383F, 1 },
+    /* 0x40 */ { itable_0F3840, 1 },
+    /* 0x41 */ { itable_0F3841, 1 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { itable_0F3880, 2 },
+    /* 0x81 */ { itable_0F3881, 2 },
+    /* 0x82 */ { itable_0F3882, 2 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { itable_0F38C8, 1 },
+    /* 0xc9 */ { itable_0F38C9, 1 },
+    /* 0xca */ { itable_0F38CA, 1 },
+    /* 0xcb */ { itable_0F38CB, 2 },
+    /* 0xcc */ { itable_0F38CC, 1 },
+    /* 0xcd */ { itable_0F38CD, 1 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { itable_0F38CF, 1 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { itable_0F38DB, 1 },
+    /* 0xdc */ { itable_0F38DC, 1 },
+    /* 0xdd */ { itable_0F38DD, 1 },
+    /* 0xde */ { itable_0F38DE, 1 },
+    /* 0xdf */ { itable_0F38DF, 1 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { itable_0F38F0, 5 },
+    /* 0xf1 */ { itable_0F38F1, 6 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { itable_0F38F5, 2 },
+    /* 0xf6 */ { itable_0F38F6, 6 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { itable_0F38F8, 9 },
+    /* 0xf9 */ { itable_0F38F9, 2 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { itable_0F38FC, 6 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_0F3A[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { itable_0F3A08, 1 },
+    /* 0x09 */ { itable_0F3A09, 1 },
+    /* 0x0a */ { itable_0F3A0A, 1 },
+    /* 0x0b */ { itable_0F3A0B, 1 },
+    /* 0x0c */ { itable_0F3A0C, 1 },
+    /* 0x0d */ { itable_0F3A0D, 1 },
+    /* 0x0e */ { itable_0F3A0E, 1 },
+    /* 0x0f */ { itable_0F3A0F, 2 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { itable_0F3A14, 3 },
+    /* 0x15 */ { itable_0F3A15, 3 },
+    /* 0x16 */ { itable_0F3A16, 2 },
+    /* 0x17 */ { itable_0F3A17, 2 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { itable_0F3A20, 3 },
+    /* 0x21 */ { itable_0F3A21, 1 },
+    /* 0x22 */ { itable_0F3A22, 2 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { itable_0F3A40, 1 },
+    /* 0x41 */ { itable_0F3A41, 1 },
+    /* 0x42 */ { itable_0F3A42, 1 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { itable_0F3A44, 5 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { itable_0F3A60, 1 },
+    /* 0x61 */ { itable_0F3A61, 1 },
+    /* 0x62 */ { itable_0F3A62, 1 },
+    /* 0x63 */ { itable_0F3A63, 1 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { NULL, 0 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { NULL, 0 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { itable_0F3ACC, 1 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { itable_0F3ACE, 1 },
+    /* 0xcf */ { itable_0F3ACF, 1 },
+    /* 0xd0 */ { NULL, 0 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { itable_0F3ADF, 1 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { itable_0F3AF0, 1 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_0FA6[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { itable_0FA6C0, 1 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { itable_0FA6C8, 1 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { itable_0FA6D0, 1 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { NULL, 0 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { NULL, 0 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { NULL, 0 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_0FA7[256] = {
+    /* 0x00 */ { NULL, 0 },
+    /* 0x01 */ { NULL, 0 },
+    /* 0x02 */ { NULL, 0 },
+    /* 0x03 */ { NULL, 0 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { NULL, 0 },
+    /* 0x06 */ { NULL, 0 },
+    /* 0x07 */ { NULL, 0 },
+    /* 0x08 */ { NULL, 0 },
+    /* 0x09 */ { NULL, 0 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { NULL, 0 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { NULL, 0 },
+    /* 0x0e */ { NULL, 0 },
+    /* 0x0f */ { NULL, 0 },
+    /* 0x10 */ { NULL, 0 },
+    /* 0x11 */ { NULL, 0 },
+    /* 0x12 */ { NULL, 0 },
+    /* 0x13 */ { NULL, 0 },
+    /* 0x14 */ { NULL, 0 },
+    /* 0x15 */ { NULL, 0 },
+    /* 0x16 */ { NULL, 0 },
+    /* 0x17 */ { NULL, 0 },
+    /* 0x18 */ { NULL, 0 },
+    /* 0x19 */ { NULL, 0 },
+    /* 0x1a */ { NULL, 0 },
+    /* 0x1b */ { NULL, 0 },
+    /* 0x1c */ { NULL, 0 },
+    /* 0x1d */ { NULL, 0 },
+    /* 0x1e */ { NULL, 0 },
+    /* 0x1f */ { NULL, 0 },
+    /* 0x20 */ { NULL, 0 },
+    /* 0x21 */ { NULL, 0 },
+    /* 0x22 */ { NULL, 0 },
+    /* 0x23 */ { NULL, 0 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { NULL, 0 },
+    /* 0x29 */ { NULL, 0 },
+    /* 0x2a */ { NULL, 0 },
+    /* 0x2b */ { NULL, 0 },
+    /* 0x2c */ { NULL, 0 },
+    /* 0x2d */ { NULL, 0 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { NULL, 0 },
+    /* 0x30 */ { NULL, 0 },
+    /* 0x31 */ { NULL, 0 },
+    /* 0x32 */ { NULL, 0 },
+    /* 0x33 */ { NULL, 0 },
+    /* 0x34 */ { NULL, 0 },
+    /* 0x35 */ { NULL, 0 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { NULL, 0 },
+    /* 0x38 */ { NULL, 0 },
+    /* 0x39 */ { NULL, 0 },
+    /* 0x3a */ { NULL, 0 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { NULL, 0 },
+    /* 0x3d */ { NULL, 0 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { NULL, 0 },
+    /* 0x41 */ { NULL, 0 },
+    /* 0x42 */ { NULL, 0 },
+    /* 0x43 */ { NULL, 0 },
+    /* 0x44 */ { NULL, 0 },
+    /* 0x45 */ { NULL, 0 },
+    /* 0x46 */ { NULL, 0 },
+    /* 0x47 */ { NULL, 0 },
+    /* 0x48 */ { NULL, 0 },
+    /* 0x49 */ { NULL, 0 },
+    /* 0x4a */ { NULL, 0 },
+    /* 0x4b */ { NULL, 0 },
+    /* 0x4c */ { NULL, 0 },
+    /* 0x4d */ { NULL, 0 },
+    /* 0x4e */ { NULL, 0 },
+    /* 0x4f */ { NULL, 0 },
+    /* 0x50 */ { NULL, 0 },
+    /* 0x51 */ { NULL, 0 },
+    /* 0x52 */ { NULL, 0 },
+    /* 0x53 */ { NULL, 0 },
+    /* 0x54 */ { NULL, 0 },
+    /* 0x55 */ { NULL, 0 },
+    /* 0x56 */ { NULL, 0 },
+    /* 0x57 */ { NULL, 0 },
+    /* 0x58 */ { NULL, 0 },
+    /* 0x59 */ { NULL, 0 },
+    /* 0x5a */ { NULL, 0 },
+    /* 0x5b */ { NULL, 0 },
+    /* 0x5c */ { NULL, 0 },
+    /* 0x5d */ { NULL, 0 },
+    /* 0x5e */ { NULL, 0 },
+    /* 0x5f */ { NULL, 0 },
+    /* 0x60 */ { NULL, 0 },
+    /* 0x61 */ { NULL, 0 },
+    /* 0x62 */ { NULL, 0 },
+    /* 0x63 */ { NULL, 0 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { NULL, 0 },
+    /* 0x69 */ { NULL, 0 },
+    /* 0x6a */ { NULL, 0 },
+    /* 0x6b */ { NULL, 0 },
+    /* 0x6c */ { NULL, 0 },
+    /* 0x6d */ { NULL, 0 },
+    /* 0x6e */ { NULL, 0 },
+    /* 0x6f */ { NULL, 0 },
+    /* 0x70 */ { NULL, 0 },
+    /* 0x71 */ { NULL, 0 },
+    /* 0x72 */ { NULL, 0 },
+    /* 0x73 */ { NULL, 0 },
+    /* 0x74 */ { NULL, 0 },
+    /* 0x75 */ { NULL, 0 },
+    /* 0x76 */ { NULL, 0 },
+    /* 0x77 */ { NULL, 0 },
+    /* 0x78 */ { NULL, 0 },
+    /* 0x79 */ { NULL, 0 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { NULL, 0 },
+    /* 0x7c */ { NULL, 0 },
+    /* 0x7d */ { NULL, 0 },
+    /* 0x7e */ { NULL, 0 },
+    /* 0x7f */ { NULL, 0 },
+    /* 0x80 */ { NULL, 0 },
+    /* 0x81 */ { NULL, 0 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { NULL, 0 },
+    /* 0x84 */ { NULL, 0 },
+    /* 0x85 */ { NULL, 0 },
+    /* 0x86 */ { NULL, 0 },
+    /* 0x87 */ { NULL, 0 },
+    /* 0x88 */ { NULL, 0 },
+    /* 0x89 */ { NULL, 0 },
+    /* 0x8a */ { NULL, 0 },
+    /* 0x8b */ { NULL, 0 },
+    /* 0x8c */ { NULL, 0 },
+    /* 0x8d */ { NULL, 0 },
+    /* 0x8e */ { NULL, 0 },
+    /* 0x8f */ { NULL, 0 },
+    /* 0x90 */ { NULL, 0 },
+    /* 0x91 */ { NULL, 0 },
+    /* 0x92 */ { NULL, 0 },
+    /* 0x93 */ { NULL, 0 },
+    /* 0x94 */ { NULL, 0 },
+    /* 0x95 */ { NULL, 0 },
+    /* 0x96 */ { NULL, 0 },
+    /* 0x97 */ { NULL, 0 },
+    /* 0x98 */ { NULL, 0 },
+    /* 0x99 */ { NULL, 0 },
+    /* 0x9a */ { NULL, 0 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { NULL, 0 },
+    /* 0x9d */ { NULL, 0 },
+    /* 0x9e */ { NULL, 0 },
+    /* 0x9f */ { NULL, 0 },
+    /* 0xa0 */ { NULL, 0 },
+    /* 0xa1 */ { NULL, 0 },
+    /* 0xa2 */ { NULL, 0 },
+    /* 0xa3 */ { NULL, 0 },
+    /* 0xa4 */ { NULL, 0 },
+    /* 0xa5 */ { NULL, 0 },
+    /* 0xa6 */ { NULL, 0 },
+    /* 0xa7 */ { NULL, 0 },
+    /* 0xa8 */ { NULL, 0 },
+    /* 0xa9 */ { NULL, 0 },
+    /* 0xaa */ { NULL, 0 },
+    /* 0xab */ { NULL, 0 },
+    /* 0xac */ { NULL, 0 },
+    /* 0xad */ { NULL, 0 },
+    /* 0xae */ { NULL, 0 },
+    /* 0xaf */ { NULL, 0 },
+    /* 0xb0 */ { NULL, 0 },
+    /* 0xb1 */ { NULL, 0 },
+    /* 0xb2 */ { NULL, 0 },
+    /* 0xb3 */ { NULL, 0 },
+    /* 0xb4 */ { NULL, 0 },
+    /* 0xb5 */ { NULL, 0 },
+    /* 0xb6 */ { NULL, 0 },
+    /* 0xb7 */ { NULL, 0 },
+    /* 0xb8 */ { NULL, 0 },
+    /* 0xb9 */ { NULL, 0 },
+    /* 0xba */ { NULL, 0 },
+    /* 0xbb */ { NULL, 0 },
+    /* 0xbc */ { NULL, 0 },
+    /* 0xbd */ { NULL, 0 },
+    /* 0xbe */ { NULL, 0 },
+    /* 0xbf */ { NULL, 0 },
+    /* 0xc0 */ { itable_0FA7C0, 1 },
+    /* 0xc1 */ { NULL, 0 },
+    /* 0xc2 */ { NULL, 0 },
+    /* 0xc3 */ { NULL, 0 },
+    /* 0xc4 */ { NULL, 0 },
+    /* 0xc5 */ { NULL, 0 },
+    /* 0xc6 */ { NULL, 0 },
+    /* 0xc7 */ { NULL, 0 },
+    /* 0xc8 */ { itable_0FA7C8, 1 },
+    /* 0xc9 */ { NULL, 0 },
+    /* 0xca */ { NULL, 0 },
+    /* 0xcb */ { NULL, 0 },
+    /* 0xcc */ { NULL, 0 },
+    /* 0xcd */ { NULL, 0 },
+    /* 0xce */ { NULL, 0 },
+    /* 0xcf */ { NULL, 0 },
+    /* 0xd0 */ { itable_0FA7D0, 1 },
+    /* 0xd1 */ { NULL, 0 },
+    /* 0xd2 */ { NULL, 0 },
+    /* 0xd3 */ { NULL, 0 },
+    /* 0xd4 */ { NULL, 0 },
+    /* 0xd5 */ { NULL, 0 },
+    /* 0xd6 */ { NULL, 0 },
+    /* 0xd7 */ { NULL, 0 },
+    /* 0xd8 */ { itable_0FA7D8, 1 },
+    /* 0xd9 */ { NULL, 0 },
+    /* 0xda */ { NULL, 0 },
+    /* 0xdb */ { NULL, 0 },
+    /* 0xdc */ { NULL, 0 },
+    /* 0xdd */ { NULL, 0 },
+    /* 0xde */ { NULL, 0 },
+    /* 0xdf */ { NULL, 0 },
+    /* 0xe0 */ { itable_0FA7E0, 1 },
+    /* 0xe1 */ { NULL, 0 },
+    /* 0xe2 */ { NULL, 0 },
+    /* 0xe3 */ { NULL, 0 },
+    /* 0xe4 */ { NULL, 0 },
+    /* 0xe5 */ { NULL, 0 },
+    /* 0xe6 */ { NULL, 0 },
+    /* 0xe7 */ { NULL, 0 },
+    /* 0xe8 */ { itable_0FA7E8, 1 },
+    /* 0xe9 */ { NULL, 0 },
+    /* 0xea */ { NULL, 0 },
+    /* 0xeb */ { NULL, 0 },
+    /* 0xec */ { NULL, 0 },
+    /* 0xed */ { NULL, 0 },
+    /* 0xee */ { NULL, 0 },
+    /* 0xef */ { NULL, 0 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { NULL, 0 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { NULL, 0 },
+    /* 0xf5 */ { NULL, 0 },
+    /* 0xf6 */ { NULL, 0 },
+    /* 0xf7 */ { NULL, 0 },
+    /* 0xf8 */ { NULL, 0 },
+    /* 0xf9 */ { NULL, 0 },
+    /* 0xfa */ { NULL, 0 },
+    /* 0xfb */ { NULL, 0 },
+    /* 0xfc */ { NULL, 0 },
+    /* 0xfd */ { NULL, 0 },
+    /* 0xfe */ { NULL, 0 },
+    /* 0xff */ { NULL, 0 },
+};
+
+static const struct disasm_index itable_0F[256] = {
+    /* 0x00 */ { itable_0F00, 24 },
+    /* 0x01 */ { itable_0F01, 66 },
+    /* 0x02 */ { itable_0F02, 10 },
+    /* 0x03 */ { itable_0F03, 10 },
+    /* 0x04 */ { NULL, 0 },
+    /* 0x05 */ { itable_0F05, 1 },
+    /* 0x06 */ { itable_0F06, 1 },
+    /* 0x07 */ { itable_0F07, 1 },
+    /* 0x08 */ { itable_0F08, 1 },
+    /* 0x09 */ { itable_0F09, 3 },
+    /* 0x0a */ { NULL, 0 },
+    /* 0x0b */ { itable_0F0B, 1 },
+    /* 0x0c */ { NULL, 0 },
+    /* 0x0d */ { itable_0F0D, 3 },
+    /* 0x0e */ { itable_0F0E, 1 },
+    /* 0x0f */ { itable_0F0F, 26 },
+    /* 0x10 */ { itable_0F10, 4 },
+    /* 0x11 */ { itable_0F11, 4 },
+    /* 0x12 */ { itable_0F12, 5 },
+    /* 0x13 */ { itable_0F13, 2 },
+    /* 0x14 */ { itable_0F14, 2 },
+    /* 0x15 */ { itable_0F15, 2 },
+    /* 0x16 */ { itable_0F16, 4 },
+    /* 0x17 */ { itable_0F17, 2 },
+    /* 0x18 */ { itable_0F18, 30 },
+    /* 0x19 */ { itable_0F19, 24 },
+    /* 0x1a */ { itable_0F1A, 35 },
+    /* 0x1b */ { itable_0F1B, 35 },
+    /* 0x1c */ { itable_0F1C, 25 },
+    /* 0x1d */ { itable_0F1D, 24 },
+    /* 0x1e */ { itable_0F1E, 28 },
+    /* 0x1f */ { itable_0F1F, 27 },
+    /* 0x20 */ { itable_0F20, 2 },
+    /* 0x21 */ { itable_0F21, 2 },
+    /* 0x22 */ { itable_0F22, 2 },
+    /* 0x23 */ { itable_0F23, 2 },
+    /* 0x24 */ { NULL, 0 },
+    /* 0x25 */ { NULL, 0 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { NULL, 0 },
+    /* 0x28 */ { itable_0F28, 2 },
+    /* 0x29 */ { itable_0F29, 2 },
+    /* 0x2a */ { itable_0F2A, 6 },
+    /* 0x2b */ { itable_0F2B, 4 },
+    /* 0x2c */ { itable_0F2C, 8 },
+    /* 0x2d */ { itable_0F2D, 10 },
+    /* 0x2e */ { itable_0F2E, 2 },
+    /* 0x2f */ { itable_0F2F, 2 },
+    /* 0x30 */ { itable_0F30, 1 },
+    /* 0x31 */ { itable_0F31, 1 },
+    /* 0x32 */ { itable_0F32, 1 },
+    /* 0x33 */ { itable_0F33, 1 },
+    /* 0x34 */ { itable_0F34, 1 },
+    /* 0x35 */ { itable_0F35, 1 },
+    /* 0x36 */ { itable_0F36, 1 },
+    /* 0x37 */ { itable_0F37, 2 },
+    /* 0x38 */ { itable_0F38, -1 },
+    /* 0x39 */ { itable_0F39, 1 },
+    /* 0x3a */ { itable_0F3A, -1 },
+    /* 0x3b */ { NULL, 0 },
+    /* 0x3c */ { itable_0F3C, 1 },
+    /* 0x3d */ { itable_0F3D, 1 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { NULL, 0 },
+    /* 0x40 */ { itable_0F40, 6 },
+    /* 0x41 */ { itable_0F41, 6 },
+    /* 0x42 */ { itable_0F42, 6 },
+    /* 0x43 */ { itable_0F43, 6 },
+    /* 0x44 */ { itable_0F44, 6 },
+    /* 0x45 */ { itable_0F45, 6 },
+    /* 0x46 */ { itable_0F46, 6 },
+    /* 0x47 */ { itable_0F47, 6 },
+    /* 0x48 */ { itable_0F48, 6 },
+    /* 0x49 */ { itable_0F49, 6 },
+    /* 0x4a */ { itable_0F4A, 6 },
+    /* 0x4b */ { itable_0F4B, 6 },
+    /* 0x4c */ { itable_0F4C, 6 },
+    /* 0x4d */ { itable_0F4D, 6 },
+    /* 0x4e */ { itable_0F4E, 6 },
+    /* 0x4f */ { itable_0F4F, 6 },
+    /* 0x50 */ { itable_0F50, 5 },
+    /* 0x51 */ { itable_0F51, 5 },
+    /* 0x52 */ { itable_0F52, 3 },
+    /* 0x53 */ { itable_0F53, 2 },
+    /* 0x54 */ { itable_0F54, 3 },
+    /* 0x55 */ { itable_0F55, 3 },
+    /* 0x56 */ { itable_0F56, 2 },
+    /* 0x57 */ { itable_0F57, 2 },
+    /* 0x58 */ { itable_0F58, 5 },
+    /* 0x59 */ { itable_0F59, 5 },
+    /* 0x5a */ { itable_0F5A, 5 },
+    /* 0x5b */ { itable_0F5B, 4 },
+    /* 0x5c */ { itable_0F5C, 5 },
+    /* 0x5d */ { itable_0F5D, 5 },
+    /* 0x5e */ { itable_0F5E, 5 },
+    /* 0x5f */ { itable_0F5F, 4 },
+    /* 0x60 */ { itable_0F60, 2 },
+    /* 0x61 */ { itable_0F61, 2 },
+    /* 0x62 */ { itable_0F62, 2 },
+    /* 0x63 */ { itable_0F63, 2 },
+    /* 0x64 */ { itable_0F64, 2 },
+    /* 0x65 */ { itable_0F65, 2 },
+    /* 0x66 */ { itable_0F66, 2 },
+    /* 0x67 */ { itable_0F67, 2 },
+    /* 0x68 */ { itable_0F68, 2 },
+    /* 0x69 */ { itable_0F69, 2 },
+    /* 0x6a */ { itable_0F6A, 2 },
+    /* 0x6b */ { itable_0F6B, 2 },
+    /* 0x6c */ { itable_0F6C, 1 },
+    /* 0x6d */ { itable_0F6D, 1 },
+    /* 0x6e */ { itable_0F6E, 5 },
+    /* 0x6f */ { itable_0F6F, 3 },
+    /* 0x70 */ { itable_0F70, 7 },
+    /* 0x71 */ { itable_0F71, 6 },
+    /* 0x72 */ { itable_0F72, 6 },
+    /* 0x73 */ { itable_0F73, 6 },
+    /* 0x74 */ { itable_0F74, 2 },
+    /* 0x75 */ { itable_0F75, 2 },
+    /* 0x76 */ { itable_0F76, 2 },
+    /* 0x77 */ { itable_0F77, 1 },
+    /* 0x78 */ { itable_0F78, 5 },
+    /* 0x79 */ { itable_0F79, 5 },
+    /* 0x7a */ { NULL, 0 },
+    /* 0x7b */ { itable_0F7B, 1 },
+    /* 0x7c */ { itable_0F7C, 3 },
+    /* 0x7d */ { itable_0F7D, 3 },
+    /* 0x7e */ { itable_0F7E, 7 },
+    /* 0x7f */ { itable_0F7F, 3 },
+    /* 0x80 */ { itable_0F80, 4 },
+    /* 0x81 */ { itable_0F81, 4 },
+    /* 0x82 */ { itable_0F82, 4 },
+    /* 0x83 */ { itable_0F83, 4 },
+    /* 0x84 */ { itable_0F84, 4 },
+    /* 0x85 */ { itable_0F85, 4 },
+    /* 0x86 */ { itable_0F86, 4 },
+    /* 0x87 */ { itable_0F87, 4 },
+    /* 0x88 */ { itable_0F88, 4 },
+    /* 0x89 */ { itable_0F89, 4 },
+    /* 0x8a */ { itable_0F8A, 4 },
+    /* 0x8b */ { itable_0F8B, 4 },
+    /* 0x8c */ { itable_0F8C, 4 },
+    /* 0x8d */ { itable_0F8D, 4 },
+    /* 0x8e */ { itable_0F8E, 4 },
+    /* 0x8f */ { itable_0F8F, 4 },
+    /* 0x90 */ { itable_0F90, 2 },
+    /* 0x91 */ { itable_0F91, 2 },
+    /* 0x92 */ { itable_0F92, 2 },
+    /* 0x93 */ { itable_0F93, 2 },
+    /* 0x94 */ { itable_0F94, 2 },
+    /* 0x95 */ { itable_0F95, 2 },
+    /* 0x96 */ { itable_0F96, 2 },
+    /* 0x97 */ { itable_0F97, 2 },
+    /* 0x98 */ { itable_0F98, 2 },
+    /* 0x99 */ { itable_0F99, 2 },
+    /* 0x9a */ { itable_0F9A, 2 },
+    /* 0x9b */ { itable_0F9B, 2 },
+    /* 0x9c */ { itable_0F9C, 2 },
+    /* 0x9d */ { itable_0F9D, 2 },
+    /* 0x9e */ { itable_0F9E, 2 },
+    /* 0x9f */ { itable_0F9F, 2 },
+    /* 0xa0 */ { itable_0FA0, 1 },
+    /* 0xa1 */ { itable_0FA1, 1 },
+    /* 0xa2 */ { itable_0FA2, 1 },
+    /* 0xa3 */ { itable_0FA3, 6 },
+    /* 0xa4 */ { itable_0FA4, 6 },
+    /* 0xa5 */ { itable_0FA5, 6 },
+    /* 0xa6 */ { itable_0FA6, -1 },
+    /* 0xa7 */ { itable_0FA7, -1 },
+    /* 0xa8 */ { itable_0FA8, 1 },
+    /* 0xa9 */ { itable_0FA9, 1 },
+    /* 0xaa */ { itable_0FAA, 1 },
+    /* 0xab */ { itable_0FAB, 6 },
+    /* 0xac */ { itable_0FAC, 6 },
+    /* 0xad */ { itable_0FAD, 6 },
+    /* 0xae */ { itable_0FAE, 40 },
+    /* 0xaf */ { itable_0FAF, 6 },
+    /* 0xb0 */ { itable_0FB0, 2 },
+    /* 0xb1 */ { itable_0FB1, 6 },
+    /* 0xb2 */ { itable_0FB2, 3 },
+    /* 0xb3 */ { itable_0FB3, 6 },
+    /* 0xb4 */ { itable_0FB4, 3 },
+    /* 0xb5 */ { itable_0FB5, 3 },
+    /* 0xb6 */ { itable_0FB6, 4 },
+    /* 0xb7 */ { itable_0FB7, 2 },
+    /* 0xb8 */ { itable_0FB8, 6 },
+    /* 0xb9 */ { itable_0FB9, 3 },
+    /* 0xba */ { itable_0FBA, 12 },
+    /* 0xbb */ { itable_0FBB, 6 },
+    /* 0xbc */ { itable_0FBC, 9 },
+    /* 0xbd */ { itable_0FBD, 9 },
+    /* 0xbe */ { itable_0FBE, 4 },
+    /* 0xbf */ { itable_0FBF, 2 },
+    /* 0xc0 */ { itable_0FC0, 2 },
+    /* 0xc1 */ { itable_0FC1, 6 },
+    /* 0xc2 */ { itable_0FC2, 36 },
+    /* 0xc3 */ { itable_0FC3, 2 },
+    /* 0xc4 */ { itable_0FC4, 6 },
+    /* 0xc5 */ { itable_0FC5, 2 },
+    /* 0xc6 */ { itable_0FC6, 2 },
+    /* 0xc7 */ { itable_0FC7, 22 },
+    /* 0xc8 */ { itable_0FC8, 2 },
+    /* 0xc9 */ { itable_0FC9, 2 },
+    /* 0xca */ { itable_0FCA, 2 },
+    /* 0xcb */ { itable_0FCB, 2 },
+    /* 0xcc */ { itable_0FCC, 2 },
+    /* 0xcd */ { itable_0FCD, 2 },
+    /* 0xce */ { itable_0FCE, 2 },
+    /* 0xcf */ { itable_0FCF, 2 },
+    /* 0xd0 */ { itable_0FD0, 2 },
+    /* 0xd1 */ { itable_0FD1, 2 },
+    /* 0xd2 */ { itable_0FD2, 2 },
+    /* 0xd3 */ { itable_0FD3, 2 },
+    /* 0xd4 */ { itable_0FD4, 2 },
+    /* 0xd5 */ { itable_0FD5, 2 },
+    /* 0xd6 */ { itable_0FD6, 4 },
+    /* 0xd7 */ { itable_0FD7, 2 },
+    /* 0xd8 */ { itable_0FD8, 2 },
+    /* 0xd9 */ { itable_0FD9, 2 },
+    /* 0xda */ { itable_0FDA, 2 },
+    /* 0xdb */ { itable_0FDB, 2 },
+    /* 0xdc */ { itable_0FDC, 2 },
+    /* 0xdd */ { itable_0FDD, 2 },
+    /* 0xde */ { itable_0FDE, 2 },
+    /* 0xdf */ { itable_0FDF, 2 },
+    /* 0xe0 */ { itable_0FE0, 2 },
+    /* 0xe1 */ { itable_0FE1, 2 },
+    /* 0xe2 */ { itable_0FE2, 2 },
+    /* 0xe3 */ { itable_0FE3, 2 },
+    /* 0xe4 */ { itable_0FE4, 2 },
+    /* 0xe5 */ { itable_0FE5, 2 },
+    /* 0xe6 */ { itable_0FE6, 3 },
+    /* 0xe7 */ { itable_0FE7, 2 },
+    /* 0xe8 */ { itable_0FE8, 2 },
+    /* 0xe9 */ { itable_0FE9, 2 },
+    /* 0xea */ { itable_0FEA, 2 },
+    /* 0xeb */ { itable_0FEB, 2 },
+    /* 0xec */ { itable_0FEC, 2 },
+    /* 0xed */ { itable_0FED, 2 },
+    /* 0xee */ { itable_0FEE, 2 },
+    /* 0xef */ { itable_0FEF, 2 },
+    /* 0xf0 */ { itable_0FF0, 1 },
+    /* 0xf1 */ { itable_0FF1, 2 },
+    /* 0xf2 */ { itable_0FF2, 2 },
+    /* 0xf3 */ { itable_0FF3, 2 },
+    /* 0xf4 */ { itable_0FF4, 2 },
+    /* 0xf5 */ { itable_0FF5, 2 },
+    /* 0xf6 */ { itable_0FF6, 2 },
+    /* 0xf7 */ { itable_0FF7, 2 },
+    /* 0xf8 */ { itable_0FF8, 2 },
+    /* 0xf9 */ { itable_0FF9, 2 },
+    /* 0xfa */ { itable_0FFA, 2 },
+    /* 0xfb */ { itable_0FFB, 2 },
+    /* 0xfc */ { itable_0FFC, 2 },
+    /* 0xfd */ { itable_0FFD, 2 },
+    /* 0xfe */ { itable_0FFE, 2 },
+    /* 0xff */ { itable_0FFF, 4 },
+};
+
+const struct disasm_index itable[256] = {
+    /* 0x00 */ { itable_00, 2 },
+    /* 0x01 */ { itable_01, 6 },
+    /* 0x02 */ { itable_02, 2 },
+    /* 0x03 */ { itable_03, 6 },
+    /* 0x04 */ { itable_04, 1 },
+    /* 0x05 */ { itable_05, 3 },
+    /* 0x06 */ { itable_06, 1 },
+    /* 0x07 */ { itable_07, 1 },
+    /* 0x08 */ { itable_08, 2 },
+    /* 0x09 */ { itable_09, 6 },
+    /* 0x0a */ { itable_0A, 2 },
+    /* 0x0b */ { itable_0B, 6 },
+    /* 0x0c */ { itable_0C, 1 },
+    /* 0x0d */ { itable_0D, 3 },
+    /* 0x0e */ { itable_0E, 1 },
+    /* 0x0f */ { itable_0F, -1 },
+    /* 0x10 */ { itable_10, 2 },
+    /* 0x11 */ { itable_11, 6 },
+    /* 0x12 */ { itable_12, 2 },
+    /* 0x13 */ { itable_13, 6 },
+    /* 0x14 */ { itable_14, 1 },
+    /* 0x15 */ { itable_15, 3 },
+    /* 0x16 */ { itable_16, 1 },
+    /* 0x17 */ { itable_17, 1 },
+    /* 0x18 */ { itable_18, 2 },
+    /* 0x19 */ { itable_19, 6 },
+    /* 0x1a */ { itable_1A, 2 },
+    /* 0x1b */ { itable_1B, 6 },
+    /* 0x1c */ { itable_1C, 1 },
+    /* 0x1d */ { itable_1D, 3 },
+    /* 0x1e */ { itable_1E, 1 },
+    /* 0x1f */ { itable_1F, 1 },
+    /* 0x20 */ { itable_20, 2 },
+    /* 0x21 */ { itable_21, 6 },
+    /* 0x22 */ { itable_22, 2 },
+    /* 0x23 */ { itable_23, 6 },
+    /* 0x24 */ { itable_24, 1 },
+    /* 0x25 */ { itable_25, 3 },
+    /* 0x26 */ { NULL, 0 },
+    /* 0x27 */ { itable_27, 1 },
+    /* 0x28 */ { itable_28, 2 },
+    /* 0x29 */ { itable_29, 6 },
+    /* 0x2a */ { itable_2A, 2 },
+    /* 0x2b */ { itable_2B, 6 },
+    /* 0x2c */ { itable_2C, 1 },
+    /* 0x2d */ { itable_2D, 3 },
+    /* 0x2e */ { NULL, 0 },
+    /* 0x2f */ { itable_2F, 1 },
+    /* 0x30 */ { itable_30, 2 },
+    /* 0x31 */ { itable_31, 6 },
+    /* 0x32 */ { itable_32, 2 },
+    /* 0x33 */ { itable_33, 6 },
+    /* 0x34 */ { itable_34, 1 },
+    /* 0x35 */ { itable_35, 3 },
+    /* 0x36 */ { NULL, 0 },
+    /* 0x37 */ { itable_37, 1 },
+    /* 0x38 */ { itable_38, 2 },
+    /* 0x39 */ { itable_39, 6 },
+    /* 0x3a */ { itable_3A, 2 },
+    /* 0x3b */ { itable_3B, 6 },
+    /* 0x3c */ { itable_3C, 1 },
+    /* 0x3d */ { itable_3D, 3 },
+    /* 0x3e */ { NULL, 0 },
+    /* 0x3f */ { itable_3F, 1 },
+    /* 0x40 */ { itable_40, 2 },
+    /* 0x41 */ { itable_41, 2 },
+    /* 0x42 */ { itable_42, 2 },
+    /* 0x43 */ { itable_43, 2 },
+    /* 0x44 */ { itable_44, 2 },
+    /* 0x45 */ { itable_45, 2 },
+    /* 0x46 */ { itable_46, 2 },
+    /* 0x47 */ { itable_47, 2 },
+    /* 0x48 */ { itable_48, 2 },
+    /* 0x49 */ { itable_49, 2 },
+    /* 0x4a */ { itable_4A, 2 },
+    /* 0x4b */ { itable_4B, 2 },
+    /* 0x4c */ { itable_4C, 2 },
+    /* 0x4d */ { itable_4D, 2 },
+    /* 0x4e */ { itable_4E, 2 },
+    /* 0x4f */ { itable_4F, 2 },
+    /* 0x50 */ { itable_50, 3 },
+    /* 0x51 */ { itable_51, 3 },
+    /* 0x52 */ { itable_52, 3 },
+    /* 0x53 */ { itable_53, 3 },
+    /* 0x54 */ { itable_54, 3 },
+    /* 0x55 */ { itable_55, 3 },
+    /* 0x56 */ { itable_56, 3 },
+    /* 0x57 */ { itable_57, 3 },
+    /* 0x58 */ { itable_58, 3 },
+    /* 0x59 */ { itable_59, 3 },
+    /* 0x5a */ { itable_5A, 3 },
+    /* 0x5b */ { itable_5B, 3 },
+    /* 0x5c */ { itable_5C, 3 },
+    /* 0x5d */ { itable_5D, 3 },
+    /* 0x5e */ { itable_5E, 3 },
+    /* 0x5f */ { itable_5F, 3 },
+    /* 0x60 */ { itable_60, 3 },
+    /* 0x61 */ { itable_61, 3 },
+    /* 0x62 */ { itable_62, 2 },
+    /* 0x63 */ { itable_63, 3 },
+    /* 0x64 */ { NULL, 0 },
+    /* 0x65 */ { NULL, 0 },
+    /* 0x66 */ { NULL, 0 },
+    /* 0x67 */ { NULL, 0 },
+    /* 0x68 */ { itable_68, 5 },
+    /* 0x69 */ { itable_69, 9 },
+    /* 0x6a */ { itable_6A, 1 },
+    /* 0x6b */ { itable_6B, 9 },
+    /* 0x6c */ { itable_6C, 1 },
+    /* 0x6d */ { itable_6D, 2 },
+    /* 0x6e */ { itable_6E, 1 },
+    /* 0x6f */ { itable_6F, 2 },
+    /* 0x70 */ { itable_70, 1 },
+    /* 0x71 */ { itable_71, 1 },
+    /* 0x72 */ { itable_72, 1 },
+    /* 0x73 */ { itable_73, 1 },
+    /* 0x74 */ { itable_74, 1 },
+    /* 0x75 */ { itable_75, 1 },
+    /* 0x76 */ { itable_76, 1 },
+    /* 0x77 */ { itable_77, 1 },
+    /* 0x78 */ { itable_78, 1 },
+    /* 0x79 */ { itable_79, 1 },
+    /* 0x7a */ { itable_7A, 1 },
+    /* 0x7b */ { itable_7B, 1 },
+    /* 0x7c */ { itable_7C, 1 },
+    /* 0x7d */ { itable_7D, 1 },
+    /* 0x7e */ { itable_7E, 1 },
+    /* 0x7f */ { itable_7F, 1 },
+    /* 0x80 */ { itable_80, 15 },
+    /* 0x81 */ { itable_81, 40 },
+    /* 0x82 */ { NULL, 0 },
+    /* 0x83 */ { itable_83, 24 },
+    /* 0x84 */ { itable_84, 3 },
+    /* 0x85 */ { itable_85, 9 },
+    /* 0x86 */ { itable_86, 4 },
+    /* 0x87 */ { itable_87, 12 },
+    /* 0x88 */ { itable_88, 2 },
+    /* 0x89 */ { itable_89, 6 },
+    /* 0x8a */ { itable_8A, 2 },
+    /* 0x8b */ { itable_8B, 6 },
+    /* 0x8c */ { itable_8C, 4 },
+    /* 0x8d */ { itable_8D, 3 },
+    /* 0x8e */ { itable_8E, 4 },
+    /* 0x8f */ { itable_8F, 3 },
+    /* 0x90 */ { itable_90, 9 },
+    /* 0x91 */ { itable_91, 6 },
+    /* 0x92 */ { itable_92, 6 },
+    /* 0x93 */ { itable_93, 6 },
+    /* 0x94 */ { itable_94, 6 },
+    /* 0x95 */ { itable_95, 6 },
+    /* 0x96 */ { itable_96, 6 },
+    /* 0x97 */ { itable_97, 6 },
+    /* 0x98 */ { itable_98, 3 },
+    /* 0x99 */ { itable_99, 3 },
+    /* 0x9a */ { itable_9A, 5 },
+    /* 0x9b */ { NULL, 0 },
+    /* 0x9c */ { itable_9C, 4 },
+    /* 0x9d */ { itable_9D, 4 },
+    /* 0x9e */ { itable_9E, 1 },
+    /* 0x9f */ { itable_9F, 1 },
+    /* 0xa0 */ { itable_A0, 1 },
+    /* 0xa1 */ { itable_A1, 3 },
+    /* 0xa2 */ { itable_A2, 1 },
+    /* 0xa3 */ { itable_A3, 3 },
+    /* 0xa4 */ { itable_A4, 1 },
+    /* 0xa5 */ { itable_A5, 3 },
+    /* 0xa6 */ { itable_A6, 1 },
+    /* 0xa7 */ { itable_A7, 3 },
+    /* 0xa8 */ { itable_A8, 1 },
+    /* 0xa9 */ { itable_A9, 3 },
+    /* 0xaa */ { itable_AA, 1 },
+    /* 0xab */ { itable_AB, 3 },
+    /* 0xac */ { itable_AC, 1 },
+    /* 0xad */ { itable_AD, 3 },
+    /* 0xae */ { itable_AE, 1 },
+    /* 0xaf */ { itable_AF, 3 },
+    /* 0xb0 */ { itable_B0, 1 },
+    /* 0xb1 */ { itable_B1, 1 },
+    /* 0xb2 */ { itable_B2, 1 },
+    /* 0xb3 */ { itable_B3, 1 },
+    /* 0xb4 */ { itable_B4, 1 },
+    /* 0xb5 */ { itable_B5, 1 },
+    /* 0xb6 */ { itable_B6, 1 },
+    /* 0xb7 */ { itable_B7, 1 },
+    /* 0xb8 */ { itable_B8, 3 },
+    /* 0xb9 */ { itable_B9, 3 },
+    /* 0xba */ { itable_BA, 3 },
+    /* 0xbb */ { itable_BB, 3 },
+    /* 0xbc */ { itable_BC, 3 },
+    /* 0xbd */ { itable_BD, 3 },
+    /* 0xbe */ { itable_BE, 3 },
+    /* 0xbf */ { itable_BF, 3 },
+    /* 0xc0 */ { itable_C0, 7 },
+    /* 0xc1 */ { itable_C1, 21 },
+    /* 0xc2 */ { itable_C2, 8 },
+    /* 0xc3 */ { itable_C3, 8 },
+    /* 0xc4 */ { itable_C4, 2 },
+    /* 0xc5 */ { itable_C5, 2 },
+    /* 0xc6 */ { itable_C6, 4 },
+    /* 0xc7 */ { itable_C7, 10 },
+    /* 0xc8 */ { itable_C8, 1 },
+    /* 0xc9 */ { itable_C9, 1 },
+    /* 0xca */ { itable_CA, 4 },
+    /* 0xcb */ { itable_CB, 4 },
+    /* 0xcc */ { itable_CC, 1 },
+    /* 0xcd */ { itable_CD, 1 },
+    /* 0xce */ { itable_CE, 1 },
+    /* 0xcf */ { itable_CF, 4 },
+    /* 0xd0 */ { itable_D0, 7 },
+    /* 0xd1 */ { itable_D1, 21 },
+    /* 0xd2 */ { itable_D2, 7 },
+    /* 0xd3 */ { itable_D3, 21 },
+    /* 0xd4 */ { itable_D4, 2 },
+    /* 0xd5 */ { itable_D5, 2 },
+    /* 0xd6 */ { itable_D6, 1 },
+    /* 0xd7 */ { itable_D7, 2 },
+    /* 0xd8 */ { itable_D8, 24 },
+    /* 0xd9 */ { itable_D9, 41 },
+    /* 0xda */ { itable_DA, 17 },
+    /* 0xdb */ { itable_DB, 27 },
+    /* 0xdc */ { itable_DC, 20 },
+    /* 0xdd */ { itable_DD, 17 },
+    /* 0xde */ { itable_DE, 21 },
+    /* 0xdf */ { itable_DF, 18 },
+    /* 0xe0 */ { itable_E0, 8 },
+    /* 0xe1 */ { itable_E1, 8 },
+    /* 0xe2 */ { itable_E2, 4 },
+    /* 0xe3 */ { itable_E3, 3 },
+    /* 0xe4 */ { itable_E4, 1 },
+    /* 0xe5 */ { itable_E5, 2 },
+    /* 0xe6 */ { itable_E6, 1 },
+    /* 0xe7 */ { itable_E7, 2 },
+    /* 0xe8 */ { itable_E8, 4 },
+    /* 0xe9 */ { itable_E9, 4 },
+    /* 0xea */ { itable_EA, 5 },
+    /* 0xeb */ { itable_EB, 1 },
+    /* 0xec */ { itable_EC, 1 },
+    /* 0xed */ { itable_ED, 2 },
+    /* 0xee */ { itable_EE, 1 },
+    /* 0xef */ { itable_EF, 2 },
+    /* 0xf0 */ { NULL, 0 },
+    /* 0xf1 */ { itable_F1, 2 },
+    /* 0xf2 */ { NULL, 0 },
+    /* 0xf3 */ { NULL, 0 },
+    /* 0xf4 */ { itable_F4, 1 },
+    /* 0xf5 */ { itable_F5, 1 },
+    /* 0xf6 */ { itable_F6, 8 },
+    /* 0xf7 */ { itable_F7, 23 },
+    /* 0xf8 */ { itable_F8, 1 },
+    /* 0xf9 */ { itable_F9, 1 },
+    /* 0xfa */ { itable_FA, 1 },
+    /* 0xfb */ { itable_FB, 1 },
+    /* 0xfc */ { itable_FC, 1 },
+    /* 0xfd */ { itable_FD, 1 },
+    /* 0xfe */ { itable_FE, 2 },
+    /* 0xff */ { itable_FF, 27 },
+};
+
+const struct disasm_index * const itable_vex[NASM_VEX_CLASSES][32][4] =
+{
+    {
+        { NULL,          NULL,          NULL,          NULL,          },
+        { itable_vex010, itable_vex011, itable_vex012, itable_vex013, },
+        { itable_vex020, itable_vex021, itable_vex022, itable_vex023, },
+        { NULL,          itable_vex031, NULL,          itable_vex033, },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+    },
+    {
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { itable_xop080, NULL,          NULL,          NULL,          },
+        { itable_xop090, NULL,          NULL,          NULL,          },
+        { itable_xop0A0, NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+    },
+    {
+        { NULL,          NULL,          NULL,          NULL,          },
+        { itable_evex010,itable_evex011,itable_evex012,itable_evex013,},
+        { NULL,          itable_evex021,itable_evex022,itable_evex023,},
+        { itable_evex030,itable_evex031,itable_evex032,NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { itable_evex050,itable_evex051,itable_evex052,itable_evex053,},
+        { itable_evex060,itable_evex061,itable_evex062,itable_evex063,},
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+        { NULL,          NULL,          NULL,          NULL,          },
+    },
+};
diff --git a/vere/ext/nasm/x86/insnsi.h b/vere/ext/nasm/x86/insnsi.h
new file mode 100644
index 0000000..65188c0
--- /dev/null
+++ b/vere/ext/nasm/x86/insnsi.h
@@ -0,0 +1,2265 @@
+/* This file is auto-generated from insns.dat by insns.pl - don't edit it */
+
+/* This file in included by nasm.h */
+
+/* Instruction names */
+
+#ifndef NASM_INSNSI_H
+#define NASM_INSNSI_H 1
+
+enum opcode {
+	I_DB,
+	I_DW,
+	I_DD,
+	I_DQ,
+	I_DT,
+	I_DO,
+	I_DY,
+	I_DZ,
+	I_RESB,
+	I_RESW,
+	I_RESD,
+	I_RESQ,
+	I_REST,
+	I_RESO,
+	I_RESY,
+	I_RESZ,
+	I_INCBIN,
+	I_AAA,
+	I_AAD,
+	I_AAM,
+	I_AAS,
+	I_ADC,
+	I_ADD,
+	I_AND,
+	I_ARPL,
+	I_BB0_RESET,
+	I_BB1_RESET,
+	I_BOUND,
+	I_BSF,
+	I_BSR,
+	I_BSWAP,
+	I_BT,
+	I_BTC,
+	I_BTR,
+	I_BTS,
+	I_CALL,
+	I_CBW,
+	I_CDQ,
+	I_CDQE,
+	I_CLC,
+	I_CLD,
+	I_CLI,
+	I_CLTS,
+	I_CMC,
+	I_CMP,
+	I_CMPSB,
+	I_CMPSD,
+	I_CMPSQ,
+	I_CMPSW,
+	I_CMPXCHG,
+	I_CMPXCHG486,
+	I_CMPXCHG8B,
+	I_CMPXCHG16B,
+	I_CPUID,
+	I_CPU_READ,
+	I_CPU_WRITE,
+	I_CQO,
+	I_CWD,
+	I_CWDE,
+	I_DAA,
+	I_DAS,
+	I_DEC,
+	I_DIV,
+	I_DMINT,
+	I_EMMS,
+	I_ENTER,
+	I_EQU,
+	I_F2XM1,
+	I_FABS,
+	I_FADD,
+	I_FADDP,
+	I_FBLD,
+	I_FBSTP,
+	I_FCHS,
+	I_FCLEX,
+	I_FCMOVB,
+	I_FCMOVBE,
+	I_FCMOVE,
+	I_FCMOVNB,
+	I_FCMOVNBE,
+	I_FCMOVNE,
+	I_FCMOVNU,
+	I_FCMOVU,
+	I_FCOM,
+	I_FCOMI,
+	I_FCOMIP,
+	I_FCOMP,
+	I_FCOMPP,
+	I_FCOS,
+	I_FDECSTP,
+	I_FDISI,
+	I_FDIV,
+	I_FDIVP,
+	I_FDIVR,
+	I_FDIVRP,
+	I_FEMMS,
+	I_FENI,
+	I_FFREE,
+	I_FFREEP,
+	I_FIADD,
+	I_FICOM,
+	I_FICOMP,
+	I_FIDIV,
+	I_FIDIVR,
+	I_FILD,
+	I_FIMUL,
+	I_FINCSTP,
+	I_FINIT,
+	I_FIST,
+	I_FISTP,
+	I_FISTTP,
+	I_FISUB,
+	I_FISUBR,
+	I_FLD,
+	I_FLD1,
+	I_FLDCW,
+	I_FLDENV,
+	I_FLDL2E,
+	I_FLDL2T,
+	I_FLDLG2,
+	I_FLDLN2,
+	I_FLDPI,
+	I_FLDZ,
+	I_FMUL,
+	I_FMULP,
+	I_FNCLEX,
+	I_FNDISI,
+	I_FNENI,
+	I_FNINIT,
+	I_FNOP,
+	I_FNSAVE,
+	I_FNSTCW,
+	I_FNSTENV,
+	I_FNSTSW,
+	I_FPATAN,
+	I_FPREM,
+	I_FPREM1,
+	I_FPTAN,
+	I_FRNDINT,
+	I_FRSTOR,
+	I_FSAVE,
+	I_FSCALE,
+	I_FSETPM,
+	I_FSIN,
+	I_FSINCOS,
+	I_FSQRT,
+	I_FST,
+	I_FSTCW,
+	I_FSTENV,
+	I_FSTP,
+	I_FSTSW,
+	I_FSUB,
+	I_FSUBP,
+	I_FSUBR,
+	I_FSUBRP,
+	I_FTST,
+	I_FUCOM,
+	I_FUCOMI,
+	I_FUCOMIP,
+	I_FUCOMP,
+	I_FUCOMPP,
+	I_FXAM,
+	I_FXCH,
+	I_FXTRACT,
+	I_FYL2X,
+	I_FYL2XP1,
+	I_HLT,
+	I_IBTS,
+	I_ICEBP,
+	I_IDIV,
+	I_IMUL,
+	I_IN,
+	I_INC,
+	I_INSB,
+	I_INSD,
+	I_INSW,
+	I_INT,
+	I_INT01,
+	I_INT1,
+	I_INT03,
+	I_INT3,
+	I_INTO,
+	I_INVD,
+	I_INVPCID,
+	I_INVLPG,
+	I_INVLPGA,
+	I_IRET,
+	I_IRETD,
+	I_IRETQ,
+	I_IRETW,
+	I_JCXZ,
+	I_JECXZ,
+	I_JRCXZ,
+	I_JMP,
+	I_JMPE,
+	I_LAHF,
+	I_LAR,
+	I_LDS,
+	I_LEA,
+	I_LEAVE,
+	I_LES,
+	I_LFENCE,
+	I_LFS,
+	I_LGDT,
+	I_LGS,
+	I_LIDT,
+	I_LLDT,
+	I_LMSW,
+	I_LOADALL,
+	I_LOADALL286,
+	I_LODSB,
+	I_LODSD,
+	I_LODSQ,
+	I_LODSW,
+	I_LOOP,
+	I_LOOPE,
+	I_LOOPNE,
+	I_LOOPNZ,
+	I_LOOPZ,
+	I_LSL,
+	I_LSS,
+	I_LTR,
+	I_MFENCE,
+	I_MONITOR,
+	I_MONITORX,
+	I_MOV,
+	I_MOVD,
+	I_MOVQ,
+	I_MOVSB,
+	I_MOVSD,
+	I_MOVSQ,
+	I_MOVSW,
+	I_MOVSX,
+	I_MOVSXD,
+	I_MOVZX,
+	I_MUL,
+	I_MWAIT,
+	I_MWAITX,
+	I_NEG,
+	I_NOP,
+	I_NOT,
+	I_OR,
+	I_OUT,
+	I_OUTSB,
+	I_OUTSD,
+	I_OUTSW,
+	I_PACKSSDW,
+	I_PACKSSWB,
+	I_PACKUSWB,
+	I_PADDB,
+	I_PADDD,
+	I_PADDSB,
+	I_PADDSIW,
+	I_PADDSW,
+	I_PADDUSB,
+	I_PADDUSW,
+	I_PADDW,
+	I_PAND,
+	I_PANDN,
+	I_PAUSE,
+	I_PAVEB,
+	I_PAVGUSB,
+	I_PCMPEQB,
+	I_PCMPEQD,
+	I_PCMPEQW,
+	I_PCMPGTB,
+	I_PCMPGTD,
+	I_PCMPGTW,
+	I_PDISTIB,
+	I_PF2ID,
+	I_PFACC,
+	I_PFADD,
+	I_PFCMPEQ,
+	I_PFCMPGE,
+	I_PFCMPGT,
+	I_PFMAX,
+	I_PFMIN,
+	I_PFMUL,
+	I_PFRCP,
+	I_PFRCPIT1,
+	I_PFRCPIT2,
+	I_PFRSQIT1,
+	I_PFRSQRT,
+	I_PFSUB,
+	I_PFSUBR,
+	I_PI2FD,
+	I_PMACHRIW,
+	I_PMADDWD,
+	I_PMAGW,
+	I_PMULHRIW,
+	I_PMULHRWA,
+	I_PMULHRWC,
+	I_PMULHW,
+	I_PMULLW,
+	I_PMVGEZB,
+	I_PMVLZB,
+	I_PMVNZB,
+	I_PMVZB,
+	I_POP,
+	I_POPA,
+	I_POPAD,
+	I_POPAW,
+	I_POPF,
+	I_POPFD,
+	I_POPFQ,
+	I_POPFW,
+	I_POR,
+	I_PREFETCH,
+	I_PREFETCHW,
+	I_PSLLD,
+	I_PSLLQ,
+	I_PSLLW,
+	I_PSRAD,
+	I_PSRAW,
+	I_PSRLD,
+	I_PSRLQ,
+	I_PSRLW,
+	I_PSUBB,
+	I_PSUBD,
+	I_PSUBSB,
+	I_PSUBSIW,
+	I_PSUBSW,
+	I_PSUBUSB,
+	I_PSUBUSW,
+	I_PSUBW,
+	I_PUNPCKHBW,
+	I_PUNPCKHDQ,
+	I_PUNPCKHWD,
+	I_PUNPCKLBW,
+	I_PUNPCKLDQ,
+	I_PUNPCKLWD,
+	I_PUSH,
+	I_PUSHA,
+	I_PUSHAD,
+	I_PUSHAW,
+	I_PUSHF,
+	I_PUSHFD,
+	I_PUSHFQ,
+	I_PUSHFW,
+	I_PXOR,
+	I_RCL,
+	I_RCR,
+	I_RDSHR,
+	I_RDMSR,
+	I_RDPMC,
+	I_RDTSC,
+	I_RDTSCP,
+	I_RET,
+	I_RETF,
+	I_RETN,
+	I_RETW,
+	I_RETFW,
+	I_RETNW,
+	I_RETD,
+	I_RETFD,
+	I_RETND,
+	I_RETQ,
+	I_RETFQ,
+	I_RETNQ,
+	I_ROL,
+	I_ROR,
+	I_RDM,
+	I_RSDC,
+	I_RSLDT,
+	I_RSM,
+	I_RSTS,
+	I_SAHF,
+	I_SAL,
+	I_SALC,
+	I_SAR,
+	I_SBB,
+	I_SCASB,
+	I_SCASD,
+	I_SCASQ,
+	I_SCASW,
+	I_SFENCE,
+	I_SGDT,
+	I_SHL,
+	I_SHLD,
+	I_SHR,
+	I_SHRD,
+	I_SIDT,
+	I_SLDT,
+	I_SKINIT,
+	I_SMI,
+	I_SMINT,
+	I_SMINTOLD,
+	I_SMSW,
+	I_STC,
+	I_STD,
+	I_STI,
+	I_STOSB,
+	I_STOSD,
+	I_STOSQ,
+	I_STOSW,
+	I_STR,
+	I_SUB,
+	I_SVDC,
+	I_SVLDT,
+	I_SVTS,
+	I_SWAPGS,
+	I_SYSCALL,
+	I_SYSENTER,
+	I_SYSEXIT,
+	I_SYSRET,
+	I_TEST,
+	I_UD0,
+	I_UD1,
+	I_UD2B,
+	I_UD2,
+	I_UD2A,
+	I_UMOV,
+	I_VERR,
+	I_VERW,
+	I_FWAIT,
+	I_WBINVD,
+	I_WRSHR,
+	I_WRMSR,
+	I_XADD,
+	I_XBTS,
+	I_XCHG,
+	I_XLATB,
+	I_XLAT,
+	I_XOR,
+	I_CMOVA,
+	I_CMOVAE,
+	I_CMOVB,
+	I_CMOVBE,
+	I_CMOVC,
+	I_CMOVE,
+	I_CMOVG,
+	I_CMOVGE,
+	I_CMOVL,
+	I_CMOVLE,
+	I_CMOVNA,
+	I_CMOVNAE,
+	I_CMOVNB,
+	I_CMOVNBE,
+	I_CMOVNC,
+	I_CMOVNE,
+	I_CMOVNG,
+	I_CMOVNGE,
+	I_CMOVNL,
+	I_CMOVNLE,
+	I_CMOVNO,
+	I_CMOVNP,
+	I_CMOVNS,
+	I_CMOVNZ,
+	I_CMOVO,
+	I_CMOVP,
+	I_CMOVPE,
+	I_CMOVPO,
+	I_CMOVS,
+	I_CMOVZ,
+	I_JA,
+	I_JAE,
+	I_JB,
+	I_JBE,
+	I_JC,
+	I_JE,
+	I_JG,
+	I_JGE,
+	I_JL,
+	I_JLE,
+	I_JNA,
+	I_JNAE,
+	I_JNB,
+	I_JNBE,
+	I_JNC,
+	I_JNE,
+	I_JNG,
+	I_JNGE,
+	I_JNL,
+	I_JNLE,
+	I_JNO,
+	I_JNP,
+	I_JNS,
+	I_JNZ,
+	I_JO,
+	I_JP,
+	I_JPE,
+	I_JPO,
+	I_JS,
+	I_JZ,
+	I_SETA,
+	I_SETAE,
+	I_SETB,
+	I_SETBE,
+	I_SETC,
+	I_SETE,
+	I_SETG,
+	I_SETGE,
+	I_SETL,
+	I_SETLE,
+	I_SETNA,
+	I_SETNAE,
+	I_SETNB,
+	I_SETNBE,
+	I_SETNC,
+	I_SETNE,
+	I_SETNG,
+	I_SETNGE,
+	I_SETNL,
+	I_SETNLE,
+	I_SETNO,
+	I_SETNP,
+	I_SETNS,
+	I_SETNZ,
+	I_SETO,
+	I_SETP,
+	I_SETPE,
+	I_SETPO,
+	I_SETS,
+	I_SETZ,
+	I_ADDPS,
+	I_ADDSS,
+	I_ANDNPS,
+	I_ANDPS,
+	I_CMPEQPS,
+	I_CMPEQSS,
+	I_CMPLEPS,
+	I_CMPLESS,
+	I_CMPLTPS,
+	I_CMPLTSS,
+	I_CMPNEQPS,
+	I_CMPNEQSS,
+	I_CMPNLEPS,
+	I_CMPNLESS,
+	I_CMPNLTPS,
+	I_CMPNLTSS,
+	I_CMPORDPS,
+	I_CMPORDSS,
+	I_CMPUNORDPS,
+	I_CMPUNORDSS,
+	I_CMPPS,
+	I_CMPSS,
+	I_COMISS,
+	I_CVTPI2PS,
+	I_CVTPS2PI,
+	I_CVTSI2SS,
+	I_CVTSS2SI,
+	I_CVTTPS2PI,
+	I_CVTTSS2SI,
+	I_DIVPS,
+	I_DIVSS,
+	I_LDMXCSR,
+	I_MAXPS,
+	I_MAXSS,
+	I_MINPS,
+	I_MINSS,
+	I_MOVAPS,
+	I_MOVHPS,
+	I_MOVLHPS,
+	I_MOVLPS,
+	I_MOVHLPS,
+	I_MOVMSKPS,
+	I_MOVNTPS,
+	I_MOVSS,
+	I_MOVUPS,
+	I_MULPS,
+	I_MULSS,
+	I_ORPS,
+	I_RCPPS,
+	I_RCPSS,
+	I_RSQRTPS,
+	I_RSQRTSS,
+	I_SHUFPS,
+	I_SQRTPS,
+	I_SQRTSS,
+	I_STMXCSR,
+	I_SUBPS,
+	I_SUBSS,
+	I_UCOMISS,
+	I_UNPCKHPS,
+	I_UNPCKLPS,
+	I_XORPS,
+	I_FXRSTOR,
+	I_FXRSTOR64,
+	I_FXSAVE,
+	I_FXSAVE64,
+	I_XGETBV,
+	I_XSETBV,
+	I_XSAVE,
+	I_XSAVE64,
+	I_XSAVEC,
+	I_XSAVEC64,
+	I_XSAVEOPT,
+	I_XSAVEOPT64,
+	I_XSAVES,
+	I_XSAVES64,
+	I_XRSTOR,
+	I_XRSTOR64,
+	I_XRSTORS,
+	I_XRSTORS64,
+	I_PREFETCHNTA,
+	I_PREFETCHT0,
+	I_PREFETCHT1,
+	I_PREFETCHT2,
+	I_PREFETCHIT0,
+	I_PREFETCHIT1,
+	I_MASKMOVQ,
+	I_MOVNTQ,
+	I_PAVGB,
+	I_PAVGW,
+	I_PEXTRW,
+	I_PINSRW,
+	I_PMAXSW,
+	I_PMAXUB,
+	I_PMINSW,
+	I_PMINUB,
+	I_PMOVMSKB,
+	I_PMULHUW,
+	I_PSADBW,
+	I_PSHUFW,
+	I_PF2IW,
+	I_PFNACC,
+	I_PFPNACC,
+	I_PI2FW,
+	I_PSWAPD,
+	I_MASKMOVDQU,
+	I_CLFLUSH,
+	I_MOVNTDQ,
+	I_MOVNTI,
+	I_MOVNTPD,
+	I_MOVDQA,
+	I_MOVDQU,
+	I_MOVDQ2Q,
+	I_MOVQ2DQ,
+	I_PADDQ,
+	I_PMULUDQ,
+	I_PSHUFD,
+	I_PSHUFHW,
+	I_PSHUFLW,
+	I_PSLLDQ,
+	I_PSRLDQ,
+	I_PSUBQ,
+	I_PUNPCKHQDQ,
+	I_PUNPCKLQDQ,
+	I_ADDPD,
+	I_ADDSD,
+	I_ANDNPD,
+	I_ANDPD,
+	I_CMPEQPD,
+	I_CMPEQSD,
+	I_CMPLEPD,
+	I_CMPLESD,
+	I_CMPLTPD,
+	I_CMPLTSD,
+	I_CMPNEQPD,
+	I_CMPNEQSD,
+	I_CMPNLEPD,
+	I_CMPNLESD,
+	I_CMPNLTPD,
+	I_CMPNLTSD,
+	I_CMPORDPD,
+	I_CMPORDSD,
+	I_CMPUNORDPD,
+	I_CMPUNORDSD,
+	I_CMPPD,
+	I_COMISD,
+	I_CVTDQ2PD,
+	I_CVTDQ2PS,
+	I_CVTPD2DQ,
+	I_CVTPD2PI,
+	I_CVTPD2PS,
+	I_CVTPI2PD,
+	I_CVTPS2DQ,
+	I_CVTPS2PD,
+	I_CVTSD2SI,
+	I_CVTSD2SS,
+	I_CVTSI2SD,
+	I_CVTSS2SD,
+	I_CVTTPD2PI,
+	I_CVTTPD2DQ,
+	I_CVTTPS2DQ,
+	I_CVTTSD2SI,
+	I_DIVPD,
+	I_DIVSD,
+	I_MAXPD,
+	I_MAXSD,
+	I_MINPD,
+	I_MINSD,
+	I_MOVAPD,
+	I_MOVHPD,
+	I_MOVLPD,
+	I_MOVMSKPD,
+	I_MOVUPD,
+	I_MULPD,
+	I_MULSD,
+	I_ORPD,
+	I_SHUFPD,
+	I_SQRTPD,
+	I_SQRTSD,
+	I_SUBPD,
+	I_SUBSD,
+	I_UCOMISD,
+	I_UNPCKHPD,
+	I_UNPCKLPD,
+	I_XORPD,
+	I_ADDSUBPD,
+	I_ADDSUBPS,
+	I_HADDPD,
+	I_HADDPS,
+	I_HSUBPD,
+	I_HSUBPS,
+	I_LDDQU,
+	I_MOVDDUP,
+	I_MOVSHDUP,
+	I_MOVSLDUP,
+	I_CLGI,
+	I_STGI,
+	I_VMCALL,
+	I_VMCLEAR,
+	I_VMFUNC,
+	I_VMLAUNCH,
+	I_VMLOAD,
+	I_VMMCALL,
+	I_VMPTRLD,
+	I_VMPTRST,
+	I_VMREAD,
+	I_VMRESUME,
+	I_VMRUN,
+	I_VMSAVE,
+	I_VMWRITE,
+	I_VMXOFF,
+	I_VMXON,
+	I_INVEPT,
+	I_INVVPID,
+	I_PVALIDATE,
+	I_RMPADJUST,
+	I_VMGEXIT,
+	I_PABSB,
+	I_PABSW,
+	I_PABSD,
+	I_PALIGNR,
+	I_PHADDW,
+	I_PHADDD,
+	I_PHADDSW,
+	I_PHSUBW,
+	I_PHSUBD,
+	I_PHSUBSW,
+	I_PMADDUBSW,
+	I_PMULHRSW,
+	I_PSHUFB,
+	I_PSIGNB,
+	I_PSIGNW,
+	I_PSIGND,
+	I_EXTRQ,
+	I_INSERTQ,
+	I_MOVNTSD,
+	I_MOVNTSS,
+	I_LZCNT,
+	I_BLENDPD,
+	I_BLENDPS,
+	I_BLENDVPD,
+	I_BLENDVPS,
+	I_DPPD,
+	I_DPPS,
+	I_EXTRACTPS,
+	I_INSERTPS,
+	I_MOVNTDQA,
+	I_MPSADBW,
+	I_PACKUSDW,
+	I_PBLENDVB,
+	I_PBLENDW,
+	I_PCMPEQQ,
+	I_PEXTRB,
+	I_PEXTRD,
+	I_PEXTRQ,
+	I_PHMINPOSUW,
+	I_PINSRB,
+	I_PINSRD,
+	I_PINSRQ,
+	I_PMAXSB,
+	I_PMAXSD,
+	I_PMAXUD,
+	I_PMAXUW,
+	I_PMINSB,
+	I_PMINSD,
+	I_PMINUD,
+	I_PMINUW,
+	I_PMOVSXBW,
+	I_PMOVSXBD,
+	I_PMOVSXBQ,
+	I_PMOVSXWD,
+	I_PMOVSXWQ,
+	I_PMOVSXDQ,
+	I_PMOVZXBW,
+	I_PMOVZXBD,
+	I_PMOVZXBQ,
+	I_PMOVZXWD,
+	I_PMOVZXWQ,
+	I_PMOVZXDQ,
+	I_PMULDQ,
+	I_PMULLD,
+	I_PTEST,
+	I_ROUNDPD,
+	I_ROUNDPS,
+	I_ROUNDSD,
+	I_ROUNDSS,
+	I_CRC32,
+	I_PCMPESTRI,
+	I_PCMPESTRM,
+	I_PCMPISTRI,
+	I_PCMPISTRM,
+	I_PCMPGTQ,
+	I_POPCNT,
+	I_GETSEC,
+	I_PFRCPV,
+	I_PFRSQRTV,
+	I_MOVBE,
+	I_AESENC,
+	I_AESENCLAST,
+	I_AESDEC,
+	I_AESDECLAST,
+	I_AESIMC,
+	I_AESKEYGENASSIST,
+	I_VAESENC,
+	I_VAESENCLAST,
+	I_VAESDEC,
+	I_VAESDECLAST,
+	I_VAESIMC,
+	I_VAESKEYGENASSIST,
+	I_VADDPD,
+	I_VADDPS,
+	I_VADDSD,
+	I_VADDSS,
+	I_VADDSUBPD,
+	I_VADDSUBPS,
+	I_VANDPD,
+	I_VANDPS,
+	I_VANDNPD,
+	I_VANDNPS,
+	I_VBLENDPD,
+	I_VBLENDPS,
+	I_VBLENDVPD,
+	I_VBLENDVPS,
+	I_VBROADCASTSS,
+	I_VBROADCASTSD,
+	I_VBROADCASTF128,
+	I_VCMPEQ_OSPD,
+	I_VCMPEQPD,
+	I_VCMPLT_OSPD,
+	I_VCMPLTPD,
+	I_VCMPLE_OSPD,
+	I_VCMPLEPD,
+	I_VCMPUNORD_QPD,
+	I_VCMPUNORDPD,
+	I_VCMPNEQ_UQPD,
+	I_VCMPNEQPD,
+	I_VCMPNLT_USPD,
+	I_VCMPNLTPD,
+	I_VCMPNLE_USPD,
+	I_VCMPNLEPD,
+	I_VCMPORD_QPD,
+	I_VCMPORDPD,
+	I_VCMPEQ_UQPD,
+	I_VCMPNGE_USPD,
+	I_VCMPNGEPD,
+	I_VCMPNGT_USPD,
+	I_VCMPNGTPD,
+	I_VCMPFALSE_OQPD,
+	I_VCMPFALSEPD,
+	I_VCMPNEQ_OQPD,
+	I_VCMPGE_OSPD,
+	I_VCMPGEPD,
+	I_VCMPGT_OSPD,
+	I_VCMPGTPD,
+	I_VCMPTRUE_UQPD,
+	I_VCMPTRUEPD,
+	I_VCMPLT_OQPD,
+	I_VCMPLE_OQPD,
+	I_VCMPUNORD_SPD,
+	I_VCMPNEQ_USPD,
+	I_VCMPNLT_UQPD,
+	I_VCMPNLE_UQPD,
+	I_VCMPORD_SPD,
+	I_VCMPEQ_USPD,
+	I_VCMPNGE_UQPD,
+	I_VCMPNGT_UQPD,
+	I_VCMPFALSE_OSPD,
+	I_VCMPNEQ_OSPD,
+	I_VCMPGE_OQPD,
+	I_VCMPGT_OQPD,
+	I_VCMPTRUE_USPD,
+	I_VCMPPD,
+	I_VCMPEQ_OSPS,
+	I_VCMPEQPS,
+	I_VCMPLT_OSPS,
+	I_VCMPLTPS,
+	I_VCMPLE_OSPS,
+	I_VCMPLEPS,
+	I_VCMPUNORD_QPS,
+	I_VCMPUNORDPS,
+	I_VCMPNEQ_UQPS,
+	I_VCMPNEQPS,
+	I_VCMPNLT_USPS,
+	I_VCMPNLTPS,
+	I_VCMPNLE_USPS,
+	I_VCMPNLEPS,
+	I_VCMPORD_QPS,
+	I_VCMPORDPS,
+	I_VCMPEQ_UQPS,
+	I_VCMPNGE_USPS,
+	I_VCMPNGEPS,
+	I_VCMPNGT_USPS,
+	I_VCMPNGTPS,
+	I_VCMPFALSE_OQPS,
+	I_VCMPFALSEPS,
+	I_VCMPNEQ_OQPS,
+	I_VCMPGE_OSPS,
+	I_VCMPGEPS,
+	I_VCMPGT_OSPS,
+	I_VCMPGTPS,
+	I_VCMPTRUE_UQPS,
+	I_VCMPTRUEPS,
+	I_VCMPLT_OQPS,
+	I_VCMPLE_OQPS,
+	I_VCMPUNORD_SPS,
+	I_VCMPNEQ_USPS,
+	I_VCMPNLT_UQPS,
+	I_VCMPNLE_UQPS,
+	I_VCMPORD_SPS,
+	I_VCMPEQ_USPS,
+	I_VCMPNGE_UQPS,
+	I_VCMPNGT_UQPS,
+	I_VCMPFALSE_OSPS,
+	I_VCMPNEQ_OSPS,
+	I_VCMPGE_OQPS,
+	I_VCMPGT_OQPS,
+	I_VCMPTRUE_USPS,
+	I_VCMPPS,
+	I_VCMPEQ_OSSD,
+	I_VCMPEQSD,
+	I_VCMPLT_OSSD,
+	I_VCMPLTSD,
+	I_VCMPLE_OSSD,
+	I_VCMPLESD,
+	I_VCMPUNORD_QSD,
+	I_VCMPUNORDSD,
+	I_VCMPNEQ_UQSD,
+	I_VCMPNEQSD,
+	I_VCMPNLT_USSD,
+	I_VCMPNLTSD,
+	I_VCMPNLE_USSD,
+	I_VCMPNLESD,
+	I_VCMPORD_QSD,
+	I_VCMPORDSD,
+	I_VCMPEQ_UQSD,
+	I_VCMPNGE_USSD,
+	I_VCMPNGESD,
+	I_VCMPNGT_USSD,
+	I_VCMPNGTSD,
+	I_VCMPFALSE_OQSD,
+	I_VCMPFALSESD,
+	I_VCMPNEQ_OQSD,
+	I_VCMPGE_OSSD,
+	I_VCMPGESD,
+	I_VCMPGT_OSSD,
+	I_VCMPGTSD,
+	I_VCMPTRUE_UQSD,
+	I_VCMPTRUESD,
+	I_VCMPLT_OQSD,
+	I_VCMPLE_OQSD,
+	I_VCMPUNORD_SSD,
+	I_VCMPNEQ_USSD,
+	I_VCMPNLT_UQSD,
+	I_VCMPNLE_UQSD,
+	I_VCMPORD_SSD,
+	I_VCMPEQ_USSD,
+	I_VCMPNGE_UQSD,
+	I_VCMPNGT_UQSD,
+	I_VCMPFALSE_OSSD,
+	I_VCMPNEQ_OSSD,
+	I_VCMPGE_OQSD,
+	I_VCMPGT_OQSD,
+	I_VCMPTRUE_USSD,
+	I_VCMPSD,
+	I_VCMPEQ_OSSS,
+	I_VCMPEQSS,
+	I_VCMPLT_OSSS,
+	I_VCMPLTSS,
+	I_VCMPLE_OSSS,
+	I_VCMPLESS,
+	I_VCMPUNORD_QSS,
+	I_VCMPUNORDSS,
+	I_VCMPNEQ_UQSS,
+	I_VCMPNEQSS,
+	I_VCMPNLT_USSS,
+	I_VCMPNLTSS,
+	I_VCMPNLE_USSS,
+	I_VCMPNLESS,
+	I_VCMPORD_QSS,
+	I_VCMPORDSS,
+	I_VCMPEQ_UQSS,
+	I_VCMPNGE_USSS,
+	I_VCMPNGESS,
+	I_VCMPNGT_USSS,
+	I_VCMPNGTSS,
+	I_VCMPFALSE_OQSS,
+	I_VCMPFALSESS,
+	I_VCMPNEQ_OQSS,
+	I_VCMPGE_OSSS,
+	I_VCMPGESS,
+	I_VCMPGT_OSSS,
+	I_VCMPGTSS,
+	I_VCMPTRUE_UQSS,
+	I_VCMPTRUESS,
+	I_VCMPLT_OQSS,
+	I_VCMPLE_OQSS,
+	I_VCMPUNORD_SSS,
+	I_VCMPNEQ_USSS,
+	I_VCMPNLT_UQSS,
+	I_VCMPNLE_UQSS,
+	I_VCMPORD_SSS,
+	I_VCMPEQ_USSS,
+	I_VCMPNGE_UQSS,
+	I_VCMPNGT_UQSS,
+	I_VCMPFALSE_OSSS,
+	I_VCMPNEQ_OSSS,
+	I_VCMPGE_OQSS,
+	I_VCMPGT_OQSS,
+	I_VCMPTRUE_USSS,
+	I_VCMPSS,
+	I_VCOMISD,
+	I_VCOMISS,
+	I_VCVTDQ2PD,
+	I_VCVTDQ2PS,
+	I_VCVTPD2DQ,
+	I_VCVTPD2PS,
+	I_VCVTPS2DQ,
+	I_VCVTPS2PD,
+	I_VCVTSD2SI,
+	I_VCVTSD2SS,
+	I_VCVTSI2SD,
+	I_VCVTSI2SS,
+	I_VCVTSS2SD,
+	I_VCVTSS2SI,
+	I_VCVTTPD2DQ,
+	I_VCVTTPS2DQ,
+	I_VCVTTSD2SI,
+	I_VCVTTSS2SI,
+	I_VDIVPD,
+	I_VDIVPS,
+	I_VDIVSD,
+	I_VDIVSS,
+	I_VDPPD,
+	I_VDPPS,
+	I_VEXTRACTF128,
+	I_VEXTRACTPS,
+	I_VHADDPD,
+	I_VHADDPS,
+	I_VHSUBPD,
+	I_VHSUBPS,
+	I_VINSERTF128,
+	I_VINSERTPS,
+	I_VLDDQU,
+	I_VLDQQU,
+	I_VLDMXCSR,
+	I_VMASKMOVDQU,
+	I_VMASKMOVPS,
+	I_VMASKMOVPD,
+	I_VMAXPD,
+	I_VMAXPS,
+	I_VMAXSD,
+	I_VMAXSS,
+	I_VMINPD,
+	I_VMINPS,
+	I_VMINSD,
+	I_VMINSS,
+	I_VMOVAPD,
+	I_VMOVAPS,
+	I_VMOVD,
+	I_VMOVQ,
+	I_VMOVDDUP,
+	I_VMOVDQA,
+	I_VMOVQQA,
+	I_VMOVDQU,
+	I_VMOVQQU,
+	I_VMOVHLPS,
+	I_VMOVHPD,
+	I_VMOVHPS,
+	I_VMOVLHPS,
+	I_VMOVLPD,
+	I_VMOVLPS,
+	I_VMOVMSKPD,
+	I_VMOVMSKPS,
+	I_VMOVNTDQ,
+	I_VMOVNTQQ,
+	I_VMOVNTDQA,
+	I_VMOVNTPD,
+	I_VMOVNTPS,
+	I_VMOVSD,
+	I_VMOVSHDUP,
+	I_VMOVSLDUP,
+	I_VMOVSS,
+	I_VMOVUPD,
+	I_VMOVUPS,
+	I_VMPSADBW,
+	I_VMULPD,
+	I_VMULPS,
+	I_VMULSD,
+	I_VMULSS,
+	I_VORPD,
+	I_VORPS,
+	I_VPABSB,
+	I_VPABSW,
+	I_VPABSD,
+	I_VPACKSSWB,
+	I_VPACKSSDW,
+	I_VPACKUSWB,
+	I_VPACKUSDW,
+	I_VPADDB,
+	I_VPADDW,
+	I_VPADDD,
+	I_VPADDQ,
+	I_VPADDSB,
+	I_VPADDSW,
+	I_VPADDUSB,
+	I_VPADDUSW,
+	I_VPALIGNR,
+	I_VPAND,
+	I_VPANDN,
+	I_VPAVGB,
+	I_VPAVGW,
+	I_VPBLENDVB,
+	I_VPBLENDW,
+	I_VPCMPESTRI,
+	I_VPCMPESTRM,
+	I_VPCMPISTRI,
+	I_VPCMPISTRM,
+	I_VPCMPEQB,
+	I_VPCMPEQW,
+	I_VPCMPEQD,
+	I_VPCMPEQQ,
+	I_VPCMPGTB,
+	I_VPCMPGTW,
+	I_VPCMPGTD,
+	I_VPCMPGTQ,
+	I_VPERMILPD,
+	I_VPERMILPS,
+	I_VPERM2F128,
+	I_VPEXTRB,
+	I_VPEXTRW,
+	I_VPEXTRD,
+	I_VPEXTRQ,
+	I_VPHADDW,
+	I_VPHADDD,
+	I_VPHADDSW,
+	I_VPHMINPOSUW,
+	I_VPHSUBW,
+	I_VPHSUBD,
+	I_VPHSUBSW,
+	I_VPINSRB,
+	I_VPINSRW,
+	I_VPINSRD,
+	I_VPINSRQ,
+	I_VPMADDWD,
+	I_VPMADDUBSW,
+	I_VPMAXSB,
+	I_VPMAXSW,
+	I_VPMAXSD,
+	I_VPMAXUB,
+	I_VPMAXUW,
+	I_VPMAXUD,
+	I_VPMINSB,
+	I_VPMINSW,
+	I_VPMINSD,
+	I_VPMINUB,
+	I_VPMINUW,
+	I_VPMINUD,
+	I_VPMOVMSKB,
+	I_VPMOVSXBW,
+	I_VPMOVSXBD,
+	I_VPMOVSXBQ,
+	I_VPMOVSXWD,
+	I_VPMOVSXWQ,
+	I_VPMOVSXDQ,
+	I_VPMOVZXBW,
+	I_VPMOVZXBD,
+	I_VPMOVZXBQ,
+	I_VPMOVZXWD,
+	I_VPMOVZXWQ,
+	I_VPMOVZXDQ,
+	I_VPMULHUW,
+	I_VPMULHRSW,
+	I_VPMULHW,
+	I_VPMULLW,
+	I_VPMULLD,
+	I_VPMULUDQ,
+	I_VPMULDQ,
+	I_VPOR,
+	I_VPSADBW,
+	I_VPSHUFB,
+	I_VPSHUFD,
+	I_VPSHUFHW,
+	I_VPSHUFLW,
+	I_VPSIGNB,
+	I_VPSIGNW,
+	I_VPSIGND,
+	I_VPSLLDQ,
+	I_VPSRLDQ,
+	I_VPSLLW,
+	I_VPSLLD,
+	I_VPSLLQ,
+	I_VPSRAW,
+	I_VPSRAD,
+	I_VPSRLW,
+	I_VPSRLD,
+	I_VPSRLQ,
+	I_VPTEST,
+	I_VPSUBB,
+	I_VPSUBW,
+	I_VPSUBD,
+	I_VPSUBQ,
+	I_VPSUBSB,
+	I_VPSUBSW,
+	I_VPSUBUSB,
+	I_VPSUBUSW,
+	I_VPUNPCKHBW,
+	I_VPUNPCKHWD,
+	I_VPUNPCKHDQ,
+	I_VPUNPCKHQDQ,
+	I_VPUNPCKLBW,
+	I_VPUNPCKLWD,
+	I_VPUNPCKLDQ,
+	I_VPUNPCKLQDQ,
+	I_VPXOR,
+	I_VRCPPS,
+	I_VRCPSS,
+	I_VRSQRTPS,
+	I_VRSQRTSS,
+	I_VROUNDPD,
+	I_VROUNDPS,
+	I_VROUNDSD,
+	I_VROUNDSS,
+	I_VSHUFPD,
+	I_VSHUFPS,
+	I_VSQRTPD,
+	I_VSQRTPS,
+	I_VSQRTSD,
+	I_VSQRTSS,
+	I_VSTMXCSR,
+	I_VSUBPD,
+	I_VSUBPS,
+	I_VSUBSD,
+	I_VSUBSS,
+	I_VTESTPS,
+	I_VTESTPD,
+	I_VUCOMISD,
+	I_VUCOMISS,
+	I_VUNPCKHPD,
+	I_VUNPCKHPS,
+	I_VUNPCKLPD,
+	I_VUNPCKLPS,
+	I_VXORPD,
+	I_VXORPS,
+	I_VZEROALL,
+	I_VZEROUPPER,
+	I_PCLMULLQLQDQ,
+	I_PCLMULHQLQDQ,
+	I_PCLMULLQHQDQ,
+	I_PCLMULHQHQDQ,
+	I_PCLMULQDQ,
+	I_VPCLMULLQLQDQ,
+	I_VPCLMULHQLQDQ,
+	I_VPCLMULLQHQDQ,
+	I_VPCLMULHQHQDQ,
+	I_VPCLMULQDQ,
+	I_VFMADD132PS,
+	I_VFMADD132PD,
+	I_VFMADD312PS,
+	I_VFMADD312PD,
+	I_VFMADD213PS,
+	I_VFMADD213PD,
+	I_VFMADD123PS,
+	I_VFMADD123PD,
+	I_VFMADD231PS,
+	I_VFMADD231PD,
+	I_VFMADD321PS,
+	I_VFMADD321PD,
+	I_VFMADDSUB132PS,
+	I_VFMADDSUB132PD,
+	I_VFMADDSUB312PS,
+	I_VFMADDSUB312PD,
+	I_VFMADDSUB213PS,
+	I_VFMADDSUB213PD,
+	I_VFMADDSUB123PS,
+	I_VFMADDSUB123PD,
+	I_VFMADDSUB231PS,
+	I_VFMADDSUB231PD,
+	I_VFMADDSUB321PS,
+	I_VFMADDSUB321PD,
+	I_VFMSUB132PS,
+	I_VFMSUB132PD,
+	I_VFMSUB312PS,
+	I_VFMSUB312PD,
+	I_VFMSUB213PS,
+	I_VFMSUB213PD,
+	I_VFMSUB123PS,
+	I_VFMSUB123PD,
+	I_VFMSUB231PS,
+	I_VFMSUB231PD,
+	I_VFMSUB321PS,
+	I_VFMSUB321PD,
+	I_VFMSUBADD132PS,
+	I_VFMSUBADD132PD,
+	I_VFMSUBADD312PS,
+	I_VFMSUBADD312PD,
+	I_VFMSUBADD213PS,
+	I_VFMSUBADD213PD,
+	I_VFMSUBADD123PS,
+	I_VFMSUBADD123PD,
+	I_VFMSUBADD231PS,
+	I_VFMSUBADD231PD,
+	I_VFMSUBADD321PS,
+	I_VFMSUBADD321PD,
+	I_VFNMADD132PS,
+	I_VFNMADD132PD,
+	I_VFNMADD312PS,
+	I_VFNMADD312PD,
+	I_VFNMADD213PS,
+	I_VFNMADD213PD,
+	I_VFNMADD123PS,
+	I_VFNMADD123PD,
+	I_VFNMADD231PS,
+	I_VFNMADD231PD,
+	I_VFNMADD321PS,
+	I_VFNMADD321PD,
+	I_VFNMSUB132PS,
+	I_VFNMSUB132PD,
+	I_VFNMSUB312PS,
+	I_VFNMSUB312PD,
+	I_VFNMSUB213PS,
+	I_VFNMSUB213PD,
+	I_VFNMSUB123PS,
+	I_VFNMSUB123PD,
+	I_VFNMSUB231PS,
+	I_VFNMSUB231PD,
+	I_VFNMSUB321PS,
+	I_VFNMSUB321PD,
+	I_VFMADD132SS,
+	I_VFMADD132SD,
+	I_VFMADD312SS,
+	I_VFMADD312SD,
+	I_VFMADD213SS,
+	I_VFMADD213SD,
+	I_VFMADD123SS,
+	I_VFMADD123SD,
+	I_VFMADD231SS,
+	I_VFMADD231SD,
+	I_VFMADD321SS,
+	I_VFMADD321SD,
+	I_VFMSUB132SS,
+	I_VFMSUB132SD,
+	I_VFMSUB312SS,
+	I_VFMSUB312SD,
+	I_VFMSUB213SS,
+	I_VFMSUB213SD,
+	I_VFMSUB123SS,
+	I_VFMSUB123SD,
+	I_VFMSUB231SS,
+	I_VFMSUB231SD,
+	I_VFMSUB321SS,
+	I_VFMSUB321SD,
+	I_VFNMADD132SS,
+	I_VFNMADD132SD,
+	I_VFNMADD312SS,
+	I_VFNMADD312SD,
+	I_VFNMADD213SS,
+	I_VFNMADD213SD,
+	I_VFNMADD123SS,
+	I_VFNMADD123SD,
+	I_VFNMADD231SS,
+	I_VFNMADD231SD,
+	I_VFNMADD321SS,
+	I_VFNMADD321SD,
+	I_VFNMSUB132SS,
+	I_VFNMSUB132SD,
+	I_VFNMSUB312SS,
+	I_VFNMSUB312SD,
+	I_VFNMSUB213SS,
+	I_VFNMSUB213SD,
+	I_VFNMSUB123SS,
+	I_VFNMSUB123SD,
+	I_VFNMSUB231SS,
+	I_VFNMSUB231SD,
+	I_VFNMSUB321SS,
+	I_VFNMSUB321SD,
+	I_RDFSBASE,
+	I_RDGSBASE,
+	I_RDRAND,
+	I_WRFSBASE,
+	I_WRGSBASE,
+	I_VCVTPH2PS,
+	I_VCVTPS2PH,
+	I_ADCX,
+	I_ADOX,
+	I_RDSEED,
+	I_CLAC,
+	I_STAC,
+	I_XSTORE,
+	I_XCRYPTECB,
+	I_XCRYPTCBC,
+	I_XCRYPTCTR,
+	I_XCRYPTCFB,
+	I_XCRYPTOFB,
+	I_MONTMUL,
+	I_XSHA1,
+	I_XSHA256,
+	I_LLWPCB,
+	I_SLWPCB,
+	I_LWPVAL,
+	I_LWPINS,
+	I_VFMADDPD,
+	I_VFMADDPS,
+	I_VFMADDSD,
+	I_VFMADDSS,
+	I_VFMADDSUBPD,
+	I_VFMADDSUBPS,
+	I_VFMSUBADDPD,
+	I_VFMSUBADDPS,
+	I_VFMSUBPD,
+	I_VFMSUBPS,
+	I_VFMSUBSD,
+	I_VFMSUBSS,
+	I_VFNMADDPD,
+	I_VFNMADDPS,
+	I_VFNMADDSD,
+	I_VFNMADDSS,
+	I_VFNMSUBPD,
+	I_VFNMSUBPS,
+	I_VFNMSUBSD,
+	I_VFNMSUBSS,
+	I_VFRCZPD,
+	I_VFRCZPS,
+	I_VFRCZSD,
+	I_VFRCZSS,
+	I_VPCMOV,
+	I_VPCOMB,
+	I_VPCOMD,
+	I_VPCOMQ,
+	I_VPCOMUB,
+	I_VPCOMUD,
+	I_VPCOMUQ,
+	I_VPCOMUW,
+	I_VPCOMW,
+	I_VPHADDBD,
+	I_VPHADDBQ,
+	I_VPHADDBW,
+	I_VPHADDDQ,
+	I_VPHADDUBD,
+	I_VPHADDUBQ,
+	I_VPHADDUBW,
+	I_VPHADDUDQ,
+	I_VPHADDUWD,
+	I_VPHADDUWQ,
+	I_VPHADDWD,
+	I_VPHADDWQ,
+	I_VPHSUBBW,
+	I_VPHSUBDQ,
+	I_VPHSUBWD,
+	I_VPMACSDD,
+	I_VPMACSDQH,
+	I_VPMACSDQL,
+	I_VPMACSSDD,
+	I_VPMACSSDQH,
+	I_VPMACSSDQL,
+	I_VPMACSSWD,
+	I_VPMACSSWW,
+	I_VPMACSWD,
+	I_VPMACSWW,
+	I_VPMADCSSWD,
+	I_VPMADCSWD,
+	I_VPPERM,
+	I_VPROTB,
+	I_VPROTD,
+	I_VPROTQ,
+	I_VPROTW,
+	I_VPSHAB,
+	I_VPSHAD,
+	I_VPSHAQ,
+	I_VPSHAW,
+	I_VPSHLB,
+	I_VPSHLD,
+	I_VPSHLQ,
+	I_VPSHLW,
+	I_VBROADCASTI128,
+	I_VPBLENDD,
+	I_VPBROADCASTB,
+	I_VPBROADCASTW,
+	I_VPBROADCASTD,
+	I_VPBROADCASTQ,
+	I_VPERMD,
+	I_VPERMPD,
+	I_VPERMPS,
+	I_VPERMQ,
+	I_VPERM2I128,
+	I_VEXTRACTI128,
+	I_VINSERTI128,
+	I_VPMASKMOVD,
+	I_VPMASKMOVQ,
+	I_VPSLLVD,
+	I_VPSLLVQ,
+	I_VPSRAVD,
+	I_VPSRLVD,
+	I_VPSRLVQ,
+	I_VGATHERDPD,
+	I_VGATHERQPD,
+	I_VGATHERDPS,
+	I_VGATHERQPS,
+	I_VPGATHERDD,
+	I_VPGATHERQD,
+	I_VPGATHERDQ,
+	I_VPGATHERQQ,
+	I_XABORT,
+	I_XBEGIN,
+	I_XEND,
+	I_XTEST,
+	I_ANDN,
+	I_BEXTR,
+	I_BLCI,
+	I_BLCIC,
+	I_BLSI,
+	I_BLSIC,
+	I_BLCFILL,
+	I_BLSFILL,
+	I_BLCMSK,
+	I_BLSMSK,
+	I_BLSR,
+	I_BLCS,
+	I_BZHI,
+	I_MULX,
+	I_PDEP,
+	I_PEXT,
+	I_RORX,
+	I_SARX,
+	I_SHLX,
+	I_SHRX,
+	I_TZCNT,
+	I_TZMSK,
+	I_T1MSKC,
+	I_PREFETCHWT1,
+	I_BNDMK,
+	I_BNDCL,
+	I_BNDCU,
+	I_BNDCN,
+	I_BNDMOV,
+	I_BNDLDX,
+	I_BNDSTX,
+	I_SHA1MSG1,
+	I_SHA1MSG2,
+	I_SHA1NEXTE,
+	I_SHA1RNDS4,
+	I_SHA256MSG1,
+	I_SHA256MSG2,
+	I_SHA256RNDS2,
+	I_VBCSTNEBF16PS,
+	I_VBCSTNESH2PS,
+	I_VCVTNEEBF162PS,
+	I_VCVTNEEPH2PS,
+	I_VCVTNEOBF162PS,
+	I_VCVTNEOPH2PS,
+	I_VCVTNEPS2BF16,
+	I_VPDPBSSD,
+	I_VPDPBSSDS,
+	I_VPDPBSUD,
+	I_VPDPBSUDS,
+	I_VPDPBUUD,
+	I_VPDPBUUDS,
+	I_VPMADD52HUQ,
+	I_VPMADD52LUQ,
+	I_KADDB,
+	I_KADDD,
+	I_KADDQ,
+	I_KADDW,
+	I_KANDB,
+	I_KANDD,
+	I_KANDNB,
+	I_KANDND,
+	I_KANDNQ,
+	I_KANDNW,
+	I_KANDQ,
+	I_KANDW,
+	I_KMOVB,
+	I_KMOVD,
+	I_KMOVQ,
+	I_KMOVW,
+	I_KNOTB,
+	I_KNOTD,
+	I_KNOTQ,
+	I_KNOTW,
+	I_KORB,
+	I_KORD,
+	I_KORQ,
+	I_KORW,
+	I_KORTESTB,
+	I_KORTESTD,
+	I_KORTESTQ,
+	I_KORTESTW,
+	I_KSHIFTLB,
+	I_KSHIFTLD,
+	I_KSHIFTLQ,
+	I_KSHIFTLW,
+	I_KSHIFTRB,
+	I_KSHIFTRD,
+	I_KSHIFTRQ,
+	I_KSHIFTRW,
+	I_KTESTB,
+	I_KTESTD,
+	I_KTESTQ,
+	I_KTESTW,
+	I_KUNPCKBW,
+	I_KUNPCKDQ,
+	I_KUNPCKWD,
+	I_KXNORB,
+	I_KXNORD,
+	I_KXNORQ,
+	I_KXNORW,
+	I_KXORB,
+	I_KXORD,
+	I_KXORQ,
+	I_KXORW,
+	I_KADD,
+	I_KAND,
+	I_KANDN,
+	I_KMOV,
+	I_KNOT,
+	I_KOR,
+	I_KORTEST,
+	I_KSHIFTL,
+	I_KSHIFTR,
+	I_KTEST,
+	I_KUNPCK,
+	I_KXNOR,
+	I_KXOR,
+	I_VALIGND,
+	I_VALIGNQ,
+	I_VBLENDMPD,
+	I_VBLENDMPS,
+	I_VBROADCASTF32X2,
+	I_VBROADCASTF32X4,
+	I_VBROADCASTF32X8,
+	I_VBROADCASTF64X2,
+	I_VBROADCASTF64X4,
+	I_VBROADCASTI32X2,
+	I_VBROADCASTI32X4,
+	I_VBROADCASTI32X8,
+	I_VBROADCASTI64X2,
+	I_VBROADCASTI64X4,
+	I_VCMPEQ_OQPD,
+	I_VCMPEQ_OQPS,
+	I_VCMPEQ_OQSD,
+	I_VCMPEQ_OQSS,
+	I_VCOMPRESSPD,
+	I_VCOMPRESSPS,
+	I_VCVTPD2QQ,
+	I_VCVTPD2UDQ,
+	I_VCVTPD2UQQ,
+	I_VCVTPS2QQ,
+	I_VCVTPS2UDQ,
+	I_VCVTPS2UQQ,
+	I_VCVTQQ2PD,
+	I_VCVTQQ2PS,
+	I_VCVTSD2USI,
+	I_VCVTSS2USI,
+	I_VCVTTPD2QQ,
+	I_VCVTTPD2UDQ,
+	I_VCVTTPD2UQQ,
+	I_VCVTTPS2QQ,
+	I_VCVTTPS2UDQ,
+	I_VCVTTPS2UQQ,
+	I_VCVTTSD2USI,
+	I_VCVTTSS2USI,
+	I_VCVTUDQ2PD,
+	I_VCVTUDQ2PS,
+	I_VCVTUQQ2PD,
+	I_VCVTUQQ2PS,
+	I_VCVTUSI2SD,
+	I_VCVTUSI2SS,
+	I_VDBPSADBW,
+	I_VEXP2PD,
+	I_VEXP2PS,
+	I_VEXPANDPD,
+	I_VEXPANDPS,
+	I_VEXTRACTF32X4,
+	I_VEXTRACTF32X8,
+	I_VEXTRACTF64X2,
+	I_VEXTRACTF64X4,
+	I_VEXTRACTI32X4,
+	I_VEXTRACTI32X8,
+	I_VEXTRACTI64X2,
+	I_VEXTRACTI64X4,
+	I_VFIXUPIMMPD,
+	I_VFIXUPIMMPS,
+	I_VFIXUPIMMSD,
+	I_VFIXUPIMMSS,
+	I_VFPCLASSPD,
+	I_VFPCLASSPS,
+	I_VFPCLASSSD,
+	I_VFPCLASSSS,
+	I_VGATHERPF0DPD,
+	I_VGATHERPF0DPS,
+	I_VGATHERPF0QPD,
+	I_VGATHERPF0QPS,
+	I_VGATHERPF1DPD,
+	I_VGATHERPF1DPS,
+	I_VGATHERPF1QPD,
+	I_VGATHERPF1QPS,
+	I_VGETEXPPD,
+	I_VGETEXPPS,
+	I_VGETEXPSD,
+	I_VGETEXPSS,
+	I_VGETMANTPD,
+	I_VGETMANTPS,
+	I_VGETMANTSD,
+	I_VGETMANTSS,
+	I_VINSERTF32X4,
+	I_VINSERTF32X8,
+	I_VINSERTF64X2,
+	I_VINSERTF64X4,
+	I_VINSERTI32X4,
+	I_VINSERTI32X8,
+	I_VINSERTI64X2,
+	I_VINSERTI64X4,
+	I_VMOVDQA32,
+	I_VMOVDQA64,
+	I_VMOVDQU16,
+	I_VMOVDQU32,
+	I_VMOVDQU64,
+	I_VMOVDQU8,
+	I_VPABSQ,
+	I_VPANDD,
+	I_VPANDND,
+	I_VPANDNQ,
+	I_VPANDQ,
+	I_VPBLENDMB,
+	I_VPBLENDMD,
+	I_VPBLENDMQ,
+	I_VPBLENDMW,
+	I_VPBROADCASTMB2Q,
+	I_VPBROADCASTMW2D,
+	I_VPCMPEQUB,
+	I_VPCMPEQUD,
+	I_VPCMPEQUQ,
+	I_VPCMPEQUW,
+	I_VPCMPGEB,
+	I_VPCMPGED,
+	I_VPCMPGEQ,
+	I_VPCMPGEUB,
+	I_VPCMPGEUD,
+	I_VPCMPGEUQ,
+	I_VPCMPGEUW,
+	I_VPCMPGEW,
+	I_VPCMPGTUB,
+	I_VPCMPGTUD,
+	I_VPCMPGTUQ,
+	I_VPCMPGTUW,
+	I_VPCMPLEB,
+	I_VPCMPLED,
+	I_VPCMPLEQ,
+	I_VPCMPLEUB,
+	I_VPCMPLEUD,
+	I_VPCMPLEUQ,
+	I_VPCMPLEUW,
+	I_VPCMPLEW,
+	I_VPCMPLTB,
+	I_VPCMPLTD,
+	I_VPCMPLTQ,
+	I_VPCMPLTUB,
+	I_VPCMPLTUD,
+	I_VPCMPLTUQ,
+	I_VPCMPLTUW,
+	I_VPCMPLTW,
+	I_VPCMPNEQB,
+	I_VPCMPNEQD,
+	I_VPCMPNEQQ,
+	I_VPCMPNEQUB,
+	I_VPCMPNEQUD,
+	I_VPCMPNEQUQ,
+	I_VPCMPNEQUW,
+	I_VPCMPNEQW,
+	I_VPCMPNGTB,
+	I_VPCMPNGTD,
+	I_VPCMPNGTQ,
+	I_VPCMPNGTUB,
+	I_VPCMPNGTUD,
+	I_VPCMPNGTUQ,
+	I_VPCMPNGTUW,
+	I_VPCMPNGTW,
+	I_VPCMPNLEB,
+	I_VPCMPNLED,
+	I_VPCMPNLEQ,
+	I_VPCMPNLEUB,
+	I_VPCMPNLEUD,
+	I_VPCMPNLEUQ,
+	I_VPCMPNLEUW,
+	I_VPCMPNLEW,
+	I_VPCMPNLTB,
+	I_VPCMPNLTD,
+	I_VPCMPNLTQ,
+	I_VPCMPNLTUB,
+	I_VPCMPNLTUD,
+	I_VPCMPNLTUQ,
+	I_VPCMPNLTUW,
+	I_VPCMPNLTW,
+	I_VPCMPB,
+	I_VPCMPD,
+	I_VPCMPQ,
+	I_VPCMPUB,
+	I_VPCMPUD,
+	I_VPCMPUQ,
+	I_VPCMPUW,
+	I_VPCMPW,
+	I_VPCOMPRESSD,
+	I_VPCOMPRESSQ,
+	I_VPCONFLICTD,
+	I_VPCONFLICTQ,
+	I_VPERMB,
+	I_VPERMI2B,
+	I_VPERMI2D,
+	I_VPERMI2PD,
+	I_VPERMI2PS,
+	I_VPERMI2Q,
+	I_VPERMI2W,
+	I_VPERMT2B,
+	I_VPERMT2D,
+	I_VPERMT2PD,
+	I_VPERMT2PS,
+	I_VPERMT2Q,
+	I_VPERMT2W,
+	I_VPERMW,
+	I_VPEXPANDD,
+	I_VPEXPANDQ,
+	I_VPLZCNTD,
+	I_VPLZCNTQ,
+	I_VPMAXSQ,
+	I_VPMAXUQ,
+	I_VPMINSQ,
+	I_VPMINUQ,
+	I_VPMOVB2M,
+	I_VPMOVD2M,
+	I_VPMOVDB,
+	I_VPMOVDW,
+	I_VPMOVM2B,
+	I_VPMOVM2D,
+	I_VPMOVM2Q,
+	I_VPMOVM2W,
+	I_VPMOVQ2M,
+	I_VPMOVQB,
+	I_VPMOVQD,
+	I_VPMOVQW,
+	I_VPMOVSDB,
+	I_VPMOVSDW,
+	I_VPMOVSQB,
+	I_VPMOVSQD,
+	I_VPMOVSQW,
+	I_VPMOVSWB,
+	I_VPMOVUSDB,
+	I_VPMOVUSDW,
+	I_VPMOVUSQB,
+	I_VPMOVUSQD,
+	I_VPMOVUSQW,
+	I_VPMOVUSWB,
+	I_VPMOVW2M,
+	I_VPMOVWB,
+	I_VPMULLQ,
+	I_VPMULTISHIFTQB,
+	I_VPORD,
+	I_VPORQ,
+	I_VPROLD,
+	I_VPROLQ,
+	I_VPROLVD,
+	I_VPROLVQ,
+	I_VPRORD,
+	I_VPRORQ,
+	I_VPRORVD,
+	I_VPRORVQ,
+	I_VPSCATTERDD,
+	I_VPSCATTERDQ,
+	I_VPSCATTERQD,
+	I_VPSCATTERQQ,
+	I_VPSLLVW,
+	I_VPSRAQ,
+	I_VPSRAVQ,
+	I_VPSRAVW,
+	I_VPSRLVW,
+	I_VPTERNLOGD,
+	I_VPTERNLOGQ,
+	I_VPTESTMB,
+	I_VPTESTMD,
+	I_VPTESTMQ,
+	I_VPTESTMW,
+	I_VPTESTNMB,
+	I_VPTESTNMD,
+	I_VPTESTNMQ,
+	I_VPTESTNMW,
+	I_VPXORD,
+	I_VPXORQ,
+	I_VRANGEPD,
+	I_VRANGEPS,
+	I_VRANGESD,
+	I_VRANGESS,
+	I_VRCP14PD,
+	I_VRCP14PS,
+	I_VRCP14SD,
+	I_VRCP14SS,
+	I_VRCP28PD,
+	I_VRCP28PS,
+	I_VRCP28SD,
+	I_VRCP28SS,
+	I_VREDUCEPD,
+	I_VREDUCEPS,
+	I_VREDUCESD,
+	I_VREDUCESS,
+	I_VRNDSCALEPD,
+	I_VRNDSCALEPS,
+	I_VRNDSCALESD,
+	I_VRNDSCALESS,
+	I_VRSQRT14PD,
+	I_VRSQRT14PS,
+	I_VRSQRT14SD,
+	I_VRSQRT14SS,
+	I_VRSQRT28PD,
+	I_VRSQRT28PS,
+	I_VRSQRT28SD,
+	I_VRSQRT28SS,
+	I_VSCALEFPD,
+	I_VSCALEFPS,
+	I_VSCALEFSD,
+	I_VSCALEFSS,
+	I_VSCATTERDPD,
+	I_VSCATTERDPS,
+	I_VSCATTERPF0DPD,
+	I_VSCATTERPF0DPS,
+	I_VSCATTERPF0QPD,
+	I_VSCATTERPF0QPS,
+	I_VSCATTERPF1DPD,
+	I_VSCATTERPF1DPS,
+	I_VSCATTERPF1QPD,
+	I_VSCATTERPF1QPS,
+	I_VSCATTERQPD,
+	I_VSCATTERQPS,
+	I_VSHUFF32X4,
+	I_VSHUFF64X2,
+	I_VSHUFI32X4,
+	I_VSHUFI64X2,
+	I_RDPKRU,
+	I_WRPKRU,
+	I_RDPID,
+	I_CLFLUSHOPT,
+	I_CLWB,
+	I_PCOMMIT,
+	I_CLZERO,
+	I_PTWRITE,
+	I_CLDEMOTE,
+	I_MOVDIRI,
+	I_MOVDIR64B,
+	I_PCONFIG,
+	I_TPAUSE,
+	I_UMONITOR,
+	I_UMWAIT,
+	I_WBNOINVD,
+	I_GF2P8AFFINEINVQB,
+	I_VGF2P8AFFINEINVQB,
+	I_GF2P8AFFINEQB,
+	I_VGF2P8AFFINEQB,
+	I_GF2P8MULB,
+	I_VGF2P8MULB,
+	I_VPCOMPRESSB,
+	I_VPCOMPRESSW,
+	I_VPEXPANDB,
+	I_VPEXPANDW,
+	I_VPSHLDW,
+	I_VPSHLDD,
+	I_VPSHLDQ,
+	I_VPSHLDVW,
+	I_VPSHLDVD,
+	I_VPSHLDVQ,
+	I_VPSHRDW,
+	I_VPSHRDD,
+	I_VPSHRDQ,
+	I_VPSHRDVW,
+	I_VPSHRDVD,
+	I_VPSHRDVQ,
+	I_VPDPBUSD,
+	I_VPDPBUSDS,
+	I_VPDPWSSD,
+	I_VPDPWSSDS,
+	I_VPOPCNTB,
+	I_VPOPCNTW,
+	I_VPOPCNTD,
+	I_VPOPCNTQ,
+	I_VPSHUFBITQMB,
+	I_V4FMADDPS,
+	I_V4FNMADDPS,
+	I_V4FMADDSS,
+	I_V4FNMADDSS,
+	I_V4DPWSSDS,
+	I_V4DPWSSD,
+	I_ENCLS,
+	I_ENCLU,
+	I_ENCLV,
+	I_CLRSSBSY,
+	I_ENDBR32,
+	I_ENDBR64,
+	I_INCSSPD,
+	I_INCSSPQ,
+	I_RDSSPD,
+	I_RDSSPQ,
+	I_RSTORSSP,
+	I_SAVEPREVSSP,
+	I_SETSSBSY,
+	I_WRUSSD,
+	I_WRUSSQ,
+	I_WRSSD,
+	I_WRSSQ,
+	I_ENQCMD,
+	I_ENQCMDS,
+	I_SERIALIZE,
+	I_XRESLDTRK,
+	I_XSUSLDTRK,
+	I_VCVTNE2PS2BF16,
+	I_VDPBF16PS,
+	I_VP2INTERSECTD,
+	I_LDTILECFG,
+	I_STTILECFG,
+	I_TDPBF16PS,
+	I_TDPBSSD,
+	I_TDPBSUD,
+	I_TDPBUSD,
+	I_TDPBUUD,
+	I_TILELOADD,
+	I_TILELOADDT1,
+	I_TILERELEASE,
+	I_TILESTORED,
+	I_TILEZERO,
+	I_VADDPH,
+	I_VADDSH,
+	I_VCMPPH,
+	I_VCMPSH,
+	I_VCOMISH,
+	I_VCVTDQ2PH,
+	I_VCVTPD2PH,
+	I_VCVTPH2DQ,
+	I_VCVTPH2PD,
+	I_VCVTPH2PSX,
+	I_VCVTPH2QQ,
+	I_VCVTPH2UDQ,
+	I_VCVTPH2UQQ,
+	I_VCVTPH2UW,
+	I_VCVTPH2W,
+	I_VCVTQQ2PH,
+	I_VCVTSD2SH,
+	I_VCVTSH2SD,
+	I_VCVTSH2SI,
+	I_VCVTSH2SS,
+	I_VCVTSH2USI,
+	I_VCVTSI2SH,
+	I_VCVTSS2SH,
+	I_VCVTTPH2DQ,
+	I_VCVTTPH2QQ,
+	I_VCVTTPH2UDQ,
+	I_VCVTTPH2UQQ,
+	I_VCVTTPH2UW,
+	I_VCVTTPH2W,
+	I_VCVTTSH2SI,
+	I_VCVTTSH2USI,
+	I_VCVTUDQ2PH,
+	I_VCVTUQQ2PH,
+	I_VCVTUSI2SH,
+	I_VCVTUW2PH,
+	I_VCVTW2PH,
+	I_VDIVPH,
+	I_VDIVSH,
+	I_VFCMADDCPH,
+	I_VFMADDCPH,
+	I_VFCMADDCSH,
+	I_VFMADDCSH,
+	I_VFCMULCPCH,
+	I_VFMULCPCH,
+	I_VFCMULCSH,
+	I_VFMULCSH,
+	I_VFMADDSUB132PH,
+	I_VFMADDSUB213PH,
+	I_VFMADDSUB231PH,
+	I_VFMSUBADD132PH,
+	I_VFMSUBADD213PH,
+	I_VFMSUBADD231PH,
+	I_VPMADD132PH,
+	I_VPMADD213PH,
+	I_VPMADD231PH,
+	I_VFMADD132PH,
+	I_VFMADD213PH,
+	I_VFMADD231PH,
+	I_VPMADD132SH,
+	I_VPMADD213SH,
+	I_VPMADD231SH,
+	I_VPNMADD132SH,
+	I_VPNMADD213SH,
+	I_VPNMADD231SH,
+	I_VPMSUB132PH,
+	I_VPMSUB213PH,
+	I_VPMSUB231PH,
+	I_VFMSUB132PH,
+	I_VFMSUB213PH,
+	I_VFMSUB231PH,
+	I_VPMSUB132SH,
+	I_VPMSUB213SH,
+	I_VPMSUB231SH,
+	I_VPNMSUB132SH,
+	I_VPNMSUB213SH,
+	I_VPNMSUB231SH,
+	I_VFPCLASSPH,
+	I_VFPCLASSSH,
+	I_VGETEXPPH,
+	I_VGETEXPSH,
+	I_VGETMANTPH,
+	I_VGETMANTSH,
+	I_VGETMAXPH,
+	I_VGETMAXSH,
+	I_VGETMINPH,
+	I_VGETMINSH,
+	I_VMOVSH,
+	I_VMOVW,
+	I_VMULPH,
+	I_VMULSH,
+	I_VRCPPH,
+	I_VRCPSH,
+	I_VREDUCEPH,
+	I_VREDUCESH,
+	I_VENDSCALEPH,
+	I_VENDSCALESH,
+	I_VRSQRTPH,
+	I_VRSQRTSH,
+	I_VSCALEFPH,
+	I_VSCALEFSH,
+	I_VSQRTPH,
+	I_VSQRTSH,
+	I_VSUBPH,
+	I_VSUBSH,
+	I_VUCOMISH,
+	I_AADD,
+	I_AAND,
+	I_AXOR,
+	I_CLUI,
+	I_SENDUIPI,
+	I_STUI,
+	I_TESTUI,
+	I_UIRET,
+	I_CMPAXADD,
+	I_CMPAEXADD,
+	I_CMPBXADD,
+	I_CMPBEXADD,
+	I_CMPCXADD,
+	I_CMPEXADD,
+	I_CMPGXADD,
+	I_CMPGEXADD,
+	I_CMPLXADD,
+	I_CMPLEXADD,
+	I_CMPNAXADD,
+	I_CMPNAEXADD,
+	I_CMPNBXADD,
+	I_CMPNBEXADD,
+	I_CMPNCXADD,
+	I_CMPNEXADD,
+	I_CMPNGXADD,
+	I_CMPNGEXADD,
+	I_CMPNLXADD,
+	I_CMPNLEXADD,
+	I_CMPNOXADD,
+	I_CMPNPXADD,
+	I_CMPNSXADD,
+	I_CMPNZXADD,
+	I_CMPOXADD,
+	I_CMPPXADD,
+	I_CMPPEXADD,
+	I_CMPPOXADD,
+	I_CMPSXADD,
+	I_CMPZXADD,
+	I_WRMSRNS,
+	I_RDMSRLIST,
+	I_WRMSRLIST,
+	I_HRESET,
+	I_HINT_NOP0,
+	I_HINT_NOP1,
+	I_HINT_NOP2,
+	I_HINT_NOP3,
+	I_HINT_NOP4,
+	I_HINT_NOP5,
+	I_HINT_NOP6,
+	I_HINT_NOP7,
+	I_HINT_NOP8,
+	I_HINT_NOP9,
+	I_HINT_NOP10,
+	I_HINT_NOP11,
+	I_HINT_NOP12,
+	I_HINT_NOP13,
+	I_HINT_NOP14,
+	I_HINT_NOP15,
+	I_HINT_NOP16,
+	I_HINT_NOP17,
+	I_HINT_NOP18,
+	I_HINT_NOP19,
+	I_HINT_NOP20,
+	I_HINT_NOP21,
+	I_HINT_NOP22,
+	I_HINT_NOP23,
+	I_HINT_NOP24,
+	I_HINT_NOP25,
+	I_HINT_NOP26,
+	I_HINT_NOP27,
+	I_HINT_NOP28,
+	I_HINT_NOP29,
+	I_HINT_NOP30,
+	I_HINT_NOP31,
+	I_HINT_NOP32,
+	I_HINT_NOP33,
+	I_HINT_NOP34,
+	I_HINT_NOP35,
+	I_HINT_NOP36,
+	I_HINT_NOP37,
+	I_HINT_NOP38,
+	I_HINT_NOP39,
+	I_HINT_NOP40,
+	I_HINT_NOP41,
+	I_HINT_NOP42,
+	I_HINT_NOP43,
+	I_HINT_NOP44,
+	I_HINT_NOP45,
+	I_HINT_NOP46,
+	I_HINT_NOP47,
+	I_HINT_NOP48,
+	I_HINT_NOP49,
+	I_HINT_NOP50,
+	I_HINT_NOP51,
+	I_HINT_NOP52,
+	I_HINT_NOP53,
+	I_HINT_NOP54,
+	I_HINT_NOP55,
+	I_HINT_NOP56,
+	I_HINT_NOP57,
+	I_HINT_NOP58,
+	I_HINT_NOP59,
+	I_HINT_NOP60,
+	I_HINT_NOP61,
+	I_HINT_NOP62,
+	I_HINT_NOP63,
+	I_none = -1
+};
+
+#define MAX_INSLEN 17
+#define NASM_VEX_CLASSES 3
+#define NO_DECORATOR	{0,0,0,0,0}
+#endif /* NASM_INSNSI_H */
diff --git a/vere/ext/nasm/x86/insnsn.c b/vere/ext/nasm/x86/insnsn.c
new file mode 100644
index 0000000..88505a5
--- /dev/null
+++ b/vere/ext/nasm/x86/insnsn.c
@@ -0,0 +1,2254 @@
+/* This file is auto-generated from insns.dat by insns.pl - don't edit it */
+
+#include "tables.h"
+
+const char * const nasm_insn_names[] = {
+	"db",
+	"dw",
+	"dd",
+	"dq",
+	"dt",
+	"do",
+	"dy",
+	"dz",
+	"resb",
+	"resw",
+	"resd",
+	"resq",
+	"rest",
+	"reso",
+	"resy",
+	"resz",
+	"incbin",
+	"aaa",
+	"aad",
+	"aam",
+	"aas",
+	"adc",
+	"add",
+	"and",
+	"arpl",
+	"bb0_reset",
+	"bb1_reset",
+	"bound",
+	"bsf",
+	"bsr",
+	"bswap",
+	"bt",
+	"btc",
+	"btr",
+	"bts",
+	"call",
+	"cbw",
+	"cdq",
+	"cdqe",
+	"clc",
+	"cld",
+	"cli",
+	"clts",
+	"cmc",
+	"cmp",
+	"cmpsb",
+	"cmpsd",
+	"cmpsq",
+	"cmpsw",
+	"cmpxchg",
+	"cmpxchg486",
+	"cmpxchg8b",
+	"cmpxchg16b",
+	"cpuid",
+	"cpu_read",
+	"cpu_write",
+	"cqo",
+	"cwd",
+	"cwde",
+	"daa",
+	"das",
+	"dec",
+	"div",
+	"dmint",
+	"emms",
+	"enter",
+	"equ",
+	"f2xm1",
+	"fabs",
+	"fadd",
+	"faddp",
+	"fbld",
+	"fbstp",
+	"fchs",
+	"fclex",
+	"fcmovb",
+	"fcmovbe",
+	"fcmove",
+	"fcmovnb",
+	"fcmovnbe",
+	"fcmovne",
+	"fcmovnu",
+	"fcmovu",
+	"fcom",
+	"fcomi",
+	"fcomip",
+	"fcomp",
+	"fcompp",
+	"fcos",
+	"fdecstp",
+	"fdisi",
+	"fdiv",
+	"fdivp",
+	"fdivr",
+	"fdivrp",
+	"femms",
+	"feni",
+	"ffree",
+	"ffreep",
+	"fiadd",
+	"ficom",
+	"ficomp",
+	"fidiv",
+	"fidivr",
+	"fild",
+	"fimul",
+	"fincstp",
+	"finit",
+	"fist",
+	"fistp",
+	"fisttp",
+	"fisub",
+	"fisubr",
+	"fld",
+	"fld1",
+	"fldcw",
+	"fldenv",
+	"fldl2e",
+	"fldl2t",
+	"fldlg2",
+	"fldln2",
+	"fldpi",
+	"fldz",
+	"fmul",
+	"fmulp",
+	"fnclex",
+	"fndisi",
+	"fneni",
+	"fninit",
+	"fnop",
+	"fnsave",
+	"fnstcw",
+	"fnstenv",
+	"fnstsw",
+	"fpatan",
+	"fprem",
+	"fprem1",
+	"fptan",
+	"frndint",
+	"frstor",
+	"fsave",
+	"fscale",
+	"fsetpm",
+	"fsin",
+	"fsincos",
+	"fsqrt",
+	"fst",
+	"fstcw",
+	"fstenv",
+	"fstp",
+	"fstsw",
+	"fsub",
+	"fsubp",
+	"fsubr",
+	"fsubrp",
+	"ftst",
+	"fucom",
+	"fucomi",
+	"fucomip",
+	"fucomp",
+	"fucompp",
+	"fxam",
+	"fxch",
+	"fxtract",
+	"fyl2x",
+	"fyl2xp1",
+	"hlt",
+	"ibts",
+	"icebp",
+	"idiv",
+	"imul",
+	"in",
+	"inc",
+	"insb",
+	"insd",
+	"insw",
+	"int",
+	"int01",
+	"int1",
+	"int03",
+	"int3",
+	"into",
+	"invd",
+	"invpcid",
+	"invlpg",
+	"invlpga",
+	"iret",
+	"iretd",
+	"iretq",
+	"iretw",
+	"jcxz",
+	"jecxz",
+	"jrcxz",
+	"jmp",
+	"jmpe",
+	"lahf",
+	"lar",
+	"lds",
+	"lea",
+	"leave",
+	"les",
+	"lfence",
+	"lfs",
+	"lgdt",
+	"lgs",
+	"lidt",
+	"lldt",
+	"lmsw",
+	"loadall",
+	"loadall286",
+	"lodsb",
+	"lodsd",
+	"lodsq",
+	"lodsw",
+	"loop",
+	"loope",
+	"loopne",
+	"loopnz",
+	"loopz",
+	"lsl",
+	"lss",
+	"ltr",
+	"mfence",
+	"monitor",
+	"monitorx",
+	"mov",
+	"movd",
+	"movq",
+	"movsb",
+	"movsd",
+	"movsq",
+	"movsw",
+	"movsx",
+	"movsxd",
+	"movzx",
+	"mul",
+	"mwait",
+	"mwaitx",
+	"neg",
+	"nop",
+	"not",
+	"or",
+	"out",
+	"outsb",
+	"outsd",
+	"outsw",
+	"packssdw",
+	"packsswb",
+	"packuswb",
+	"paddb",
+	"paddd",
+	"paddsb",
+	"paddsiw",
+	"paddsw",
+	"paddusb",
+	"paddusw",
+	"paddw",
+	"pand",
+	"pandn",
+	"pause",
+	"paveb",
+	"pavgusb",
+	"pcmpeqb",
+	"pcmpeqd",
+	"pcmpeqw",
+	"pcmpgtb",
+	"pcmpgtd",
+	"pcmpgtw",
+	"pdistib",
+	"pf2id",
+	"pfacc",
+	"pfadd",
+	"pfcmpeq",
+	"pfcmpge",
+	"pfcmpgt",
+	"pfmax",
+	"pfmin",
+	"pfmul",
+	"pfrcp",
+	"pfrcpit1",
+	"pfrcpit2",
+	"pfrsqit1",
+	"pfrsqrt",
+	"pfsub",
+	"pfsubr",
+	"pi2fd",
+	"pmachriw",
+	"pmaddwd",
+	"pmagw",
+	"pmulhriw",
+	"pmulhrwa",
+	"pmulhrwc",
+	"pmulhw",
+	"pmullw",
+	"pmvgezb",
+	"pmvlzb",
+	"pmvnzb",
+	"pmvzb",
+	"pop",
+	"popa",
+	"popad",
+	"popaw",
+	"popf",
+	"popfd",
+	"popfq",
+	"popfw",
+	"por",
+	"prefetch",
+	"prefetchw",
+	"pslld",
+	"psllq",
+	"psllw",
+	"psrad",
+	"psraw",
+	"psrld",
+	"psrlq",
+	"psrlw",
+	"psubb",
+	"psubd",
+	"psubsb",
+	"psubsiw",
+	"psubsw",
+	"psubusb",
+	"psubusw",
+	"psubw",
+	"punpckhbw",
+	"punpckhdq",
+	"punpckhwd",
+	"punpcklbw",
+	"punpckldq",
+	"punpcklwd",
+	"push",
+	"pusha",
+	"pushad",
+	"pushaw",
+	"pushf",
+	"pushfd",
+	"pushfq",
+	"pushfw",
+	"pxor",
+	"rcl",
+	"rcr",
+	"rdshr",
+	"rdmsr",
+	"rdpmc",
+	"rdtsc",
+	"rdtscp",
+	"ret",
+	"retf",
+	"retn",
+	"retw",
+	"retfw",
+	"retnw",
+	"retd",
+	"retfd",
+	"retnd",
+	"retq",
+	"retfq",
+	"retnq",
+	"rol",
+	"ror",
+	"rdm",
+	"rsdc",
+	"rsldt",
+	"rsm",
+	"rsts",
+	"sahf",
+	"sal",
+	"salc",
+	"sar",
+	"sbb",
+	"scasb",
+	"scasd",
+	"scasq",
+	"scasw",
+	"sfence",
+	"sgdt",
+	"shl",
+	"shld",
+	"shr",
+	"shrd",
+	"sidt",
+	"sldt",
+	"skinit",
+	"smi",
+	"smint",
+	"smintold",
+	"smsw",
+	"stc",
+	"std",
+	"sti",
+	"stosb",
+	"stosd",
+	"stosq",
+	"stosw",
+	"str",
+	"sub",
+	"svdc",
+	"svldt",
+	"svts",
+	"swapgs",
+	"syscall",
+	"sysenter",
+	"sysexit",
+	"sysret",
+	"test",
+	"ud0",
+	"ud1",
+	"ud2b",
+	"ud2",
+	"ud2a",
+	"umov",
+	"verr",
+	"verw",
+	"fwait",
+	"wbinvd",
+	"wrshr",
+	"wrmsr",
+	"xadd",
+	"xbts",
+	"xchg",
+	"xlatb",
+	"xlat",
+	"xor",
+	"cmova",
+	"cmovae",
+	"cmovb",
+	"cmovbe",
+	"cmovc",
+	"cmove",
+	"cmovg",
+	"cmovge",
+	"cmovl",
+	"cmovle",
+	"cmovna",
+	"cmovnae",
+	"cmovnb",
+	"cmovnbe",
+	"cmovnc",
+	"cmovne",
+	"cmovng",
+	"cmovnge",
+	"cmovnl",
+	"cmovnle",
+	"cmovno",
+	"cmovnp",
+	"cmovns",
+	"cmovnz",
+	"cmovo",
+	"cmovp",
+	"cmovpe",
+	"cmovpo",
+	"cmovs",
+	"cmovz",
+	"ja",
+	"jae",
+	"jb",
+	"jbe",
+	"jc",
+	"je",
+	"jg",
+	"jge",
+	"jl",
+	"jle",
+	"jna",
+	"jnae",
+	"jnb",
+	"jnbe",
+	"jnc",
+	"jne",
+	"jng",
+	"jnge",
+	"jnl",
+	"jnle",
+	"jno",
+	"jnp",
+	"jns",
+	"jnz",
+	"jo",
+	"jp",
+	"jpe",
+	"jpo",
+	"js",
+	"jz",
+	"seta",
+	"setae",
+	"setb",
+	"setbe",
+	"setc",
+	"sete",
+	"setg",
+	"setge",
+	"setl",
+	"setle",
+	"setna",
+	"setnae",
+	"setnb",
+	"setnbe",
+	"setnc",
+	"setne",
+	"setng",
+	"setnge",
+	"setnl",
+	"setnle",
+	"setno",
+	"setnp",
+	"setns",
+	"setnz",
+	"seto",
+	"setp",
+	"setpe",
+	"setpo",
+	"sets",
+	"setz",
+	"addps",
+	"addss",
+	"andnps",
+	"andps",
+	"cmpeqps",
+	"cmpeqss",
+	"cmpleps",
+	"cmpless",
+	"cmpltps",
+	"cmpltss",
+	"cmpneqps",
+	"cmpneqss",
+	"cmpnleps",
+	"cmpnless",
+	"cmpnltps",
+	"cmpnltss",
+	"cmpordps",
+	"cmpordss",
+	"cmpunordps",
+	"cmpunordss",
+	"cmpps",
+	"cmpss",
+	"comiss",
+	"cvtpi2ps",
+	"cvtps2pi",
+	"cvtsi2ss",
+	"cvtss2si",
+	"cvttps2pi",
+	"cvttss2si",
+	"divps",
+	"divss",
+	"ldmxcsr",
+	"maxps",
+	"maxss",
+	"minps",
+	"minss",
+	"movaps",
+	"movhps",
+	"movlhps",
+	"movlps",
+	"movhlps",
+	"movmskps",
+	"movntps",
+	"movss",
+	"movups",
+	"mulps",
+	"mulss",
+	"orps",
+	"rcpps",
+	"rcpss",
+	"rsqrtps",
+	"rsqrtss",
+	"shufps",
+	"sqrtps",
+	"sqrtss",
+	"stmxcsr",
+	"subps",
+	"subss",
+	"ucomiss",
+	"unpckhps",
+	"unpcklps",
+	"xorps",
+	"fxrstor",
+	"fxrstor64",
+	"fxsave",
+	"fxsave64",
+	"xgetbv",
+	"xsetbv",
+	"xsave",
+	"xsave64",
+	"xsavec",
+	"xsavec64",
+	"xsaveopt",
+	"xsaveopt64",
+	"xsaves",
+	"xsaves64",
+	"xrstor",
+	"xrstor64",
+	"xrstors",
+	"xrstors64",
+	"prefetchnta",
+	"prefetcht0",
+	"prefetcht1",
+	"prefetcht2",
+	"prefetchit0",
+	"prefetchit1",
+	"maskmovq",
+	"movntq",
+	"pavgb",
+	"pavgw",
+	"pextrw",
+	"pinsrw",
+	"pmaxsw",
+	"pmaxub",
+	"pminsw",
+	"pminub",
+	"pmovmskb",
+	"pmulhuw",
+	"psadbw",
+	"pshufw",
+	"pf2iw",
+	"pfnacc",
+	"pfpnacc",
+	"pi2fw",
+	"pswapd",
+	"maskmovdqu",
+	"clflush",
+	"movntdq",
+	"movnti",
+	"movntpd",
+	"movdqa",
+	"movdqu",
+	"movdq2q",
+	"movq2dq",
+	"paddq",
+	"pmuludq",
+	"pshufd",
+	"pshufhw",
+	"pshuflw",
+	"pslldq",
+	"psrldq",
+	"psubq",
+	"punpckhqdq",
+	"punpcklqdq",
+	"addpd",
+	"addsd",
+	"andnpd",
+	"andpd",
+	"cmpeqpd",
+	"cmpeqsd",
+	"cmplepd",
+	"cmplesd",
+	"cmpltpd",
+	"cmpltsd",
+	"cmpneqpd",
+	"cmpneqsd",
+	"cmpnlepd",
+	"cmpnlesd",
+	"cmpnltpd",
+	"cmpnltsd",
+	"cmpordpd",
+	"cmpordsd",
+	"cmpunordpd",
+	"cmpunordsd",
+	"cmppd",
+	"comisd",
+	"cvtdq2pd",
+	"cvtdq2ps",
+	"cvtpd2dq",
+	"cvtpd2pi",
+	"cvtpd2ps",
+	"cvtpi2pd",
+	"cvtps2dq",
+	"cvtps2pd",
+	"cvtsd2si",
+	"cvtsd2ss",
+	"cvtsi2sd",
+	"cvtss2sd",
+	"cvttpd2pi",
+	"cvttpd2dq",
+	"cvttps2dq",
+	"cvttsd2si",
+	"divpd",
+	"divsd",
+	"maxpd",
+	"maxsd",
+	"minpd",
+	"minsd",
+	"movapd",
+	"movhpd",
+	"movlpd",
+	"movmskpd",
+	"movupd",
+	"mulpd",
+	"mulsd",
+	"orpd",
+	"shufpd",
+	"sqrtpd",
+	"sqrtsd",
+	"subpd",
+	"subsd",
+	"ucomisd",
+	"unpckhpd",
+	"unpcklpd",
+	"xorpd",
+	"addsubpd",
+	"addsubps",
+	"haddpd",
+	"haddps",
+	"hsubpd",
+	"hsubps",
+	"lddqu",
+	"movddup",
+	"movshdup",
+	"movsldup",
+	"clgi",
+	"stgi",
+	"vmcall",
+	"vmclear",
+	"vmfunc",
+	"vmlaunch",
+	"vmload",
+	"vmmcall",
+	"vmptrld",
+	"vmptrst",
+	"vmread",
+	"vmresume",
+	"vmrun",
+	"vmsave",
+	"vmwrite",
+	"vmxoff",
+	"vmxon",
+	"invept",
+	"invvpid",
+	"pvalidate",
+	"rmpadjust",
+	"vmgexit",
+	"pabsb",
+	"pabsw",
+	"pabsd",
+	"palignr",
+	"phaddw",
+	"phaddd",
+	"phaddsw",
+	"phsubw",
+	"phsubd",
+	"phsubsw",
+	"pmaddubsw",
+	"pmulhrsw",
+	"pshufb",
+	"psignb",
+	"psignw",
+	"psignd",
+	"extrq",
+	"insertq",
+	"movntsd",
+	"movntss",
+	"lzcnt",
+	"blendpd",
+	"blendps",
+	"blendvpd",
+	"blendvps",
+	"dppd",
+	"dpps",
+	"extractps",
+	"insertps",
+	"movntdqa",
+	"mpsadbw",
+	"packusdw",
+	"pblendvb",
+	"pblendw",
+	"pcmpeqq",
+	"pextrb",
+	"pextrd",
+	"pextrq",
+	"phminposuw",
+	"pinsrb",
+	"pinsrd",
+	"pinsrq",
+	"pmaxsb",
+	"pmaxsd",
+	"pmaxud",
+	"pmaxuw",
+	"pminsb",
+	"pminsd",
+	"pminud",
+	"pminuw",
+	"pmovsxbw",
+	"pmovsxbd",
+	"pmovsxbq",
+	"pmovsxwd",
+	"pmovsxwq",
+	"pmovsxdq",
+	"pmovzxbw",
+	"pmovzxbd",
+	"pmovzxbq",
+	"pmovzxwd",
+	"pmovzxwq",
+	"pmovzxdq",
+	"pmuldq",
+	"pmulld",
+	"ptest",
+	"roundpd",
+	"roundps",
+	"roundsd",
+	"roundss",
+	"crc32",
+	"pcmpestri",
+	"pcmpestrm",
+	"pcmpistri",
+	"pcmpistrm",
+	"pcmpgtq",
+	"popcnt",
+	"getsec",
+	"pfrcpv",
+	"pfrsqrtv",
+	"movbe",
+	"aesenc",
+	"aesenclast",
+	"aesdec",
+	"aesdeclast",
+	"aesimc",
+	"aeskeygenassist",
+	"vaesenc",
+	"vaesenclast",
+	"vaesdec",
+	"vaesdeclast",
+	"vaesimc",
+	"vaeskeygenassist",
+	"vaddpd",
+	"vaddps",
+	"vaddsd",
+	"vaddss",
+	"vaddsubpd",
+	"vaddsubps",
+	"vandpd",
+	"vandps",
+	"vandnpd",
+	"vandnps",
+	"vblendpd",
+	"vblendps",
+	"vblendvpd",
+	"vblendvps",
+	"vbroadcastss",
+	"vbroadcastsd",
+	"vbroadcastf128",
+	"vcmpeq_ospd",
+	"vcmpeqpd",
+	"vcmplt_ospd",
+	"vcmpltpd",
+	"vcmple_ospd",
+	"vcmplepd",
+	"vcmpunord_qpd",
+	"vcmpunordpd",
+	"vcmpneq_uqpd",
+	"vcmpneqpd",
+	"vcmpnlt_uspd",
+	"vcmpnltpd",
+	"vcmpnle_uspd",
+	"vcmpnlepd",
+	"vcmpord_qpd",
+	"vcmpordpd",
+	"vcmpeq_uqpd",
+	"vcmpnge_uspd",
+	"vcmpngepd",
+	"vcmpngt_uspd",
+	"vcmpngtpd",
+	"vcmpfalse_oqpd",
+	"vcmpfalsepd",
+	"vcmpneq_oqpd",
+	"vcmpge_ospd",
+	"vcmpgepd",
+	"vcmpgt_ospd",
+	"vcmpgtpd",
+	"vcmptrue_uqpd",
+	"vcmptruepd",
+	"vcmplt_oqpd",
+	"vcmple_oqpd",
+	"vcmpunord_spd",
+	"vcmpneq_uspd",
+	"vcmpnlt_uqpd",
+	"vcmpnle_uqpd",
+	"vcmpord_spd",
+	"vcmpeq_uspd",
+	"vcmpnge_uqpd",
+	"vcmpngt_uqpd",
+	"vcmpfalse_ospd",
+	"vcmpneq_ospd",
+	"vcmpge_oqpd",
+	"vcmpgt_oqpd",
+	"vcmptrue_uspd",
+	"vcmppd",
+	"vcmpeq_osps",
+	"vcmpeqps",
+	"vcmplt_osps",
+	"vcmpltps",
+	"vcmple_osps",
+	"vcmpleps",
+	"vcmpunord_qps",
+	"vcmpunordps",
+	"vcmpneq_uqps",
+	"vcmpneqps",
+	"vcmpnlt_usps",
+	"vcmpnltps",
+	"vcmpnle_usps",
+	"vcmpnleps",
+	"vcmpord_qps",
+	"vcmpordps",
+	"vcmpeq_uqps",
+	"vcmpnge_usps",
+	"vcmpngeps",
+	"vcmpngt_usps",
+	"vcmpngtps",
+	"vcmpfalse_oqps",
+	"vcmpfalseps",
+	"vcmpneq_oqps",
+	"vcmpge_osps",
+	"vcmpgeps",
+	"vcmpgt_osps",
+	"vcmpgtps",
+	"vcmptrue_uqps",
+	"vcmptrueps",
+	"vcmplt_oqps",
+	"vcmple_oqps",
+	"vcmpunord_sps",
+	"vcmpneq_usps",
+	"vcmpnlt_uqps",
+	"vcmpnle_uqps",
+	"vcmpord_sps",
+	"vcmpeq_usps",
+	"vcmpnge_uqps",
+	"vcmpngt_uqps",
+	"vcmpfalse_osps",
+	"vcmpneq_osps",
+	"vcmpge_oqps",
+	"vcmpgt_oqps",
+	"vcmptrue_usps",
+	"vcmpps",
+	"vcmpeq_ossd",
+	"vcmpeqsd",
+	"vcmplt_ossd",
+	"vcmpltsd",
+	"vcmple_ossd",
+	"vcmplesd",
+	"vcmpunord_qsd",
+	"vcmpunordsd",
+	"vcmpneq_uqsd",
+	"vcmpneqsd",
+	"vcmpnlt_ussd",
+	"vcmpnltsd",
+	"vcmpnle_ussd",
+	"vcmpnlesd",
+	"vcmpord_qsd",
+	"vcmpordsd",
+	"vcmpeq_uqsd",
+	"vcmpnge_ussd",
+	"vcmpngesd",
+	"vcmpngt_ussd",
+	"vcmpngtsd",
+	"vcmpfalse_oqsd",
+	"vcmpfalsesd",
+	"vcmpneq_oqsd",
+	"vcmpge_ossd",
+	"vcmpgesd",
+	"vcmpgt_ossd",
+	"vcmpgtsd",
+	"vcmptrue_uqsd",
+	"vcmptruesd",
+	"vcmplt_oqsd",
+	"vcmple_oqsd",
+	"vcmpunord_ssd",
+	"vcmpneq_ussd",
+	"vcmpnlt_uqsd",
+	"vcmpnle_uqsd",
+	"vcmpord_ssd",
+	"vcmpeq_ussd",
+	"vcmpnge_uqsd",
+	"vcmpngt_uqsd",
+	"vcmpfalse_ossd",
+	"vcmpneq_ossd",
+	"vcmpge_oqsd",
+	"vcmpgt_oqsd",
+	"vcmptrue_ussd",
+	"vcmpsd",
+	"vcmpeq_osss",
+	"vcmpeqss",
+	"vcmplt_osss",
+	"vcmpltss",
+	"vcmple_osss",
+	"vcmpless",
+	"vcmpunord_qss",
+	"vcmpunordss",
+	"vcmpneq_uqss",
+	"vcmpneqss",
+	"vcmpnlt_usss",
+	"vcmpnltss",
+	"vcmpnle_usss",
+	"vcmpnless",
+	"vcmpord_qss",
+	"vcmpordss",
+	"vcmpeq_uqss",
+	"vcmpnge_usss",
+	"vcmpngess",
+	"vcmpngt_usss",
+	"vcmpngtss",
+	"vcmpfalse_oqss",
+	"vcmpfalsess",
+	"vcmpneq_oqss",
+	"vcmpge_osss",
+	"vcmpgess",
+	"vcmpgt_osss",
+	"vcmpgtss",
+	"vcmptrue_uqss",
+	"vcmptruess",
+	"vcmplt_oqss",
+	"vcmple_oqss",
+	"vcmpunord_sss",
+	"vcmpneq_usss",
+	"vcmpnlt_uqss",
+	"vcmpnle_uqss",
+	"vcmpord_sss",
+	"vcmpeq_usss",
+	"vcmpnge_uqss",
+	"vcmpngt_uqss",
+	"vcmpfalse_osss",
+	"vcmpneq_osss",
+	"vcmpge_oqss",
+	"vcmpgt_oqss",
+	"vcmptrue_usss",
+	"vcmpss",
+	"vcomisd",
+	"vcomiss",
+	"vcvtdq2pd",
+	"vcvtdq2ps",
+	"vcvtpd2dq",
+	"vcvtpd2ps",
+	"vcvtps2dq",
+	"vcvtps2pd",
+	"vcvtsd2si",
+	"vcvtsd2ss",
+	"vcvtsi2sd",
+	"vcvtsi2ss",
+	"vcvtss2sd",
+	"vcvtss2si",
+	"vcvttpd2dq",
+	"vcvttps2dq",
+	"vcvttsd2si",
+	"vcvttss2si",
+	"vdivpd",
+	"vdivps",
+	"vdivsd",
+	"vdivss",
+	"vdppd",
+	"vdpps",
+	"vextractf128",
+	"vextractps",
+	"vhaddpd",
+	"vhaddps",
+	"vhsubpd",
+	"vhsubps",
+	"vinsertf128",
+	"vinsertps",
+	"vlddqu",
+	"vldqqu",
+	"vldmxcsr",
+	"vmaskmovdqu",
+	"vmaskmovps",
+	"vmaskmovpd",
+	"vmaxpd",
+	"vmaxps",
+	"vmaxsd",
+	"vmaxss",
+	"vminpd",
+	"vminps",
+	"vminsd",
+	"vminss",
+	"vmovapd",
+	"vmovaps",
+	"vmovd",
+	"vmovq",
+	"vmovddup",
+	"vmovdqa",
+	"vmovqqa",
+	"vmovdqu",
+	"vmovqqu",
+	"vmovhlps",
+	"vmovhpd",
+	"vmovhps",
+	"vmovlhps",
+	"vmovlpd",
+	"vmovlps",
+	"vmovmskpd",
+	"vmovmskps",
+	"vmovntdq",
+	"vmovntqq",
+	"vmovntdqa",
+	"vmovntpd",
+	"vmovntps",
+	"vmovsd",
+	"vmovshdup",
+	"vmovsldup",
+	"vmovss",
+	"vmovupd",
+	"vmovups",
+	"vmpsadbw",
+	"vmulpd",
+	"vmulps",
+	"vmulsd",
+	"vmulss",
+	"vorpd",
+	"vorps",
+	"vpabsb",
+	"vpabsw",
+	"vpabsd",
+	"vpacksswb",
+	"vpackssdw",
+	"vpackuswb",
+	"vpackusdw",
+	"vpaddb",
+	"vpaddw",
+	"vpaddd",
+	"vpaddq",
+	"vpaddsb",
+	"vpaddsw",
+	"vpaddusb",
+	"vpaddusw",
+	"vpalignr",
+	"vpand",
+	"vpandn",
+	"vpavgb",
+	"vpavgw",
+	"vpblendvb",
+	"vpblendw",
+	"vpcmpestri",
+	"vpcmpestrm",
+	"vpcmpistri",
+	"vpcmpistrm",
+	"vpcmpeqb",
+	"vpcmpeqw",
+	"vpcmpeqd",
+	"vpcmpeqq",
+	"vpcmpgtb",
+	"vpcmpgtw",
+	"vpcmpgtd",
+	"vpcmpgtq",
+	"vpermilpd",
+	"vpermilps",
+	"vperm2f128",
+	"vpextrb",
+	"vpextrw",
+	"vpextrd",
+	"vpextrq",
+	"vphaddw",
+	"vphaddd",
+	"vphaddsw",
+	"vphminposuw",
+	"vphsubw",
+	"vphsubd",
+	"vphsubsw",
+	"vpinsrb",
+	"vpinsrw",
+	"vpinsrd",
+	"vpinsrq",
+	"vpmaddwd",
+	"vpmaddubsw",
+	"vpmaxsb",
+	"vpmaxsw",
+	"vpmaxsd",
+	"vpmaxub",
+	"vpmaxuw",
+	"vpmaxud",
+	"vpminsb",
+	"vpminsw",
+	"vpminsd",
+	"vpminub",
+	"vpminuw",
+	"vpminud",
+	"vpmovmskb",
+	"vpmovsxbw",
+	"vpmovsxbd",
+	"vpmovsxbq",
+	"vpmovsxwd",
+	"vpmovsxwq",
+	"vpmovsxdq",
+	"vpmovzxbw",
+	"vpmovzxbd",
+	"vpmovzxbq",
+	"vpmovzxwd",
+	"vpmovzxwq",
+	"vpmovzxdq",
+	"vpmulhuw",
+	"vpmulhrsw",
+	"vpmulhw",
+	"vpmullw",
+	"vpmulld",
+	"vpmuludq",
+	"vpmuldq",
+	"vpor",
+	"vpsadbw",
+	"vpshufb",
+	"vpshufd",
+	"vpshufhw",
+	"vpshuflw",
+	"vpsignb",
+	"vpsignw",
+	"vpsignd",
+	"vpslldq",
+	"vpsrldq",
+	"vpsllw",
+	"vpslld",
+	"vpsllq",
+	"vpsraw",
+	"vpsrad",
+	"vpsrlw",
+	"vpsrld",
+	"vpsrlq",
+	"vptest",
+	"vpsubb",
+	"vpsubw",
+	"vpsubd",
+	"vpsubq",
+	"vpsubsb",
+	"vpsubsw",
+	"vpsubusb",
+	"vpsubusw",
+	"vpunpckhbw",
+	"vpunpckhwd",
+	"vpunpckhdq",
+	"vpunpckhqdq",
+	"vpunpcklbw",
+	"vpunpcklwd",
+	"vpunpckldq",
+	"vpunpcklqdq",
+	"vpxor",
+	"vrcpps",
+	"vrcpss",
+	"vrsqrtps",
+	"vrsqrtss",
+	"vroundpd",
+	"vroundps",
+	"vroundsd",
+	"vroundss",
+	"vshufpd",
+	"vshufps",
+	"vsqrtpd",
+	"vsqrtps",
+	"vsqrtsd",
+	"vsqrtss",
+	"vstmxcsr",
+	"vsubpd",
+	"vsubps",
+	"vsubsd",
+	"vsubss",
+	"vtestps",
+	"vtestpd",
+	"vucomisd",
+	"vucomiss",
+	"vunpckhpd",
+	"vunpckhps",
+	"vunpcklpd",
+	"vunpcklps",
+	"vxorpd",
+	"vxorps",
+	"vzeroall",
+	"vzeroupper",
+	"pclmullqlqdq",
+	"pclmulhqlqdq",
+	"pclmullqhqdq",
+	"pclmulhqhqdq",
+	"pclmulqdq",
+	"vpclmullqlqdq",
+	"vpclmulhqlqdq",
+	"vpclmullqhqdq",
+	"vpclmulhqhqdq",
+	"vpclmulqdq",
+	"vfmadd132ps",
+	"vfmadd132pd",
+	"vfmadd312ps",
+	"vfmadd312pd",
+	"vfmadd213ps",
+	"vfmadd213pd",
+	"vfmadd123ps",
+	"vfmadd123pd",
+	"vfmadd231ps",
+	"vfmadd231pd",
+	"vfmadd321ps",
+	"vfmadd321pd",
+	"vfmaddsub132ps",
+	"vfmaddsub132pd",
+	"vfmaddsub312ps",
+	"vfmaddsub312pd",
+	"vfmaddsub213ps",
+	"vfmaddsub213pd",
+	"vfmaddsub123ps",
+	"vfmaddsub123pd",
+	"vfmaddsub231ps",
+	"vfmaddsub231pd",
+	"vfmaddsub321ps",
+	"vfmaddsub321pd",
+	"vfmsub132ps",
+	"vfmsub132pd",
+	"vfmsub312ps",
+	"vfmsub312pd",
+	"vfmsub213ps",
+	"vfmsub213pd",
+	"vfmsub123ps",
+	"vfmsub123pd",
+	"vfmsub231ps",
+	"vfmsub231pd",
+	"vfmsub321ps",
+	"vfmsub321pd",
+	"vfmsubadd132ps",
+	"vfmsubadd132pd",
+	"vfmsubadd312ps",
+	"vfmsubadd312pd",
+	"vfmsubadd213ps",
+	"vfmsubadd213pd",
+	"vfmsubadd123ps",
+	"vfmsubadd123pd",
+	"vfmsubadd231ps",
+	"vfmsubadd231pd",
+	"vfmsubadd321ps",
+	"vfmsubadd321pd",
+	"vfnmadd132ps",
+	"vfnmadd132pd",
+	"vfnmadd312ps",
+	"vfnmadd312pd",
+	"vfnmadd213ps",
+	"vfnmadd213pd",
+	"vfnmadd123ps",
+	"vfnmadd123pd",
+	"vfnmadd231ps",
+	"vfnmadd231pd",
+	"vfnmadd321ps",
+	"vfnmadd321pd",
+	"vfnmsub132ps",
+	"vfnmsub132pd",
+	"vfnmsub312ps",
+	"vfnmsub312pd",
+	"vfnmsub213ps",
+	"vfnmsub213pd",
+	"vfnmsub123ps",
+	"vfnmsub123pd",
+	"vfnmsub231ps",
+	"vfnmsub231pd",
+	"vfnmsub321ps",
+	"vfnmsub321pd",
+	"vfmadd132ss",
+	"vfmadd132sd",
+	"vfmadd312ss",
+	"vfmadd312sd",
+	"vfmadd213ss",
+	"vfmadd213sd",
+	"vfmadd123ss",
+	"vfmadd123sd",
+	"vfmadd231ss",
+	"vfmadd231sd",
+	"vfmadd321ss",
+	"vfmadd321sd",
+	"vfmsub132ss",
+	"vfmsub132sd",
+	"vfmsub312ss",
+	"vfmsub312sd",
+	"vfmsub213ss",
+	"vfmsub213sd",
+	"vfmsub123ss",
+	"vfmsub123sd",
+	"vfmsub231ss",
+	"vfmsub231sd",
+	"vfmsub321ss",
+	"vfmsub321sd",
+	"vfnmadd132ss",
+	"vfnmadd132sd",
+	"vfnmadd312ss",
+	"vfnmadd312sd",
+	"vfnmadd213ss",
+	"vfnmadd213sd",
+	"vfnmadd123ss",
+	"vfnmadd123sd",
+	"vfnmadd231ss",
+	"vfnmadd231sd",
+	"vfnmadd321ss",
+	"vfnmadd321sd",
+	"vfnmsub132ss",
+	"vfnmsub132sd",
+	"vfnmsub312ss",
+	"vfnmsub312sd",
+	"vfnmsub213ss",
+	"vfnmsub213sd",
+	"vfnmsub123ss",
+	"vfnmsub123sd",
+	"vfnmsub231ss",
+	"vfnmsub231sd",
+	"vfnmsub321ss",
+	"vfnmsub321sd",
+	"rdfsbase",
+	"rdgsbase",
+	"rdrand",
+	"wrfsbase",
+	"wrgsbase",
+	"vcvtph2ps",
+	"vcvtps2ph",
+	"adcx",
+	"adox",
+	"rdseed",
+	"clac",
+	"stac",
+	"xstore",
+	"xcryptecb",
+	"xcryptcbc",
+	"xcryptctr",
+	"xcryptcfb",
+	"xcryptofb",
+	"montmul",
+	"xsha1",
+	"xsha256",
+	"llwpcb",
+	"slwpcb",
+	"lwpval",
+	"lwpins",
+	"vfmaddpd",
+	"vfmaddps",
+	"vfmaddsd",
+	"vfmaddss",
+	"vfmaddsubpd",
+	"vfmaddsubps",
+	"vfmsubaddpd",
+	"vfmsubaddps",
+	"vfmsubpd",
+	"vfmsubps",
+	"vfmsubsd",
+	"vfmsubss",
+	"vfnmaddpd",
+	"vfnmaddps",
+	"vfnmaddsd",
+	"vfnmaddss",
+	"vfnmsubpd",
+	"vfnmsubps",
+	"vfnmsubsd",
+	"vfnmsubss",
+	"vfrczpd",
+	"vfrczps",
+	"vfrczsd",
+	"vfrczss",
+	"vpcmov",
+	"vpcomb",
+	"vpcomd",
+	"vpcomq",
+	"vpcomub",
+	"vpcomud",
+	"vpcomuq",
+	"vpcomuw",
+	"vpcomw",
+	"vphaddbd",
+	"vphaddbq",
+	"vphaddbw",
+	"vphadddq",
+	"vphaddubd",
+	"vphaddubq",
+	"vphaddubw",
+	"vphaddudq",
+	"vphadduwd",
+	"vphadduwq",
+	"vphaddwd",
+	"vphaddwq",
+	"vphsubbw",
+	"vphsubdq",
+	"vphsubwd",
+	"vpmacsdd",
+	"vpmacsdqh",
+	"vpmacsdql",
+	"vpmacssdd",
+	"vpmacssdqh",
+	"vpmacssdql",
+	"vpmacsswd",
+	"vpmacssww",
+	"vpmacswd",
+	"vpmacsww",
+	"vpmadcsswd",
+	"vpmadcswd",
+	"vpperm",
+	"vprotb",
+	"vprotd",
+	"vprotq",
+	"vprotw",
+	"vpshab",
+	"vpshad",
+	"vpshaq",
+	"vpshaw",
+	"vpshlb",
+	"vpshld",
+	"vpshlq",
+	"vpshlw",
+	"vbroadcasti128",
+	"vpblendd",
+	"vpbroadcastb",
+	"vpbroadcastw",
+	"vpbroadcastd",
+	"vpbroadcastq",
+	"vpermd",
+	"vpermpd",
+	"vpermps",
+	"vpermq",
+	"vperm2i128",
+	"vextracti128",
+	"vinserti128",
+	"vpmaskmovd",
+	"vpmaskmovq",
+	"vpsllvd",
+	"vpsllvq",
+	"vpsravd",
+	"vpsrlvd",
+	"vpsrlvq",
+	"vgatherdpd",
+	"vgatherqpd",
+	"vgatherdps",
+	"vgatherqps",
+	"vpgatherdd",
+	"vpgatherqd",
+	"vpgatherdq",
+	"vpgatherqq",
+	"xabort",
+	"xbegin",
+	"xend",
+	"xtest",
+	"andn",
+	"bextr",
+	"blci",
+	"blcic",
+	"blsi",
+	"blsic",
+	"blcfill",
+	"blsfill",
+	"blcmsk",
+	"blsmsk",
+	"blsr",
+	"blcs",
+	"bzhi",
+	"mulx",
+	"pdep",
+	"pext",
+	"rorx",
+	"sarx",
+	"shlx",
+	"shrx",
+	"tzcnt",
+	"tzmsk",
+	"t1mskc",
+	"prefetchwt1",
+	"bndmk",
+	"bndcl",
+	"bndcu",
+	"bndcn",
+	"bndmov",
+	"bndldx",
+	"bndstx",
+	"sha1msg1",
+	"sha1msg2",
+	"sha1nexte",
+	"sha1rnds4",
+	"sha256msg1",
+	"sha256msg2",
+	"sha256rnds2",
+	"vbcstnebf16ps",
+	"vbcstnesh2ps",
+	"vcvtneebf162ps",
+	"vcvtneeph2ps",
+	"vcvtneobf162ps",
+	"vcvtneoph2ps",
+	"vcvtneps2bf16",
+	"vpdpbssd",
+	"vpdpbssds",
+	"vpdpbsud",
+	"vpdpbsuds",
+	"vpdpbuud",
+	"vpdpbuuds",
+	"vpmadd52huq",
+	"vpmadd52luq",
+	"kaddb",
+	"kaddd",
+	"kaddq",
+	"kaddw",
+	"kandb",
+	"kandd",
+	"kandnb",
+	"kandnd",
+	"kandnq",
+	"kandnw",
+	"kandq",
+	"kandw",
+	"kmovb",
+	"kmovd",
+	"kmovq",
+	"kmovw",
+	"knotb",
+	"knotd",
+	"knotq",
+	"knotw",
+	"korb",
+	"kord",
+	"korq",
+	"korw",
+	"kortestb",
+	"kortestd",
+	"kortestq",
+	"kortestw",
+	"kshiftlb",
+	"kshiftld",
+	"kshiftlq",
+	"kshiftlw",
+	"kshiftrb",
+	"kshiftrd",
+	"kshiftrq",
+	"kshiftrw",
+	"ktestb",
+	"ktestd",
+	"ktestq",
+	"ktestw",
+	"kunpckbw",
+	"kunpckdq",
+	"kunpckwd",
+	"kxnorb",
+	"kxnord",
+	"kxnorq",
+	"kxnorw",
+	"kxorb",
+	"kxord",
+	"kxorq",
+	"kxorw",
+	"kadd",
+	"kand",
+	"kandn",
+	"kmov",
+	"knot",
+	"kor",
+	"kortest",
+	"kshiftl",
+	"kshiftr",
+	"ktest",
+	"kunpck",
+	"kxnor",
+	"kxor",
+	"valignd",
+	"valignq",
+	"vblendmpd",
+	"vblendmps",
+	"vbroadcastf32x2",
+	"vbroadcastf32x4",
+	"vbroadcastf32x8",
+	"vbroadcastf64x2",
+	"vbroadcastf64x4",
+	"vbroadcasti32x2",
+	"vbroadcasti32x4",
+	"vbroadcasti32x8",
+	"vbroadcasti64x2",
+	"vbroadcasti64x4",
+	"vcmpeq_oqpd",
+	"vcmpeq_oqps",
+	"vcmpeq_oqsd",
+	"vcmpeq_oqss",
+	"vcompresspd",
+	"vcompressps",
+	"vcvtpd2qq",
+	"vcvtpd2udq",
+	"vcvtpd2uqq",
+	"vcvtps2qq",
+	"vcvtps2udq",
+	"vcvtps2uqq",
+	"vcvtqq2pd",
+	"vcvtqq2ps",
+	"vcvtsd2usi",
+	"vcvtss2usi",
+	"vcvttpd2qq",
+	"vcvttpd2udq",
+	"vcvttpd2uqq",
+	"vcvttps2qq",
+	"vcvttps2udq",
+	"vcvttps2uqq",
+	"vcvttsd2usi",
+	"vcvttss2usi",
+	"vcvtudq2pd",
+	"vcvtudq2ps",
+	"vcvtuqq2pd",
+	"vcvtuqq2ps",
+	"vcvtusi2sd",
+	"vcvtusi2ss",
+	"vdbpsadbw",
+	"vexp2pd",
+	"vexp2ps",
+	"vexpandpd",
+	"vexpandps",
+	"vextractf32x4",
+	"vextractf32x8",
+	"vextractf64x2",
+	"vextractf64x4",
+	"vextracti32x4",
+	"vextracti32x8",
+	"vextracti64x2",
+	"vextracti64x4",
+	"vfixupimmpd",
+	"vfixupimmps",
+	"vfixupimmsd",
+	"vfixupimmss",
+	"vfpclasspd",
+	"vfpclassps",
+	"vfpclasssd",
+	"vfpclassss",
+	"vgatherpf0dpd",
+	"vgatherpf0dps",
+	"vgatherpf0qpd",
+	"vgatherpf0qps",
+	"vgatherpf1dpd",
+	"vgatherpf1dps",
+	"vgatherpf1qpd",
+	"vgatherpf1qps",
+	"vgetexppd",
+	"vgetexpps",
+	"vgetexpsd",
+	"vgetexpss",
+	"vgetmantpd",
+	"vgetmantps",
+	"vgetmantsd",
+	"vgetmantss",
+	"vinsertf32x4",
+	"vinsertf32x8",
+	"vinsertf64x2",
+	"vinsertf64x4",
+	"vinserti32x4",
+	"vinserti32x8",
+	"vinserti64x2",
+	"vinserti64x4",
+	"vmovdqa32",
+	"vmovdqa64",
+	"vmovdqu16",
+	"vmovdqu32",
+	"vmovdqu64",
+	"vmovdqu8",
+	"vpabsq",
+	"vpandd",
+	"vpandnd",
+	"vpandnq",
+	"vpandq",
+	"vpblendmb",
+	"vpblendmd",
+	"vpblendmq",
+	"vpblendmw",
+	"vpbroadcastmb2q",
+	"vpbroadcastmw2d",
+	"vpcmpequb",
+	"vpcmpequd",
+	"vpcmpequq",
+	"vpcmpequw",
+	"vpcmpgeb",
+	"vpcmpged",
+	"vpcmpgeq",
+	"vpcmpgeub",
+	"vpcmpgeud",
+	"vpcmpgeuq",
+	"vpcmpgeuw",
+	"vpcmpgew",
+	"vpcmpgtub",
+	"vpcmpgtud",
+	"vpcmpgtuq",
+	"vpcmpgtuw",
+	"vpcmpleb",
+	"vpcmpled",
+	"vpcmpleq",
+	"vpcmpleub",
+	"vpcmpleud",
+	"vpcmpleuq",
+	"vpcmpleuw",
+	"vpcmplew",
+	"vpcmpltb",
+	"vpcmpltd",
+	"vpcmpltq",
+	"vpcmpltub",
+	"vpcmpltud",
+	"vpcmpltuq",
+	"vpcmpltuw",
+	"vpcmpltw",
+	"vpcmpneqb",
+	"vpcmpneqd",
+	"vpcmpneqq",
+	"vpcmpnequb",
+	"vpcmpnequd",
+	"vpcmpnequq",
+	"vpcmpnequw",
+	"vpcmpneqw",
+	"vpcmpngtb",
+	"vpcmpngtd",
+	"vpcmpngtq",
+	"vpcmpngtub",
+	"vpcmpngtud",
+	"vpcmpngtuq",
+	"vpcmpngtuw",
+	"vpcmpngtw",
+	"vpcmpnleb",
+	"vpcmpnled",
+	"vpcmpnleq",
+	"vpcmpnleub",
+	"vpcmpnleud",
+	"vpcmpnleuq",
+	"vpcmpnleuw",
+	"vpcmpnlew",
+	"vpcmpnltb",
+	"vpcmpnltd",
+	"vpcmpnltq",
+	"vpcmpnltub",
+	"vpcmpnltud",
+	"vpcmpnltuq",
+	"vpcmpnltuw",
+	"vpcmpnltw",
+	"vpcmpb",
+	"vpcmpd",
+	"vpcmpq",
+	"vpcmpub",
+	"vpcmpud",
+	"vpcmpuq",
+	"vpcmpuw",
+	"vpcmpw",
+	"vpcompressd",
+	"vpcompressq",
+	"vpconflictd",
+	"vpconflictq",
+	"vpermb",
+	"vpermi2b",
+	"vpermi2d",
+	"vpermi2pd",
+	"vpermi2ps",
+	"vpermi2q",
+	"vpermi2w",
+	"vpermt2b",
+	"vpermt2d",
+	"vpermt2pd",
+	"vpermt2ps",
+	"vpermt2q",
+	"vpermt2w",
+	"vpermw",
+	"vpexpandd",
+	"vpexpandq",
+	"vplzcntd",
+	"vplzcntq",
+	"vpmaxsq",
+	"vpmaxuq",
+	"vpminsq",
+	"vpminuq",
+	"vpmovb2m",
+	"vpmovd2m",
+	"vpmovdb",
+	"vpmovdw",
+	"vpmovm2b",
+	"vpmovm2d",
+	"vpmovm2q",
+	"vpmovm2w",
+	"vpmovq2m",
+	"vpmovqb",
+	"vpmovqd",
+	"vpmovqw",
+	"vpmovsdb",
+	"vpmovsdw",
+	"vpmovsqb",
+	"vpmovsqd",
+	"vpmovsqw",
+	"vpmovswb",
+	"vpmovusdb",
+	"vpmovusdw",
+	"vpmovusqb",
+	"vpmovusqd",
+	"vpmovusqw",
+	"vpmovuswb",
+	"vpmovw2m",
+	"vpmovwb",
+	"vpmullq",
+	"vpmultishiftqb",
+	"vpord",
+	"vporq",
+	"vprold",
+	"vprolq",
+	"vprolvd",
+	"vprolvq",
+	"vprord",
+	"vprorq",
+	"vprorvd",
+	"vprorvq",
+	"vpscatterdd",
+	"vpscatterdq",
+	"vpscatterqd",
+	"vpscatterqq",
+	"vpsllvw",
+	"vpsraq",
+	"vpsravq",
+	"vpsravw",
+	"vpsrlvw",
+	"vpternlogd",
+	"vpternlogq",
+	"vptestmb",
+	"vptestmd",
+	"vptestmq",
+	"vptestmw",
+	"vptestnmb",
+	"vptestnmd",
+	"vptestnmq",
+	"vptestnmw",
+	"vpxord",
+	"vpxorq",
+	"vrangepd",
+	"vrangeps",
+	"vrangesd",
+	"vrangess",
+	"vrcp14pd",
+	"vrcp14ps",
+	"vrcp14sd",
+	"vrcp14ss",
+	"vrcp28pd",
+	"vrcp28ps",
+	"vrcp28sd",
+	"vrcp28ss",
+	"vreducepd",
+	"vreduceps",
+	"vreducesd",
+	"vreducess",
+	"vrndscalepd",
+	"vrndscaleps",
+	"vrndscalesd",
+	"vrndscaless",
+	"vrsqrt14pd",
+	"vrsqrt14ps",
+	"vrsqrt14sd",
+	"vrsqrt14ss",
+	"vrsqrt28pd",
+	"vrsqrt28ps",
+	"vrsqrt28sd",
+	"vrsqrt28ss",
+	"vscalefpd",
+	"vscalefps",
+	"vscalefsd",
+	"vscalefss",
+	"vscatterdpd",
+	"vscatterdps",
+	"vscatterpf0dpd",
+	"vscatterpf0dps",
+	"vscatterpf0qpd",
+	"vscatterpf0qps",
+	"vscatterpf1dpd",
+	"vscatterpf1dps",
+	"vscatterpf1qpd",
+	"vscatterpf1qps",
+	"vscatterqpd",
+	"vscatterqps",
+	"vshuff32x4",
+	"vshuff64x2",
+	"vshufi32x4",
+	"vshufi64x2",
+	"rdpkru",
+	"wrpkru",
+	"rdpid",
+	"clflushopt",
+	"clwb",
+	"pcommit",
+	"clzero",
+	"ptwrite",
+	"cldemote",
+	"movdiri",
+	"movdir64b",
+	"pconfig",
+	"tpause",
+	"umonitor",
+	"umwait",
+	"wbnoinvd",
+	"gf2p8affineinvqb",
+	"vgf2p8affineinvqb",
+	"gf2p8affineqb",
+	"vgf2p8affineqb",
+	"gf2p8mulb",
+	"vgf2p8mulb",
+	"vpcompressb",
+	"vpcompressw",
+	"vpexpandb",
+	"vpexpandw",
+	"vpshldw",
+	"vpshldd",
+	"vpshldq",
+	"vpshldvw",
+	"vpshldvd",
+	"vpshldvq",
+	"vpshrdw",
+	"vpshrdd",
+	"vpshrdq",
+	"vpshrdvw",
+	"vpshrdvd",
+	"vpshrdvq",
+	"vpdpbusd",
+	"vpdpbusds",
+	"vpdpwssd",
+	"vpdpwssds",
+	"vpopcntb",
+	"vpopcntw",
+	"vpopcntd",
+	"vpopcntq",
+	"vpshufbitqmb",
+	"v4fmaddps",
+	"v4fnmaddps",
+	"v4fmaddss",
+	"v4fnmaddss",
+	"v4dpwssds",
+	"v4dpwssd",
+	"encls",
+	"enclu",
+	"enclv",
+	"clrssbsy",
+	"endbr32",
+	"endbr64",
+	"incsspd",
+	"incsspq",
+	"rdsspd",
+	"rdsspq",
+	"rstorssp",
+	"saveprevssp",
+	"setssbsy",
+	"wrussd",
+	"wrussq",
+	"wrssd",
+	"wrssq",
+	"enqcmd",
+	"enqcmds",
+	"serialize",
+	"xresldtrk",
+	"xsusldtrk",
+	"vcvtne2ps2bf16",
+	"vdpbf16ps",
+	"vp2intersectd",
+	"ldtilecfg",
+	"sttilecfg",
+	"tdpbf16ps",
+	"tdpbssd",
+	"tdpbsud",
+	"tdpbusd",
+	"tdpbuud",
+	"tileloadd",
+	"tileloaddt1",
+	"tilerelease",
+	"tilestored",
+	"tilezero",
+	"vaddph",
+	"vaddsh",
+	"vcmpph",
+	"vcmpsh",
+	"vcomish",
+	"vcvtdq2ph",
+	"vcvtpd2ph",
+	"vcvtph2dq",
+	"vcvtph2pd",
+	"vcvtph2psx",
+	"vcvtph2qq",
+	"vcvtph2udq",
+	"vcvtph2uqq",
+	"vcvtph2uw",
+	"vcvtph2w",
+	"vcvtqq2ph",
+	"vcvtsd2sh",
+	"vcvtsh2sd",
+	"vcvtsh2si",
+	"vcvtsh2ss",
+	"vcvtsh2usi",
+	"vcvtsi2sh",
+	"vcvtss2sh",
+	"vcvttph2dq",
+	"vcvttph2qq",
+	"vcvttph2udq",
+	"vcvttph2uqq",
+	"vcvttph2uw",
+	"vcvttph2w",
+	"vcvttsh2si",
+	"vcvttsh2usi",
+	"vcvtudq2ph",
+	"vcvtuqq2ph",
+	"vcvtusi2sh",
+	"vcvtuw2ph",
+	"vcvtw2ph",
+	"vdivph",
+	"vdivsh",
+	"vfcmaddcph",
+	"vfmaddcph",
+	"vfcmaddcsh",
+	"vfmaddcsh",
+	"vfcmulcpch",
+	"vfmulcpch",
+	"vfcmulcsh",
+	"vfmulcsh",
+	"vfmaddsub132ph",
+	"vfmaddsub213ph",
+	"vfmaddsub231ph",
+	"vfmsubadd132ph",
+	"vfmsubadd213ph",
+	"vfmsubadd231ph",
+	"vpmadd132ph",
+	"vpmadd213ph",
+	"vpmadd231ph",
+	"vfmadd132ph",
+	"vfmadd213ph",
+	"vfmadd231ph",
+	"vpmadd132sh",
+	"vpmadd213sh",
+	"vpmadd231sh",
+	"vpnmadd132sh",
+	"vpnmadd213sh",
+	"vpnmadd231sh",
+	"vpmsub132ph",
+	"vpmsub213ph",
+	"vpmsub231ph",
+	"vfmsub132ph",
+	"vfmsub213ph",
+	"vfmsub231ph",
+	"vpmsub132sh",
+	"vpmsub213sh",
+	"vpmsub231sh",
+	"vpnmsub132sh",
+	"vpnmsub213sh",
+	"vpnmsub231sh",
+	"vfpclassph",
+	"vfpclasssh",
+	"vgetexpph",
+	"vgetexpsh",
+	"vgetmantph",
+	"vgetmantsh",
+	"vgetmaxph",
+	"vgetmaxsh",
+	"vgetminph",
+	"vgetminsh",
+	"vmovsh",
+	"vmovw",
+	"vmulph",
+	"vmulsh",
+	"vrcpph",
+	"vrcpsh",
+	"vreduceph",
+	"vreducesh",
+	"vendscaleph",
+	"vendscalesh",
+	"vrsqrtph",
+	"vrsqrtsh",
+	"vscalefph",
+	"vscalefsh",
+	"vsqrtph",
+	"vsqrtsh",
+	"vsubph",
+	"vsubsh",
+	"vucomish",
+	"aadd",
+	"aand",
+	"axor",
+	"clui",
+	"senduipi",
+	"stui",
+	"testui",
+	"uiret",
+	"cmpaxadd",
+	"cmpaexadd",
+	"cmpbxadd",
+	"cmpbexadd",
+	"cmpcxadd",
+	"cmpexadd",
+	"cmpgxadd",
+	"cmpgexadd",
+	"cmplxadd",
+	"cmplexadd",
+	"cmpnaxadd",
+	"cmpnaexadd",
+	"cmpnbxadd",
+	"cmpnbexadd",
+	"cmpncxadd",
+	"cmpnexadd",
+	"cmpngxadd",
+	"cmpngexadd",
+	"cmpnlxadd",
+	"cmpnlexadd",
+	"cmpnoxadd",
+	"cmpnpxadd",
+	"cmpnsxadd",
+	"cmpnzxadd",
+	"cmpoxadd",
+	"cmppxadd",
+	"cmppexadd",
+	"cmppoxadd",
+	"cmpsxadd",
+	"cmpzxadd",
+	"wrmsrns",
+	"rdmsrlist",
+	"wrmsrlist",
+	"hreset",
+	"hint_nop0",
+	"hint_nop1",
+	"hint_nop2",
+	"hint_nop3",
+	"hint_nop4",
+	"hint_nop5",
+	"hint_nop6",
+	"hint_nop7",
+	"hint_nop8",
+	"hint_nop9",
+	"hint_nop10",
+	"hint_nop11",
+	"hint_nop12",
+	"hint_nop13",
+	"hint_nop14",
+	"hint_nop15",
+	"hint_nop16",
+	"hint_nop17",
+	"hint_nop18",
+	"hint_nop19",
+	"hint_nop20",
+	"hint_nop21",
+	"hint_nop22",
+	"hint_nop23",
+	"hint_nop24",
+	"hint_nop25",
+	"hint_nop26",
+	"hint_nop27",
+	"hint_nop28",
+	"hint_nop29",
+	"hint_nop30",
+	"hint_nop31",
+	"hint_nop32",
+	"hint_nop33",
+	"hint_nop34",
+	"hint_nop35",
+	"hint_nop36",
+	"hint_nop37",
+	"hint_nop38",
+	"hint_nop39",
+	"hint_nop40",
+	"hint_nop41",
+	"hint_nop42",
+	"hint_nop43",
+	"hint_nop44",
+	"hint_nop45",
+	"hint_nop46",
+	"hint_nop47",
+	"hint_nop48",
+	"hint_nop49",
+	"hint_nop50",
+	"hint_nop51",
+	"hint_nop52",
+	"hint_nop53",
+	"hint_nop54",
+	"hint_nop55",
+	"hint_nop56",
+	"hint_nop57",
+	"hint_nop58",
+	"hint_nop59",
+	"hint_nop60",
+	"hint_nop61",
+	"hint_nop62",
+	"hint_nop63",
+};
diff --git a/vere/ext/nasm/x86/regdis.c b/vere/ext/nasm/x86/regdis.c
new file mode 100644
index 0000000..99179d6
--- /dev/null
+++ b/vere/ext/nasm/x86/regdis.c
@@ -0,0 +1,21 @@
+/* automatically generated from ./x86/regs.dat - do not edit */
+
+#include "regdis.h"
+
+const enum reg_enum nasm_rd_bndreg  [ 4] = {R_BND0,R_BND1,R_BND2,R_BND3};
+const enum reg_enum nasm_rd_creg    [16] = {R_CR0,R_CR1,R_CR2,R_CR3,R_CR4,R_CR5,R_CR6,R_CR7,R_CR8,R_CR9,R_CR10,R_CR11,R_CR12,R_CR13,R_CR14,R_CR15};
+const enum reg_enum nasm_rd_dreg    [16] = {R_DR0,R_DR1,R_DR2,R_DR3,R_DR4,R_DR5,R_DR6,R_DR7,R_DR8,R_DR9,R_DR10,R_DR11,R_DR12,R_DR13,R_DR14,R_DR15};
+const enum reg_enum nasm_rd_fpureg  [ 8] = {R_ST0,R_ST1,R_ST2,R_ST3,R_ST4,R_ST5,R_ST6,R_ST7};
+const enum reg_enum nasm_rd_mmxreg  [ 8] = {R_MM0,R_MM1,R_MM2,R_MM3,R_MM4,R_MM5,R_MM6,R_MM7};
+const enum reg_enum nasm_rd_opmaskreg[ 8] = {R_K0,R_K1,R_K2,R_K3,R_K4,R_K5,R_K6,R_K7};
+const enum reg_enum nasm_rd_reg16   [16] = {R_AX,R_CX,R_DX,R_BX,R_SP,R_BP,R_SI,R_DI,R_R8W,R_R9W,R_R10W,R_R11W,R_R12W,R_R13W,R_R14W,R_R15W};
+const enum reg_enum nasm_rd_reg32   [16] = {R_EAX,R_ECX,R_EDX,R_EBX,R_ESP,R_EBP,R_ESI,R_EDI,R_R8D,R_R9D,R_R10D,R_R11D,R_R12D,R_R13D,R_R14D,R_R15D};
+const enum reg_enum nasm_rd_reg64   [16] = {R_RAX,R_RCX,R_RDX,R_RBX,R_RSP,R_RBP,R_RSI,R_RDI,R_R8,R_R9,R_R10,R_R11,R_R12,R_R13,R_R14,R_R15};
+const enum reg_enum nasm_rd_reg8    [ 8] = {R_AL,R_CL,R_DL,R_BL,R_AH,R_CH,R_DH,R_BH};
+const enum reg_enum nasm_rd_reg8_rex[16] = {R_AL,R_CL,R_DL,R_BL,R_SPL,R_BPL,R_SIL,R_DIL,R_R8B,R_R9B,R_R10B,R_R11B,R_R12B,R_R13B,R_R14B,R_R15B};
+const enum reg_enum nasm_rd_sreg    [ 8] = {R_ES,R_CS,R_SS,R_DS,R_FS,R_GS,R_SEGR6,R_SEGR7};
+const enum reg_enum nasm_rd_tmmreg  [ 8] = {R_TMM0,R_TMM1,R_TMM2,R_TMM3,R_TMM4,R_TMM5,R_TMM6,R_TMM7};
+const enum reg_enum nasm_rd_treg    [ 8] = {R_TR0,R_TR1,R_TR2,R_TR3,R_TR4,R_TR5,R_TR6,R_TR7};
+const enum reg_enum nasm_rd_xmmreg  [32] = {R_XMM0,R_XMM1,R_XMM2,R_XMM3,R_XMM4,R_XMM5,R_XMM6,R_XMM7,R_XMM8,R_XMM9,R_XMM10,R_XMM11,R_XMM12,R_XMM13,R_XMM14,R_XMM15,R_XMM16,R_XMM17,R_XMM18,R_XMM19,R_XMM20,R_XMM21,R_XMM22,R_XMM23,R_XMM24,R_XMM25,R_XMM26,R_XMM27,R_XMM28,R_XMM29,R_XMM30,R_XMM31};
+const enum reg_enum nasm_rd_ymmreg  [32] = {R_YMM0,R_YMM1,R_YMM2,R_YMM3,R_YMM4,R_YMM5,R_YMM6,R_YMM7,R_YMM8,R_YMM9,R_YMM10,R_YMM11,R_YMM12,R_YMM13,R_YMM14,R_YMM15,R_YMM16,R_YMM17,R_YMM18,R_YMM19,R_YMM20,R_YMM21,R_YMM22,R_YMM23,R_YMM24,R_YMM25,R_YMM26,R_YMM27,R_YMM28,R_YMM29,R_YMM30,R_YMM31};
+const enum reg_enum nasm_rd_zmmreg  [32] = {R_ZMM0,R_ZMM1,R_ZMM2,R_ZMM3,R_ZMM4,R_ZMM5,R_ZMM6,R_ZMM7,R_ZMM8,R_ZMM9,R_ZMM10,R_ZMM11,R_ZMM12,R_ZMM13,R_ZMM14,R_ZMM15,R_ZMM16,R_ZMM17,R_ZMM18,R_ZMM19,R_ZMM20,R_ZMM21,R_ZMM22,R_ZMM23,R_ZMM24,R_ZMM25,R_ZMM26,R_ZMM27,R_ZMM28,R_ZMM29,R_ZMM30,R_ZMM31};
diff --git a/vere/ext/nasm/x86/regflags.c b/vere/ext/nasm/x86/regflags.c
new file mode 100644
index 0000000..ef42544
--- /dev/null
+++ b/vere/ext/nasm/x86/regflags.c
@@ -0,0 +1,256 @@
+/* automatically generated from ./x86/regs.dat - do not edit */
+
+#include "tables.h"
+#include "nasm.h"
+
+const opflags_t nasm_reg_flags[] = {
+    0,
+    REG_HIGH,       /* ah    */
+    REG_AL,         /* al    */
+    REG_AX,         /* ax    */
+    REG_HIGH,       /* bh    */
+    REG8NA,         /* bl    */
+    BNDREG,         /* bnd0  */
+    BNDREG,         /* bnd1  */
+    BNDREG,         /* bnd2  */
+    BNDREG,         /* bnd3  */
+    REG16NA,        /* bp    */
+    REG8NA,         /* bpl   */
+    REG16NA,        /* bx    */
+    REG_HIGH,       /* ch    */
+    REG_CL,         /* cl    */
+    REG_CREG,       /* cr0   */
+    REG_CREG,       /* cr1   */
+    REG_CREG,       /* cr10  */
+    REG_CREG,       /* cr11  */
+    REG_CREG,       /* cr12  */
+    REG_CREG,       /* cr13  */
+    REG_CREG,       /* cr14  */
+    REG_CREG,       /* cr15  */
+    REG_CREG,       /* cr2   */
+    REG_CREG,       /* cr3   */
+    REG_CREG,       /* cr4   */
+    REG_CREG,       /* cr5   */
+    REG_CREG,       /* cr6   */
+    REG_CREG,       /* cr7   */
+    REG_CREG,       /* cr8   */
+    REG_CREG,       /* cr9   */
+    REG_CS,         /* cs    */
+    REG_CX,         /* cx    */
+    REG_HIGH,       /* dh    */
+    REG16NA,        /* di    */
+    REG8NA,         /* dil   */
+    REG_DL,         /* dl    */
+    REG_DREG,       /* dr0   */
+    REG_DREG,       /* dr1   */
+    REG_DREG,       /* dr10  */
+    REG_DREG,       /* dr11  */
+    REG_DREG,       /* dr12  */
+    REG_DREG,       /* dr13  */
+    REG_DREG,       /* dr14  */
+    REG_DREG,       /* dr15  */
+    REG_DREG,       /* dr2   */
+    REG_DREG,       /* dr3   */
+    REG_DREG,       /* dr4   */
+    REG_DREG,       /* dr5   */
+    REG_DREG,       /* dr6   */
+    REG_DREG,       /* dr7   */
+    REG_DREG,       /* dr8   */
+    REG_DREG,       /* dr9   */
+    REG_DS,         /* ds    */
+    REG_DX,         /* dx    */
+    REG_EAX,        /* eax   */
+    REG32NA,        /* ebp   */
+    REG32NA,        /* ebx   */
+    REG_ECX,        /* ecx   */
+    REG32NA,        /* edi   */
+    REG_EDX,        /* edx   */
+    REG_ES,         /* es    */
+    REG32NA,        /* esi   */
+    REG32NA,        /* esp   */
+    REG_FS,         /* fs    */
+    REG_GS,         /* gs    */
+    OPMASK0,        /* k0    */
+    OPMASKREG,      /* k1    */
+    OPMASKREG,      /* k2    */
+    OPMASKREG,      /* k3    */
+    OPMASKREG,      /* k4    */
+    OPMASKREG,      /* k5    */
+    OPMASKREG,      /* k6    */
+    OPMASKREG,      /* k7    */
+    MMXREG,         /* mm0   */
+    MMXREG,         /* mm1   */
+    MMXREG,         /* mm2   */
+    MMXREG,         /* mm3   */
+    MMXREG,         /* mm4   */
+    MMXREG,         /* mm5   */
+    MMXREG,         /* mm6   */
+    MMXREG,         /* mm7   */
+    REG64NA,        /* r10   */
+    REG8NA,         /* r10b  */
+    REG32NA,        /* r10d  */
+    REG16NA,        /* r10w  */
+    REG64NA,        /* r11   */
+    REG8NA,         /* r11b  */
+    REG32NA,        /* r11d  */
+    REG16NA,        /* r11w  */
+    REG64NA,        /* r12   */
+    REG8NA,         /* r12b  */
+    REG32NA,        /* r12d  */
+    REG16NA,        /* r12w  */
+    REG64NA,        /* r13   */
+    REG8NA,         /* r13b  */
+    REG32NA,        /* r13d  */
+    REG16NA,        /* r13w  */
+    REG64NA,        /* r14   */
+    REG8NA,         /* r14b  */
+    REG32NA,        /* r14d  */
+    REG16NA,        /* r14w  */
+    REG64NA,        /* r15   */
+    REG8NA,         /* r15b  */
+    REG32NA,        /* r15d  */
+    REG16NA,        /* r15w  */
+    REG64NA,        /* r8    */
+    REG8NA,         /* r8b   */
+    REG32NA,        /* r8d   */
+    REG16NA,        /* r8w   */
+    REG64NA,        /* r9    */
+    REG8NA,         /* r9b   */
+    REG32NA,        /* r9d   */
+    REG16NA,        /* r9w   */
+    REG_RAX,        /* rax   */
+    REG64NA,        /* rbp   */
+    REG64NA,        /* rbx   */
+    REG_RCX,        /* rcx   */
+    REG64NA,        /* rdi   */
+    REG_RDX,        /* rdx   */
+    REG64NA,        /* rsi   */
+    REG64NA,        /* rsp   */
+    REG_SEG67,      /* segr6 */
+    REG_SEG67,      /* segr7 */
+    REG16NA,        /* si    */
+    REG8NA,         /* sil   */
+    REG16NA,        /* sp    */
+    REG8NA,         /* spl   */
+    REG_SS,         /* ss    */
+    FPU0,           /* st0   */
+    FPUREG,         /* st1   */
+    FPUREG,         /* st2   */
+    FPUREG,         /* st3   */
+    FPUREG,         /* st4   */
+    FPUREG,         /* st5   */
+    FPUREG,         /* st6   */
+    FPUREG,         /* st7   */
+    TMMREG,         /* tmm0  */
+    TMMREG,         /* tmm1  */
+    TMMREG,         /* tmm2  */
+    TMMREG,         /* tmm3  */
+    TMMREG,         /* tmm4  */
+    TMMREG,         /* tmm5  */
+    TMMREG,         /* tmm6  */
+    TMMREG,         /* tmm7  */
+    REG_TREG,       /* tr0   */
+    REG_TREG,       /* tr1   */
+    REG_TREG,       /* tr2   */
+    REG_TREG,       /* tr3   */
+    REG_TREG,       /* tr4   */
+    REG_TREG,       /* tr5   */
+    REG_TREG,       /* tr6   */
+    REG_TREG,       /* tr7   */
+    XMM0,           /* xmm0  */
+    XMM_L16,        /* xmm1  */
+    XMM_L16,        /* xmm10 */
+    XMM_L16,        /* xmm11 */
+    XMM_L16,        /* xmm12 */
+    XMM_L16,        /* xmm13 */
+    XMM_L16,        /* xmm14 */
+    XMM_L16,        /* xmm15 */
+    XMMREG,         /* xmm16 */
+    XMMREG,         /* xmm17 */
+    XMMREG,         /* xmm18 */
+    XMMREG,         /* xmm19 */
+    XMM_L16,        /* xmm2  */
+    XMMREG,         /* xmm20 */
+    XMMREG,         /* xmm21 */
+    XMMREG,         /* xmm22 */
+    XMMREG,         /* xmm23 */
+    XMMREG,         /* xmm24 */
+    XMMREG,         /* xmm25 */
+    XMMREG,         /* xmm26 */
+    XMMREG,         /* xmm27 */
+    XMMREG,         /* xmm28 */
+    XMMREG,         /* xmm29 */
+    XMM_L16,        /* xmm3  */
+    XMMREG,         /* xmm30 */
+    XMMREG,         /* xmm31 */
+    XMM_L16,        /* xmm4  */
+    XMM_L16,        /* xmm5  */
+    XMM_L16,        /* xmm6  */
+    XMM_L16,        /* xmm7  */
+    XMM_L16,        /* xmm8  */
+    XMM_L16,        /* xmm9  */
+    YMM0,           /* ymm0  */
+    YMM_L16,        /* ymm1  */
+    YMM_L16,        /* ymm10 */
+    YMM_L16,        /* ymm11 */
+    YMM_L16,        /* ymm12 */
+    YMM_L16,        /* ymm13 */
+    YMM_L16,        /* ymm14 */
+    YMM_L16,        /* ymm15 */
+    YMMREG,         /* ymm16 */
+    YMMREG,         /* ymm17 */
+    YMMREG,         /* ymm18 */
+    YMMREG,         /* ymm19 */
+    YMM_L16,        /* ymm2  */
+    YMMREG,         /* ymm20 */
+    YMMREG,         /* ymm21 */
+    YMMREG,         /* ymm22 */
+    YMMREG,         /* ymm23 */
+    YMMREG,         /* ymm24 */
+    YMMREG,         /* ymm25 */
+    YMMREG,         /* ymm26 */
+    YMMREG,         /* ymm27 */
+    YMMREG,         /* ymm28 */
+    YMMREG,         /* ymm29 */
+    YMM_L16,        /* ymm3  */
+    YMMREG,         /* ymm30 */
+    YMMREG,         /* ymm31 */
+    YMM_L16,        /* ymm4  */
+    YMM_L16,        /* ymm5  */
+    YMM_L16,        /* ymm6  */
+    YMM_L16,        /* ymm7  */
+    YMM_L16,        /* ymm8  */
+    YMM_L16,        /* ymm9  */
+    ZMM0,           /* zmm0  */
+    ZMM_L16,        /* zmm1  */
+    ZMM_L16,        /* zmm10 */
+    ZMM_L16,        /* zmm11 */
+    ZMM_L16,        /* zmm12 */
+    ZMM_L16,        /* zmm13 */
+    ZMM_L16,        /* zmm14 */
+    ZMM_L16,        /* zmm15 */
+    ZMMREG,         /* zmm16 */
+    ZMMREG,         /* zmm17 */
+    ZMMREG,         /* zmm18 */
+    ZMMREG,         /* zmm19 */
+    ZMM_L16,        /* zmm2  */
+    ZMMREG,         /* zmm20 */
+    ZMMREG,         /* zmm21 */
+    ZMMREG,         /* zmm22 */
+    ZMMREG,         /* zmm23 */
+    ZMMREG,         /* zmm24 */
+    ZMMREG,         /* zmm25 */
+    ZMMREG,         /* zmm26 */
+    ZMMREG,         /* zmm27 */
+    ZMMREG,         /* zmm28 */
+    ZMMREG,         /* zmm29 */
+    ZMM_L16,        /* zmm3  */
+    ZMMREG,         /* zmm30 */
+    ZMMREG,         /* zmm31 */
+    ZMM_L16,        /* zmm4  */
+    ZMM_L16,        /* zmm5  */
+    ZMM_L16,        /* zmm6  */
+    ZMM_L16,        /* zmm7  */
+    ZMM_L16,        /* zmm8  */
+    ZMM_L16,        /* zmm9  */
+};
diff --git a/vere/ext/nasm/x86/regs.c b/vere/ext/nasm/x86/regs.c
new file mode 100644
index 0000000..1e4fd01
--- /dev/null
+++ b/vere/ext/nasm/x86/regs.c
@@ -0,0 +1,254 @@
+/* automatically generated from ./x86/regs.dat - do not edit */
+
+#include "tables.h"
+
+const char * const nasm_reg_names[] = {
+    "ah",
+    "al",
+    "ax",
+    "bh",
+    "bl",
+    "bnd0",
+    "bnd1",
+    "bnd2",
+    "bnd3",
+    "bp",
+    "bpl",
+    "bx",
+    "ch",
+    "cl",
+    "cr0",
+    "cr1",
+    "cr10",
+    "cr11",
+    "cr12",
+    "cr13",
+    "cr14",
+    "cr15",
+    "cr2",
+    "cr3",
+    "cr4",
+    "cr5",
+    "cr6",
+    "cr7",
+    "cr8",
+    "cr9",
+    "cs",
+    "cx",
+    "dh",
+    "di",
+    "dil",
+    "dl",
+    "dr0",
+    "dr1",
+    "dr10",
+    "dr11",
+    "dr12",
+    "dr13",
+    "dr14",
+    "dr15",
+    "dr2",
+    "dr3",
+    "dr4",
+    "dr5",
+    "dr6",
+    "dr7",
+    "dr8",
+    "dr9",
+    "ds",
+    "dx",
+    "eax",
+    "ebp",
+    "ebx",
+    "ecx",
+    "edi",
+    "edx",
+    "es",
+    "esi",
+    "esp",
+    "fs",
+    "gs",
+    "k0",
+    "k1",
+    "k2",
+    "k3",
+    "k4",
+    "k5",
+    "k6",
+    "k7",
+    "mm0",
+    "mm1",
+    "mm2",
+    "mm3",
+    "mm4",
+    "mm5",
+    "mm6",
+    "mm7",
+    "r10",
+    "r10b",
+    "r10d",
+    "r10w",
+    "r11",
+    "r11b",
+    "r11d",
+    "r11w",
+    "r12",
+    "r12b",
+    "r12d",
+    "r12w",
+    "r13",
+    "r13b",
+    "r13d",
+    "r13w",
+    "r14",
+    "r14b",
+    "r14d",
+    "r14w",
+    "r15",
+    "r15b",
+    "r15d",
+    "r15w",
+    "r8",
+    "r8b",
+    "r8d",
+    "r8w",
+    "r9",
+    "r9b",
+    "r9d",
+    "r9w",
+    "rax",
+    "rbp",
+    "rbx",
+    "rcx",
+    "rdi",
+    "rdx",
+    "rsi",
+    "rsp",
+    "segr6",
+    "segr7",
+    "si",
+    "sil",
+    "sp",
+    "spl",
+    "ss",
+    "st0",
+    "st1",
+    "st2",
+    "st3",
+    "st4",
+    "st5",
+    "st6",
+    "st7",
+    "tmm0",
+    "tmm1",
+    "tmm2",
+    "tmm3",
+    "tmm4",
+    "tmm5",
+    "tmm6",
+    "tmm7",
+    "tr0",
+    "tr1",
+    "tr2",
+    "tr3",
+    "tr4",
+    "tr5",
+    "tr6",
+    "tr7",
+    "xmm0",
+    "xmm1",
+    "xmm10",
+    "xmm11",
+    "xmm12",
+    "xmm13",
+    "xmm14",
+    "xmm15",
+    "xmm16",
+    "xmm17",
+    "xmm18",
+    "xmm19",
+    "xmm2",
+    "xmm20",
+    "xmm21",
+    "xmm22",
+    "xmm23",
+    "xmm24",
+    "xmm25",
+    "xmm26",
+    "xmm27",
+    "xmm28",
+    "xmm29",
+    "xmm3",
+    "xmm30",
+    "xmm31",
+    "xmm4",
+    "xmm5",
+    "xmm6",
+    "xmm7",
+    "xmm8",
+    "xmm9",
+    "ymm0",
+    "ymm1",
+    "ymm10",
+    "ymm11",
+    "ymm12",
+    "ymm13",
+    "ymm14",
+    "ymm15",
+    "ymm16",
+    "ymm17",
+    "ymm18",
+    "ymm19",
+    "ymm2",
+    "ymm20",
+    "ymm21",
+    "ymm22",
+    "ymm23",
+    "ymm24",
+    "ymm25",
+    "ymm26",
+    "ymm27",
+    "ymm28",
+    "ymm29",
+    "ymm3",
+    "ymm30",
+    "ymm31",
+    "ymm4",
+    "ymm5",
+    "ymm6",
+    "ymm7",
+    "ymm8",
+    "ymm9",
+    "zmm0",
+    "zmm1",
+    "zmm10",
+    "zmm11",
+    "zmm12",
+    "zmm13",
+    "zmm14",
+    "zmm15",
+    "zmm16",
+    "zmm17",
+    "zmm18",
+    "zmm19",
+    "zmm2",
+    "zmm20",
+    "zmm21",
+    "zmm22",
+    "zmm23",
+    "zmm24",
+    "zmm25",
+    "zmm26",
+    "zmm27",
+    "zmm28",
+    "zmm29",
+    "zmm3",
+    "zmm30",
+    "zmm31",
+    "zmm4",
+    "zmm5",
+    "zmm6",
+    "zmm7",
+    "zmm8",
+    "zmm9"
+};
diff --git a/vere/ext/nasm/x86/regs.dat b/vere/ext/nasm/x86/regs.dat
new file mode 100644
index 0000000..cec8420
--- /dev/null
+++ b/vere/ext/nasm/x86/regs.dat
@@ -0,0 +1,141 @@
+## --------------------------------------------------------------------------
+##   
+##   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##     
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# List of registers and their classes; classes are defined in nasm.h
+#
+# The columns are:
+#
+# register name, assembler class, disassembler class(es), x86 register number[, token flag]
+#
+# If the register name ends in two numbers separated by a dash, then it is
+# repeated as many times as indicated, and the register number is
+# updated with it.
+#
+# If 'token flag' is present, this value will be assigned to tokflag field in
+# 'struct tokendata tokendata[]' table. Token flag can be used for specifying
+# special usage of corresponding register. E.g. opmask registers can be either
+# enclosed by curly braces or standalone operand depending on the usage.
+#
+
+# General-purpose registers
+al	REG_AL		reg8,reg8_rex	0
+ah	REG_HIGH	reg8		4
+ax	REG_AX		reg16		0
+eax	REG_EAX		reg32		0
+rax	REG_RAX		reg64		0
+bl	REG8NA		reg8,reg8_rex	3
+bh	REG_HIGH	reg8		7
+bx	REG16NA		reg16		3
+ebx	REG32NA		reg32		3
+rbx	REG64NA		reg64		3
+cl	REG_CL		reg8,reg8_rex	1
+ch	REG_HIGH	reg8		5
+cx	REG_CX		reg16		1
+ecx	REG_ECX		reg32		1
+rcx	REG_RCX		reg64		1
+dl	REG_DL		reg8,reg8_rex	2
+dh	REG_HIGH	reg8		6
+dx	REG_DX		reg16		2
+edx	REG_EDX		reg32		2
+rdx	REG_RDX		reg64		2
+spl	REG8NA		reg8_rex	4
+sp	REG16NA		reg16		4
+esp	REG32NA		reg32		4
+rsp	REG64NA		reg64		4
+bpl	REG8NA		reg8_rex	5
+bp	REG16NA		reg16		5
+ebp	REG32NA		reg32		5
+rbp	REG64NA		reg64		5
+sil	REG8NA		reg8_rex	6
+si	REG16NA		reg16		6
+esi	REG32NA		reg32		6
+rsi	REG64NA		reg64		6
+dil	REG8NA		reg8_rex	7
+di	REG16NA		reg16		7
+edi	REG32NA		reg32		7
+rdi	REG64NA		reg64		7
+r8-15b	REG8NA		reg8_rex	8
+r8-15w	REG16NA		reg16		8
+r8-15d	REG32NA		reg32		8
+r8-15	REG64NA		reg64		8
+
+# Segment registers
+es	REG_ES		sreg		0
+cs	REG_CS		sreg		1
+ss	REG_SS		sreg		2
+ds	REG_DS		sreg		3
+fs	REG_FS		sreg		4
+gs	REG_GS		sreg		5
+segr6-7	REG_SEG67	sreg		6
+
+# Control registers
+cr0-15	REG_CREG	creg		0
+
+# Debug registers
+dr0-15	REG_DREG	dreg		0
+
+# Test registers
+tr0-7	REG_TREG	treg		0
+
+# Floating-point registers
+st0	FPU0		fpureg		0
+st1-7	FPUREG		fpureg		1
+
+# MMX registers
+mm0-7	MMXREG		mmxreg		0
+
+# SSE registers
+xmm0	XMM0		xmmreg		0
+xmm1-15	XMM_L16		xmmreg		1
+xmm16-31	XMMREG		xmmreg		16
+
+# AVX registers
+ymm0	YMM0		ymmreg		0
+ymm1-15	YMM_L16		ymmreg		1
+ymm16-31	YMMREG		ymmreg		16
+
+# AVX512 registers
+zmm0	ZMM0		zmmreg		0
+zmm1-15	ZMM_L16		zmmreg		1
+zmm16-31	ZMMREG		zmmreg		16
+
+# AMX tile registers
+tmm0-7	TMMREG		tmmreg		0
+
+# Opmask registers
+k0	OPMASK0		opmaskreg	0
+k1-7	OPMASKREG	opmaskreg	1   TFLAG_BRC_OPT
+
+# Bounds registers
+bnd0-3	BNDREG		bndreg		0
diff --git a/vere/ext/nasm/x86/regs.h b/vere/ext/nasm/x86/regs.h
new file mode 100644
index 0000000..f1bca71
--- /dev/null
+++ b/vere/ext/nasm/x86/regs.h
@@ -0,0 +1,514 @@
+/* automatically generated from ./x86/regs.dat - do not edit */
+
+#ifndef NASM_REGS_H
+#define NASM_REGS_H
+
+#define EXPR_REG_START 1
+
+enum reg_enum {
+    R_zero = 0,
+    R_none = -1,
+    R_AH = EXPR_REG_START,
+    R_AL,
+    R_AX,
+    R_BH,
+    R_BL,
+    R_BND0,
+    R_BND1,
+    R_BND2,
+    R_BND3,
+    R_BP,
+    R_BPL,
+    R_BX,
+    R_CH,
+    R_CL,
+    R_CR0,
+    R_CR1,
+    R_CR10,
+    R_CR11,
+    R_CR12,
+    R_CR13,
+    R_CR14,
+    R_CR15,
+    R_CR2,
+    R_CR3,
+    R_CR4,
+    R_CR5,
+    R_CR6,
+    R_CR7,
+    R_CR8,
+    R_CR9,
+    R_CS,
+    R_CX,
+    R_DH,
+    R_DI,
+    R_DIL,
+    R_DL,
+    R_DR0,
+    R_DR1,
+    R_DR10,
+    R_DR11,
+    R_DR12,
+    R_DR13,
+    R_DR14,
+    R_DR15,
+    R_DR2,
+    R_DR3,
+    R_DR4,
+    R_DR5,
+    R_DR6,
+    R_DR7,
+    R_DR8,
+    R_DR9,
+    R_DS,
+    R_DX,
+    R_EAX,
+    R_EBP,
+    R_EBX,
+    R_ECX,
+    R_EDI,
+    R_EDX,
+    R_ES,
+    R_ESI,
+    R_ESP,
+    R_FS,
+    R_GS,
+    R_K0,
+    R_K1,
+    R_K2,
+    R_K3,
+    R_K4,
+    R_K5,
+    R_K6,
+    R_K7,
+    R_MM0,
+    R_MM1,
+    R_MM2,
+    R_MM3,
+    R_MM4,
+    R_MM5,
+    R_MM6,
+    R_MM7,
+    R_R10,
+    R_R10B,
+    R_R10D,
+    R_R10W,
+    R_R11,
+    R_R11B,
+    R_R11D,
+    R_R11W,
+    R_R12,
+    R_R12B,
+    R_R12D,
+    R_R12W,
+    R_R13,
+    R_R13B,
+    R_R13D,
+    R_R13W,
+    R_R14,
+    R_R14B,
+    R_R14D,
+    R_R14W,
+    R_R15,
+    R_R15B,
+    R_R15D,
+    R_R15W,
+    R_R8,
+    R_R8B,
+    R_R8D,
+    R_R8W,
+    R_R9,
+    R_R9B,
+    R_R9D,
+    R_R9W,
+    R_RAX,
+    R_RBP,
+    R_RBX,
+    R_RCX,
+    R_RDI,
+    R_RDX,
+    R_RSI,
+    R_RSP,
+    R_SEGR6,
+    R_SEGR7,
+    R_SI,
+    R_SIL,
+    R_SP,
+    R_SPL,
+    R_SS,
+    R_ST0,
+    R_ST1,
+    R_ST2,
+    R_ST3,
+    R_ST4,
+    R_ST5,
+    R_ST6,
+    R_ST7,
+    R_TMM0,
+    R_TMM1,
+    R_TMM2,
+    R_TMM3,
+    R_TMM4,
+    R_TMM5,
+    R_TMM6,
+    R_TMM7,
+    R_TR0,
+    R_TR1,
+    R_TR2,
+    R_TR3,
+    R_TR4,
+    R_TR5,
+    R_TR6,
+    R_TR7,
+    R_XMM0,
+    R_XMM1,
+    R_XMM10,
+    R_XMM11,
+    R_XMM12,
+    R_XMM13,
+    R_XMM14,
+    R_XMM15,
+    R_XMM16,
+    R_XMM17,
+    R_XMM18,
+    R_XMM19,
+    R_XMM2,
+    R_XMM20,
+    R_XMM21,
+    R_XMM22,
+    R_XMM23,
+    R_XMM24,
+    R_XMM25,
+    R_XMM26,
+    R_XMM27,
+    R_XMM28,
+    R_XMM29,
+    R_XMM3,
+    R_XMM30,
+    R_XMM31,
+    R_XMM4,
+    R_XMM5,
+    R_XMM6,
+    R_XMM7,
+    R_XMM8,
+    R_XMM9,
+    R_YMM0,
+    R_YMM1,
+    R_YMM10,
+    R_YMM11,
+    R_YMM12,
+    R_YMM13,
+    R_YMM14,
+    R_YMM15,
+    R_YMM16,
+    R_YMM17,
+    R_YMM18,
+    R_YMM19,
+    R_YMM2,
+    R_YMM20,
+    R_YMM21,
+    R_YMM22,
+    R_YMM23,
+    R_YMM24,
+    R_YMM25,
+    R_YMM26,
+    R_YMM27,
+    R_YMM28,
+    R_YMM29,
+    R_YMM3,
+    R_YMM30,
+    R_YMM31,
+    R_YMM4,
+    R_YMM5,
+    R_YMM6,
+    R_YMM7,
+    R_YMM8,
+    R_YMM9,
+    R_ZMM0,
+    R_ZMM1,
+    R_ZMM10,
+    R_ZMM11,
+    R_ZMM12,
+    R_ZMM13,
+    R_ZMM14,
+    R_ZMM15,
+    R_ZMM16,
+    R_ZMM17,
+    R_ZMM18,
+    R_ZMM19,
+    R_ZMM2,
+    R_ZMM20,
+    R_ZMM21,
+    R_ZMM22,
+    R_ZMM23,
+    R_ZMM24,
+    R_ZMM25,
+    R_ZMM26,
+    R_ZMM27,
+    R_ZMM28,
+    R_ZMM29,
+    R_ZMM3,
+    R_ZMM30,
+    R_ZMM31,
+    R_ZMM4,
+    R_ZMM5,
+    R_ZMM6,
+    R_ZMM7,
+    R_ZMM8,
+    R_ZMM9,
+    REG_ENUM_LIMIT
+};
+
+#define EXPR_REG_END 248
+
+#define REG_NUM_AH       4
+#define REG_NUM_AL       0
+#define REG_NUM_AX       0
+#define REG_NUM_BH       7
+#define REG_NUM_BL       3
+#define REG_NUM_BND0     0
+#define REG_NUM_BND1     1
+#define REG_NUM_BND2     2
+#define REG_NUM_BND3     3
+#define REG_NUM_BP       5
+#define REG_NUM_BPL      5
+#define REG_NUM_BX       3
+#define REG_NUM_CH       5
+#define REG_NUM_CL       1
+#define REG_NUM_CR0      0
+#define REG_NUM_CR1      1
+#define REG_NUM_CR10    10
+#define REG_NUM_CR11    11
+#define REG_NUM_CR12    12
+#define REG_NUM_CR13    13
+#define REG_NUM_CR14    14
+#define REG_NUM_CR15    15
+#define REG_NUM_CR2      2
+#define REG_NUM_CR3      3
+#define REG_NUM_CR4      4
+#define REG_NUM_CR5      5
+#define REG_NUM_CR6      6
+#define REG_NUM_CR7      7
+#define REG_NUM_CR8      8
+#define REG_NUM_CR9      9
+#define REG_NUM_CS       1
+#define REG_NUM_CX       1
+#define REG_NUM_DH       6
+#define REG_NUM_DI       7
+#define REG_NUM_DIL      7
+#define REG_NUM_DL       2
+#define REG_NUM_DR0      0
+#define REG_NUM_DR1      1
+#define REG_NUM_DR10    10
+#define REG_NUM_DR11    11
+#define REG_NUM_DR12    12
+#define REG_NUM_DR13    13
+#define REG_NUM_DR14    14
+#define REG_NUM_DR15    15
+#define REG_NUM_DR2      2
+#define REG_NUM_DR3      3
+#define REG_NUM_DR4      4
+#define REG_NUM_DR5      5
+#define REG_NUM_DR6      6
+#define REG_NUM_DR7      7
+#define REG_NUM_DR8      8
+#define REG_NUM_DR9      9
+#define REG_NUM_DS       3
+#define REG_NUM_DX       2
+#define REG_NUM_EAX      0
+#define REG_NUM_EBP      5
+#define REG_NUM_EBX      3
+#define REG_NUM_ECX      1
+#define REG_NUM_EDI      7
+#define REG_NUM_EDX      2
+#define REG_NUM_ES       0
+#define REG_NUM_ESI      6
+#define REG_NUM_ESP      4
+#define REG_NUM_FS       4
+#define REG_NUM_GS       5
+#define REG_NUM_K0       0
+#define REG_NUM_K1       1
+#define REG_NUM_K2       2
+#define REG_NUM_K3       3
+#define REG_NUM_K4       4
+#define REG_NUM_K5       5
+#define REG_NUM_K6       6
+#define REG_NUM_K7       7
+#define REG_NUM_MM0      0
+#define REG_NUM_MM1      1
+#define REG_NUM_MM2      2
+#define REG_NUM_MM3      3
+#define REG_NUM_MM4      4
+#define REG_NUM_MM5      5
+#define REG_NUM_MM6      6
+#define REG_NUM_MM7      7
+#define REG_NUM_R10     10
+#define REG_NUM_R10B    10
+#define REG_NUM_R10D    10
+#define REG_NUM_R10W    10
+#define REG_NUM_R11     11
+#define REG_NUM_R11B    11
+#define REG_NUM_R11D    11
+#define REG_NUM_R11W    11
+#define REG_NUM_R12     12
+#define REG_NUM_R12B    12
+#define REG_NUM_R12D    12
+#define REG_NUM_R12W    12
+#define REG_NUM_R13     13
+#define REG_NUM_R13B    13
+#define REG_NUM_R13D    13
+#define REG_NUM_R13W    13
+#define REG_NUM_R14     14
+#define REG_NUM_R14B    14
+#define REG_NUM_R14D    14
+#define REG_NUM_R14W    14
+#define REG_NUM_R15     15
+#define REG_NUM_R15B    15
+#define REG_NUM_R15D    15
+#define REG_NUM_R15W    15
+#define REG_NUM_R8       8
+#define REG_NUM_R8B      8
+#define REG_NUM_R8D      8
+#define REG_NUM_R8W      8
+#define REG_NUM_R9       9
+#define REG_NUM_R9B      9
+#define REG_NUM_R9D      9
+#define REG_NUM_R9W      9
+#define REG_NUM_RAX      0
+#define REG_NUM_RBP      5
+#define REG_NUM_RBX      3
+#define REG_NUM_RCX      1
+#define REG_NUM_RDI      7
+#define REG_NUM_RDX      2
+#define REG_NUM_RSI      6
+#define REG_NUM_RSP      4
+#define REG_NUM_SEGR6    6
+#define REG_NUM_SEGR7    7
+#define REG_NUM_SI       6
+#define REG_NUM_SIL      6
+#define REG_NUM_SP       4
+#define REG_NUM_SPL      4
+#define REG_NUM_SS       2
+#define REG_NUM_ST0      0
+#define REG_NUM_ST1      1
+#define REG_NUM_ST2      2
+#define REG_NUM_ST3      3
+#define REG_NUM_ST4      4
+#define REG_NUM_ST5      5
+#define REG_NUM_ST6      6
+#define REG_NUM_ST7      7
+#define REG_NUM_TMM0     0
+#define REG_NUM_TMM1     1
+#define REG_NUM_TMM2     2
+#define REG_NUM_TMM3     3
+#define REG_NUM_TMM4     4
+#define REG_NUM_TMM5     5
+#define REG_NUM_TMM6     6
+#define REG_NUM_TMM7     7
+#define REG_NUM_TR0      0
+#define REG_NUM_TR1      1
+#define REG_NUM_TR2      2
+#define REG_NUM_TR3      3
+#define REG_NUM_TR4      4
+#define REG_NUM_TR5      5
+#define REG_NUM_TR6      6
+#define REG_NUM_TR7      7
+#define REG_NUM_XMM0     0
+#define REG_NUM_XMM1     1
+#define REG_NUM_XMM10   10
+#define REG_NUM_XMM11   11
+#define REG_NUM_XMM12   12
+#define REG_NUM_XMM13   13
+#define REG_NUM_XMM14   14
+#define REG_NUM_XMM15   15
+#define REG_NUM_XMM16   16
+#define REG_NUM_XMM17   17
+#define REG_NUM_XMM18   18
+#define REG_NUM_XMM19   19
+#define REG_NUM_XMM2     2
+#define REG_NUM_XMM20   20
+#define REG_NUM_XMM21   21
+#define REG_NUM_XMM22   22
+#define REG_NUM_XMM23   23
+#define REG_NUM_XMM24   24
+#define REG_NUM_XMM25   25
+#define REG_NUM_XMM26   26
+#define REG_NUM_XMM27   27
+#define REG_NUM_XMM28   28
+#define REG_NUM_XMM29   29
+#define REG_NUM_XMM3     3
+#define REG_NUM_XMM30   30
+#define REG_NUM_XMM31   31
+#define REG_NUM_XMM4     4
+#define REG_NUM_XMM5     5
+#define REG_NUM_XMM6     6
+#define REG_NUM_XMM7     7
+#define REG_NUM_XMM8     8
+#define REG_NUM_XMM9     9
+#define REG_NUM_YMM0     0
+#define REG_NUM_YMM1     1
+#define REG_NUM_YMM10   10
+#define REG_NUM_YMM11   11
+#define REG_NUM_YMM12   12
+#define REG_NUM_YMM13   13
+#define REG_NUM_YMM14   14
+#define REG_NUM_YMM15   15
+#define REG_NUM_YMM16   16
+#define REG_NUM_YMM17   17
+#define REG_NUM_YMM18   18
+#define REG_NUM_YMM19   19
+#define REG_NUM_YMM2     2
+#define REG_NUM_YMM20   20
+#define REG_NUM_YMM21   21
+#define REG_NUM_YMM22   22
+#define REG_NUM_YMM23   23
+#define REG_NUM_YMM24   24
+#define REG_NUM_YMM25   25
+#define REG_NUM_YMM26   26
+#define REG_NUM_YMM27   27
+#define REG_NUM_YMM28   28
+#define REG_NUM_YMM29   29
+#define REG_NUM_YMM3     3
+#define REG_NUM_YMM30   30
+#define REG_NUM_YMM31   31
+#define REG_NUM_YMM4     4
+#define REG_NUM_YMM5     5
+#define REG_NUM_YMM6     6
+#define REG_NUM_YMM7     7
+#define REG_NUM_YMM8     8
+#define REG_NUM_YMM9     9
+#define REG_NUM_ZMM0     0
+#define REG_NUM_ZMM1     1
+#define REG_NUM_ZMM10   10
+#define REG_NUM_ZMM11   11
+#define REG_NUM_ZMM12   12
+#define REG_NUM_ZMM13   13
+#define REG_NUM_ZMM14   14
+#define REG_NUM_ZMM15   15
+#define REG_NUM_ZMM16   16
+#define REG_NUM_ZMM17   17
+#define REG_NUM_ZMM18   18
+#define REG_NUM_ZMM19   19
+#define REG_NUM_ZMM2     2
+#define REG_NUM_ZMM20   20
+#define REG_NUM_ZMM21   21
+#define REG_NUM_ZMM22   22
+#define REG_NUM_ZMM23   23
+#define REG_NUM_ZMM24   24
+#define REG_NUM_ZMM25   25
+#define REG_NUM_ZMM26   26
+#define REG_NUM_ZMM27   27
+#define REG_NUM_ZMM28   28
+#define REG_NUM_ZMM29   29
+#define REG_NUM_ZMM3     3
+#define REG_NUM_ZMM30   30
+#define REG_NUM_ZMM31   31
+#define REG_NUM_ZMM4     4
+#define REG_NUM_ZMM5     5
+#define REG_NUM_ZMM6     6
+#define REG_NUM_ZMM7     7
+#define REG_NUM_ZMM8     8
+#define REG_NUM_ZMM9     9
+
+
+#endif /* NASM_REGS_H */
diff --git a/vere/ext/nasm/x86/regs.pl b/vere/ext/nasm/x86/regs.pl
new file mode 100755
index 0000000..31a3fb3
--- /dev/null
+++ b/vere/ext/nasm/x86/regs.pl
@@ -0,0 +1,205 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##   
+##   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##     
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# Read regs.dat and output regs.h and regs.c (included in names.c)
+#
+
+$nline = 0;
+
+sub toint($) {
+    my($v) = @_;
+
+    return ($v =~ /^0/) ? oct $v : $v+0;
+}
+
+sub process_line($) {
+    my($line) = @_;
+    my @v;
+
+    if ( $line !~ /^\s*(\S+)\s*(\S+)\s*(\S+)\s*([0-9]+)\s*(\S*)/i ) {
+	die "regs.dat:$nline: invalid input\n";
+    }
+    $reg      = $1;
+    $aclass   = $2;
+    $dclasses = $3;
+    $x86regno = toint($4);
+
+    if ($reg =~ /^(.*[^0-9])([0-9]+)\-([0-9]+)(|[^0-9].*)$/) {
+	$nregs = $3-$2+1;
+	$reg = $1.$2.$4;
+	$reg_nr = $2;
+	$reg_prefix = $1;
+	$reg_suffix = $4;
+    } else {
+	$nregs = 1;
+	undef $reg_prefix;
+	undef $reg_suffix;
+    }
+
+    while ($nregs--) {
+	$regs{$reg} = $aclass;
+	$regvals{$reg} = $x86regno;
+
+	foreach $dclass (split(/,/, $dclasses)) {
+	    if ( !defined($disclass{$dclass}) ) {
+		$disclass{$dclass} = [];
+	    }
+
+	    $disclass{$dclass}->[$x86regno] = $reg;
+	}
+
+	# Compute the next register, if any
+	if (defined($reg_prefix)) {
+	    $x86regno++;
+	    $reg_nr++;
+	    $reg = sprintf("%s%u%s", $reg_prefix, $reg_nr, $reg_suffix);
+	} else {
+	    # Not a dashed sequence
+	    die if ($nregs);
+	}
+    }
+}
+
+($fmt, $file) = @ARGV;
+
+%regs = ();
+%regvals = ();
+%disclass = ();
+open(REGS, '<', $file) or die "$0: Cannot open $file\n";
+while ( defined($line = <REGS>) ) {
+    $nline++;
+
+    chomp $line;
+    $line =~ s/\s*(\#.*|)$//;
+
+    next if ( $line eq '' );
+
+    process_line($line);
+}
+close(REGS);
+
+if ( $fmt eq 'h' ) {
+    # Output regs.h
+    print "/* automatically generated from $file - do not edit */\n\n";
+    print "#ifndef NASM_REGS_H\n";
+    print "#define NASM_REGS_H\n\n";
+
+    $expr_regs = 1;
+    printf "#define EXPR_REG_START %d\n\n", $expr_regs;
+    print "enum reg_enum {\n";
+    # Unfortunately the code uses both 0 and -1 as "no register" in
+    # different places...
+    print "    R_zero = 0,\n";
+    print "    R_none = -1,\n";
+    $attach = ' = EXPR_REG_START'; # EXPR_REG_START == 1
+    foreach $reg ( sort(keys(%regs)) ) {
+	print "    R_\U${reg}\E${attach},\n";
+	$attach = '';
+	$expr_regs++;
+    }
+    print "    REG_ENUM_LIMIT\n";
+    print "};\n\n";
+    printf "#define EXPR_REG_END %d\n\n", $expr_regs-1;
+    foreach $reg ( sort(keys(%regs)) ) {
+	printf "#define %-15s %2d\n", "REG_NUM_\U${reg}", $regvals{$reg};
+    }
+    print "\n\n#endif /* NASM_REGS_H */\n";
+} elsif ( $fmt eq 'c' ) {
+    # Output regs.c
+    print "/* automatically generated from $file - do not edit */\n\n";
+    print "#include \"tables.h\"\n\n";
+    print "const char * const nasm_reg_names[] = "; $ch = '{';
+    # This one has no dummy entry for 0
+    foreach $reg ( sort(keys(%regs)) ) {
+	print "$ch\n    \"${reg}\"";
+	$ch = ',';
+    }
+    print "\n};\n";
+} elsif ( $fmt eq 'fc' ) {
+    # Output regflags.c
+    print "/* automatically generated from $file - do not edit */\n\n";
+    print "#include \"tables.h\"\n";
+    print "#include \"nasm.h\"\n\n";
+    print "const opflags_t nasm_reg_flags[] = {\n";
+    printf "    0,\n";		# Dummy entry for 0
+    foreach $reg ( sort(keys(%regs)) ) {
+	# Print the class of the register
+	printf "    %-15s /* %-5s */\n",
+		$regs{$reg}.',', $reg;
+    }
+    print "};\n";
+} elsif ( $fmt eq 'vc' ) {
+    # Output regvals.c
+    print "/* automatically generated from $file - do not edit */\n\n";
+    print "#include \"tables.h\"\n\n";
+    print "const int nasm_regvals[] = {\n";
+    print "    -1,\n";		# Dummy entry for 0
+    foreach $reg ( sort(keys(%regs)) ) {
+	# Print the x86 value of the register
+	printf "    %2d,  /* %-5s */\n", $regvals{$reg}, $reg;
+    }
+    print "};\n";
+} elsif ( $fmt eq 'dc' ) {
+    # Output regdis.c
+    print "/* automatically generated from $file - do not edit */\n\n";
+    print "#include \"regdis.h\"\n\n";
+    foreach $class ( sort(keys(%disclass)) ) {
+	printf "const enum reg_enum nasm_rd_%-8s[%2d] = {",
+		$class, scalar @{$disclass{$class}};
+	@foo = @{$disclass{$class}};
+	@bar = ();
+	for ( $i = 0 ; $i < scalar(@foo) ; $i++ ) {
+            if (defined($foo[$i])) {
+		push(@bar, "R_\U$foo[$i]\E");
+	    } else {
+		die "$0: No register name for class $class, value $i\n";
+            }
+	}
+	print join(',', @bar), "};\n";
+    }
+} elsif ( $fmt eq 'dh' ) {
+    # Output regdis.h
+    print "/* automatically generated from $file - do not edit */\n\n";
+    print "#ifndef NASM_REGDIS_H\n";
+    print "#define NASM_REGDIS_H\n\n";
+    print "#include \"regs.h\"\n\n";
+    foreach $class ( sort(keys(%disclass)) ) {
+	printf "extern const enum reg_enum nasm_rd_%-8s[%2d];\n",
+		$class, scalar @{$disclass{$class}};
+    }
+    print "\n#endif /* NASM_REGDIS_H */\n";
+} else {
+    die "$0: Unknown output format\n";
+}
diff --git a/vere/ext/nasm/x86/regvals.c b/vere/ext/nasm/x86/regvals.c
new file mode 100644
index 0000000..458abb7
--- /dev/null
+++ b/vere/ext/nasm/x86/regvals.c
@@ -0,0 +1,255 @@
+/* automatically generated from ./x86/regs.dat - do not edit */
+
+#include "tables.h"
+
+const int nasm_regvals[] = {
+    -1,
+     4,  /* ah    */
+     0,  /* al    */
+     0,  /* ax    */
+     7,  /* bh    */
+     3,  /* bl    */
+     0,  /* bnd0  */
+     1,  /* bnd1  */
+     2,  /* bnd2  */
+     3,  /* bnd3  */
+     5,  /* bp    */
+     5,  /* bpl   */
+     3,  /* bx    */
+     5,  /* ch    */
+     1,  /* cl    */
+     0,  /* cr0   */
+     1,  /* cr1   */
+    10,  /* cr10  */
+    11,  /* cr11  */
+    12,  /* cr12  */
+    13,  /* cr13  */
+    14,  /* cr14  */
+    15,  /* cr15  */
+     2,  /* cr2   */
+     3,  /* cr3   */
+     4,  /* cr4   */
+     5,  /* cr5   */
+     6,  /* cr6   */
+     7,  /* cr7   */
+     8,  /* cr8   */
+     9,  /* cr9   */
+     1,  /* cs    */
+     1,  /* cx    */
+     6,  /* dh    */
+     7,  /* di    */
+     7,  /* dil   */
+     2,  /* dl    */
+     0,  /* dr0   */
+     1,  /* dr1   */
+    10,  /* dr10  */
+    11,  /* dr11  */
+    12,  /* dr12  */
+    13,  /* dr13  */
+    14,  /* dr14  */
+    15,  /* dr15  */
+     2,  /* dr2   */
+     3,  /* dr3   */
+     4,  /* dr4   */
+     5,  /* dr5   */
+     6,  /* dr6   */
+     7,  /* dr7   */
+     8,  /* dr8   */
+     9,  /* dr9   */
+     3,  /* ds    */
+     2,  /* dx    */
+     0,  /* eax   */
+     5,  /* ebp   */
+     3,  /* ebx   */
+     1,  /* ecx   */
+     7,  /* edi   */
+     2,  /* edx   */
+     0,  /* es    */
+     6,  /* esi   */
+     4,  /* esp   */
+     4,  /* fs    */
+     5,  /* gs    */
+     0,  /* k0    */
+     1,  /* k1    */
+     2,  /* k2    */
+     3,  /* k3    */
+     4,  /* k4    */
+     5,  /* k5    */
+     6,  /* k6    */
+     7,  /* k7    */
+     0,  /* mm0   */
+     1,  /* mm1   */
+     2,  /* mm2   */
+     3,  /* mm3   */
+     4,  /* mm4   */
+     5,  /* mm5   */
+     6,  /* mm6   */
+     7,  /* mm7   */
+    10,  /* r10   */
+    10,  /* r10b  */
+    10,  /* r10d  */
+    10,  /* r10w  */
+    11,  /* r11   */
+    11,  /* r11b  */
+    11,  /* r11d  */
+    11,  /* r11w  */
+    12,  /* r12   */
+    12,  /* r12b  */
+    12,  /* r12d  */
+    12,  /* r12w  */
+    13,  /* r13   */
+    13,  /* r13b  */
+    13,  /* r13d  */
+    13,  /* r13w  */
+    14,  /* r14   */
+    14,  /* r14b  */
+    14,  /* r14d  */
+    14,  /* r14w  */
+    15,  /* r15   */
+    15,  /* r15b  */
+    15,  /* r15d  */
+    15,  /* r15w  */
+     8,  /* r8    */
+     8,  /* r8b   */
+     8,  /* r8d   */
+     8,  /* r8w   */
+     9,  /* r9    */
+     9,  /* r9b   */
+     9,  /* r9d   */
+     9,  /* r9w   */
+     0,  /* rax   */
+     5,  /* rbp   */
+     3,  /* rbx   */
+     1,  /* rcx   */
+     7,  /* rdi   */
+     2,  /* rdx   */
+     6,  /* rsi   */
+     4,  /* rsp   */
+     6,  /* segr6 */
+     7,  /* segr7 */
+     6,  /* si    */
+     6,  /* sil   */
+     4,  /* sp    */
+     4,  /* spl   */
+     2,  /* ss    */
+     0,  /* st0   */
+     1,  /* st1   */
+     2,  /* st2   */
+     3,  /* st3   */
+     4,  /* st4   */
+     5,  /* st5   */
+     6,  /* st6   */
+     7,  /* st7   */
+     0,  /* tmm0  */
+     1,  /* tmm1  */
+     2,  /* tmm2  */
+     3,  /* tmm3  */
+     4,  /* tmm4  */
+     5,  /* tmm5  */
+     6,  /* tmm6  */
+     7,  /* tmm7  */
+     0,  /* tr0   */
+     1,  /* tr1   */
+     2,  /* tr2   */
+     3,  /* tr3   */
+     4,  /* tr4   */
+     5,  /* tr5   */
+     6,  /* tr6   */
+     7,  /* tr7   */
+     0,  /* xmm0  */
+     1,  /* xmm1  */
+    10,  /* xmm10 */
+    11,  /* xmm11 */
+    12,  /* xmm12 */
+    13,  /* xmm13 */
+    14,  /* xmm14 */
+    15,  /* xmm15 */
+    16,  /* xmm16 */
+    17,  /* xmm17 */
+    18,  /* xmm18 */
+    19,  /* xmm19 */
+     2,  /* xmm2  */
+    20,  /* xmm20 */
+    21,  /* xmm21 */
+    22,  /* xmm22 */
+    23,  /* xmm23 */
+    24,  /* xmm24 */
+    25,  /* xmm25 */
+    26,  /* xmm26 */
+    27,  /* xmm27 */
+    28,  /* xmm28 */
+    29,  /* xmm29 */
+     3,  /* xmm3  */
+    30,  /* xmm30 */
+    31,  /* xmm31 */
+     4,  /* xmm4  */
+     5,  /* xmm5  */
+     6,  /* xmm6  */
+     7,  /* xmm7  */
+     8,  /* xmm8  */
+     9,  /* xmm9  */
+     0,  /* ymm0  */
+     1,  /* ymm1  */
+    10,  /* ymm10 */
+    11,  /* ymm11 */
+    12,  /* ymm12 */
+    13,  /* ymm13 */
+    14,  /* ymm14 */
+    15,  /* ymm15 */
+    16,  /* ymm16 */
+    17,  /* ymm17 */
+    18,  /* ymm18 */
+    19,  /* ymm19 */
+     2,  /* ymm2  */
+    20,  /* ymm20 */
+    21,  /* ymm21 */
+    22,  /* ymm22 */
+    23,  /* ymm23 */
+    24,  /* ymm24 */
+    25,  /* ymm25 */
+    26,  /* ymm26 */
+    27,  /* ymm27 */
+    28,  /* ymm28 */
+    29,  /* ymm29 */
+     3,  /* ymm3  */
+    30,  /* ymm30 */
+    31,  /* ymm31 */
+     4,  /* ymm4  */
+     5,  /* ymm5  */
+     6,  /* ymm6  */
+     7,  /* ymm7  */
+     8,  /* ymm8  */
+     9,  /* ymm9  */
+     0,  /* zmm0  */
+     1,  /* zmm1  */
+    10,  /* zmm10 */
+    11,  /* zmm11 */
+    12,  /* zmm12 */
+    13,  /* zmm13 */
+    14,  /* zmm14 */
+    15,  /* zmm15 */
+    16,  /* zmm16 */
+    17,  /* zmm17 */
+    18,  /* zmm18 */
+    19,  /* zmm19 */
+     2,  /* zmm2  */
+    20,  /* zmm20 */
+    21,  /* zmm21 */
+    22,  /* zmm22 */
+    23,  /* zmm23 */
+    24,  /* zmm24 */
+    25,  /* zmm25 */
+    26,  /* zmm26 */
+    27,  /* zmm27 */
+    28,  /* zmm28 */
+    29,  /* zmm29 */
+     3,  /* zmm3  */
+    30,  /* zmm30 */
+    31,  /* zmm31 */
+     4,  /* zmm4  */
+     5,  /* zmm5  */
+     6,  /* zmm6  */
+     7,  /* zmm7  */
+     8,  /* zmm8  */
+     9,  /* zmm9  */
+};